--- old/src/java.base/share/classes/java/lang/Integer.java 2015-11-26 01:38:36.997646316 +0300 +++ new/src/java.base/share/classes/java/lang/Integer.java 2015-11-26 01:38:36.893646830 +0300 @@ -338,7 +338,6 @@ // assert shift > 0 && shift <=5 : "Illegal shift value"; int mag = Integer.SIZE - Integer.numberOfLeadingZeros(val); int chars = Math.max(((mag + (shift - 1)) / shift), 1); - if (COMPACT_STRINGS) { byte[] buf = new byte[chars]; formatUnsignedInt(val, shift, buf, 0, chars); @@ -477,7 +476,7 @@ * (negative to positive) will expose -Integer.MIN_VALUE that overflows * integer. */ - static void getChars(int i, int index, byte[] buf) { + static int getChars(int i, int index, byte[] buf) { int q, r; int charPos = index; @@ -508,9 +507,10 @@ if (negative) { buf[--charPos] = (byte)'-'; } + return charPos; } - static void getCharsUTF16(int i, int index, byte[] buf) { + static int getCharsUTF16(int i, int index, byte[] buf) { int q, r; int charPos = index; @@ -541,6 +541,7 @@ if (negative) { StringUTF16.putChar(buf, --charPos, '-'); } + return charPos; } // Left here for compatibility reasons, see JDK-8143900. --- old/src/java.base/share/classes/java/lang/Long.java 2015-11-26 01:38:37.441644124 +0300 +++ new/src/java.base/share/classes/java/lang/Long.java 2015-11-26 01:38:37.337644638 +0300 @@ -379,7 +379,6 @@ // assert shift > 0 && shift <=5 : "Illegal shift value"; int mag = Long.SIZE - Long.numberOfLeadingZeros(val); int chars = Math.max(((mag + (shift - 1)) / shift), 1); - if (COMPACT_STRINGS) { byte[] buf = new byte[chars]; formatUnsignedLong0(val, shift, buf, 0, chars); @@ -490,7 +489,7 @@ * (negative to positive) will expose -Long.MIN_VALUE that overflows * long. */ - static void getChars(long i, int index, byte[] buf) { + static int getChars(long i, int index, byte[] buf) { long q; int r; int charPos = index; @@ -533,9 +532,10 @@ if (negative) { buf[--charPos] = (byte)'-'; } + return charPos; } - static void getCharsUTF16(long i, int index, byte[] buf) { + static int getCharsUTF16(long i, int index, byte[] buf) { long q; int r; int charPos = index; @@ -578,6 +578,7 @@ if (negative) { StringUTF16.putChar(buf, --charPos, '-'); } + return charPos; } /** --- old/test/com/sun/jdi/LineNumberInfo.java 2015-11-26 01:38:38.773637548 +0300 +++ new/test/com/sun/jdi/LineNumberInfo.java 2015-11-26 01:38:38.669638061 +0300 @@ -29,7 +29,7 @@ * * @modules jdk.jdi * @run build TestScaffold VMConnection TargetListener TargetAdapter - * @run compile -g LineNumberInfo.java ControlFlow.java + * @run compile -XDstringConcat=inline -g LineNumberInfo.java ControlFlow.java * * @run driver LineNumberInfo */ --- old/test/com/sun/jdi/sde/InstallSDE.java 2015-11-26 01:38:39.213635374 +0300 +++ new/test/com/sun/jdi/sde/InstallSDE.java 2015-11-26 01:38:39.105635910 +0300 @@ -253,12 +253,16 @@ case 3: // Integer case 4: // Float case 12: // NameAndType + case 18: // InvokeDynamic copy(4); break; case 5: // Long case 6: // Double copy(8); break; + case 15: // MethodHandle + copy(3); + break; case 1: // Utf8 int len = readU2(); writeU2(len); --- old/test/java/lang/invoke/InvokeDynamicPrintArgs.java 2015-11-26 01:38:39.649633222 +0300 +++ new/test/java/lang/invoke/InvokeDynamicPrintArgs.java 2015-11-26 01:38:39.541633758 +0300 @@ -28,7 +28,7 @@ * @compile InvokeDynamicPrintArgs.java * @run main/othervm * indify.Indify - * --verify-specifier-count=3 + * --verify-specifier-count=8 * --expand-properties --classpath ${test.classes} * --java test.java.lang.invoke.InvokeDynamicPrintArgs --check-output * @run main/othervm --- old/test/java/lang/invoke/MethodHandleConstants.java 2015-11-26 01:38:40.085631070 +0300 +++ new/test/java/lang/invoke/MethodHandleConstants.java 2015-11-26 01:38:39.977631602 +0300 @@ -28,7 +28,7 @@ * @compile MethodHandleConstants.java * @run main/othervm * indify.Indify - * --verify-specifier-count=0 + * --verify-specifier-count=4 * --expand-properties --classpath ${test.classes} * --java test.java.lang.invoke.MethodHandleConstants --check-output * @run main/othervm --- /dev/null 2015-11-23 01:27:16.425045507 +0300 +++ new/src/java.base/share/classes/java/lang/StringConcatHelper.java 2015-11-26 01:38:40.413629450 +0300 @@ -0,0 +1,322 @@ +package java.lang; + +/** + * Helper for string concatenation. These methods are mostly looked up with private lookups + * from {@link java.lang.invoke.StringConcatFactory}, and used in {@link java.lang.invoke.MethodHandle} + * combinators there. + */ +class StringConcatHelper { + + private StringConcatHelper() { + // no instantiation + } + + /** + * Check for overflow, throw the exception on overflow. + * @param len String length + * @return length + */ + private static int checkOverflow(int len) { + if (len < 0) { + throw new OutOfMemoryError("Overflow: String length out of range"); + } + return len; + } + + /** + * Mix value length into current length + * @param current current length + * @param value value to mix in + * @return new length + */ + static int mixLen(int current, boolean value) { + return checkOverflow(current + (value ? 4 : 5)); + } + + /** + * Mix value length into current length + * @param current current length + * @param value value to mix in + * @return new length + */ + static int mixLen(int current, byte value) { + return mixLen(current, (int)value); + } + + /** + * Mix value length into current length + * @param current current length + * @param value value to mix in + * @return new length + */ + static int mixLen(int current, char value) { + return checkOverflow(current + 1); + } + + /** + * Mix value length into current length + * @param current current length + * @param value value to mix in + * @return new length + */ + static int mixLen(int current, short value) { + return mixLen(current, (int)value); + } + + /** + * Mix value length into current length + * @param current current length + * @param value value to mix in + * @return new length + */ + static int mixLen(int current, int value) { + return checkOverflow(current + Integer.stringSize(value)); + } + + /** + * Mix value length into current length + * @param current current length + * @param value value to mix in + * @return new length + */ + static int mixLen(int current, long value) { + return checkOverflow(current + Long.stringSize(value)); + } + + /** + * Mix value length into current length + * @param current current length + * @param value value to mix in + * @return new length + */ + static int mixLen(int current, String value) { + return checkOverflow(current + value.length()); + } + + /** + * Mix coder into current coder + * @param current current coder + * @param value value to mix in + * @return new coder + */ + static byte mixCoder(byte current, char value) { + return (byte)(current | (StringLatin1.canEncode(value) ? 0 : 1)); + } + + /** + * Mix coder into current coder + * @param current current coder + * @param value value to mix in + * @return new coder + */ + static byte mixCoder(byte current, String value) { + return (byte)(current | value.coder()); + } + + /** + * Mix coder into current coder + * @param current current coder + * @param value value to mix in + * @return new coder + */ + static byte mixCoder(byte current, boolean value) { + // Booleans are represented with Latin1 + return current; + } + + /** + * Mix coder into current coder + * @param current current coder + * @param value value to mix in + * @return new coder + */ + static byte mixCoder(byte current, byte value) { + // Bytes are represented with Latin1 + return current; + } + + /** + * Mix coder into current coder + * @param current current coder + * @param value value to mix in + * @return new coder + */ + static byte mixCoder(byte current, short value) { + // Shorts are represented with Latin1 + return current; + } + + /** + * Mix coder into current coder + * @param current current coder + * @param value value to mix in + * @return new coder + */ + static byte mixCoder(byte current, int value) { + // Ints are represented with Latin1 + return current; + } + + /** + * Mix coder into current coder + * @param current current coder + * @param value value to mix in + * @return new coder + */ + static byte mixCoder(byte current, long value) { + // Longs are represented with Latin1 + return current; + } + + /** + * Prepends the stringly representation of boolean value into buffer, + * given the coder and final index. Index is measured in chars, not in bytes! + * + * @param index final char index in the buffer + * @param buf buffer to append to + * @param coder coder to add with + * @param value boolean value to encode + * @return new index + */ + static int prepend(int index, byte[] buf, byte coder, boolean value) { + if (coder == String.LATIN1) { + if (value) { + buf[--index] = 'e'; + buf[--index] = 'u'; + buf[--index] = 'r'; + buf[--index] = 't'; + } else { + buf[--index] = 'e'; + buf[--index] = 's'; + buf[--index] = 'l'; + buf[--index] = 'a'; + buf[--index] = 'f'; + } + } else { + if (value) { + StringUTF16.putChar(buf, --index, 'e'); + StringUTF16.putChar(buf, --index, 'u'); + StringUTF16.putChar(buf, --index, 'r'); + StringUTF16.putChar(buf, --index, 't'); + } else { + StringUTF16.putChar(buf, --index, 'e'); + StringUTF16.putChar(buf, --index, 's'); + StringUTF16.putChar(buf, --index, 'l'); + StringUTF16.putChar(buf, --index, 'a'); + StringUTF16.putChar(buf, --index, 'f'); + } + } + return index; + } + + /** + * Prepends the stringly representation of byte value into buffer, + * given the coder and final index. Index is measured in chars, not in bytes! + * + * @param index final char index in the buffer + * @param buf buffer to append to + * @param coder coder to add with + * @param value byte value to encode + * @return new index + */ + static int prepend(int index, byte[] buf, byte coder, byte value) { + return prepend(index, buf, coder, (int)value); + } + + /** + * Prepends the stringly representation of char value into buffer, + * given the coder and final index. Index is measured in chars, not in bytes! + * + * @param index final char index in the buffer + * @param buf buffer to append to + * @param coder coder to add with + * @param value char value to encode + * @return new index + */ + static int prepend(int index, byte[] buf, byte coder, char value) { + if (coder == String.LATIN1) { + buf[--index] = (byte) (value & 0xFF); + } else { + StringUTF16.putChar(buf, --index, value); + } + return index; + } + + /** + * Prepends the stringly representation of short value into buffer, + * given the coder and final index. Index is measured in chars, not in bytes! + * + * @param index final char index in the buffer + * @param buf buffer to append to + * @param coder coder to add with + * @param value short value to encode + * @return new index + */ + static int prepend(int index, byte[] buf, byte coder, short value) { + return prepend(index, buf, coder, (int)value); + } + + /** + * Prepends the stringly representation of integer value into buffer, + * given the coder and final index. Index is measured in chars, not in bytes! + * + * @param index final char index in the buffer + * @param buf buffer to append to + * @param coder coder to add with + * @param value integer value to encode + * @return new index + */ + static int prepend(int index, byte[] buf, byte coder, int value) { + if (coder == String.LATIN1) { + return Integer.getChars(value, index, buf); + } else { + return Integer.getCharsUTF16(value, index, buf); + } + } + + /** + * Prepends the stringly representation of long value into buffer, + * given the coder and final index. Index is measured in chars, not in bytes! + * + * @param index final char index in the buffer + * @param buf buffer to append to + * @param coder coder to add with + * @param value long value to encode + * @return new index + */ + static int prepend(int index, byte[] buf, byte coder, long value) { + if (coder == String.LATIN1) { + return Long.getChars(value, index, buf); + } else { + return Long.getCharsUTF16(value, index, buf); + } + } + + /** + * Prepends the stringly representation of String value into buffer, + * given the coder and final index. Index is measured in chars, not in bytes! + * + * @param index final char index in the buffer + * @param buf buffer to append to + * @param coder coder to add with + * @param value String value to encode + * @return new index + */ + static int prepend(int index, byte[] buf, byte coder, String value) { + index -= value.length(); + value.getBytes(buf, index, coder); + return index; + } + + /** + * Instantiates the String with given buffer and coder + * @param buf buffer to use + * @param coder coder to use + * @return String resulting string + */ + static String newString(byte[] buf, byte coder) { + // Use the private, non-copying constructor (unsafe!) + return new String(buf, coder); + } + +} --- /dev/null 2015-11-23 01:27:16.425045507 +0300 +++ new/src/java.base/share/classes/java/lang/invoke/StringConcatException.java 2015-11-26 01:38:40.849627298 +0300 @@ -0,0 +1,26 @@ +package java.lang.invoke; + +/** + * StringConcatException is thrown by {@link StringConcatFactory} when linkage + * invariants are violated. + */ +public class StringConcatException extends Exception { + private static final long serialVersionUID = 292L + 9L; + + /** + * Constructs an exception with a message + * @param msg exception message + */ + public StringConcatException(String msg) { + super(msg); + } + + /** + * Constructs an exception with a message and a linked throwable + * @param msg exception message + * @param cause throwable cause + */ + public StringConcatException(String msg, Throwable cause) { + super(msg, cause); + } +} --- /dev/null 2015-11-23 01:27:16.425045507 +0300 +++ new/src/java.base/share/classes/java/lang/invoke/StringConcatFactory.java 2015-11-26 01:38:41.289625128 +0300 @@ -0,0 +1,1790 @@ +/* + * Copyright (c) 2015, 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package java.lang.invoke; + +import jdk.internal.org.objectweb.asm.ClassWriter; +import jdk.internal.org.objectweb.asm.Label; +import jdk.internal.org.objectweb.asm.MethodVisitor; +import jdk.internal.org.objectweb.asm.Opcodes; +import sun.misc.Unsafe; + +import java.lang.invoke.MethodHandles.Lookup; +import java.security.AccessController; +import java.security.PrivilegedAction; +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; +import java.util.function.Function; + +import static jdk.internal.org.objectweb.asm.Opcodes.*; + +/** + *

Methods to facilitate the creation of String concatenation methods, that + * can be used to efficiently concatenate a known number of arguments of known + * types, possibly after type adaptation and partial evaluation of arguments. + * These methods are typically used as bootstrap methods for {@code + * invokedynamic} call sites, to support the string concatenation + * feature of the Java Programming Language. + * + *

Indirect access to the behavior specified by the provided {@code + * MethodHandle} proceeds in order through two phases: + * + *

    + *
  1. Linkage occurs when the methods in this class are invoked. + * They take as arguments a method type describing the concatenated arguments + * count and types, and optionally the String recipe, plus the + * constants that participate in the String concatenation. The details on + * accepted recipe shapes are described further below. Linkage may involve + * dynamically loading a new class that implements the expected concatenation + * behavior. The {@code CallSite} holds the {@code MethodHandle} pointing to the + * exact concatenation method. The concatenation methods may be shared among + * different {@code CallSite}s, e.g. if linkage methods produce them as pure + * functions.
    2. + * + *
  2. Invocation occurs when a generated concatenation method is + * invoked with the exact dynamic arguments. This may occur many times for a + * single concatenation method. The method referenced by the behavior {@code + * MethodHandle} is invoked with the static arguments and any additional dynamic + * arguments provided on invocation, as if by {@link MethodHandle#invoke(Object...)}.
    3. + *
+ * + *

This class provides two forms of linkage methods: a simple version + * ({@link #makeConcat(java.lang.invoke.MethodHandles.Lookup, String, + * MethodType)}) using only the dynamic arguments, and an advanced version + * ({@link #makeConcatWithConstants(java.lang.invoke.MethodHandles.Lookup, + * String, MethodType, String, Object...)} using the advanced forms of capturing + * the constant arguments. The advanced strategy can produce marginally better + * invocation bytecode, at the expense of exploding the number of shapes of + * string concatenation methods present at runtime, because those shapes would + * include constant static arguments as well. + * + * @author Aleksey Shipilev + * @author Remi Forax + * @author Peter Levart + * + * @apiNote

The recommended way to use these methods is to collect all + * concatenation arguments into dynamic arguments for the {@code invokedynamic} + * method with a bootstrap method pointing to one of the linkage methods in this + * class. A second recommended method is to move known constants from dynamic + * arguments to static arguments, produce the recipe with the order in which to + * process dynamic and static arguments. + * + *

There is a JVM limit (classfile structural constraint): no method + * can call with more than 255 slots. This limits the number of static and + * dynamic arguments one can pass to bootstrap method. Since there are potential + * concatenation strategies that use {@code MethodHandle} combinators, we need + * to reserve a few empty slots on the parameter lists to to capture the + * temporal results. This is why bootstrap methods in this factory do not accept + * more than 200 argument slots. Users requiring more than 200 argument slots in + * concatenation are expected to split the large concatenation in smaller + * expressions. + */ +public class StringConcatFactory { + + /** + * Tag used to demarcate an ordinary argument. + */ + private static final char TAG_ARG = '\u0001'; + + /** + * Tag used to demarcate a constant. + */ + private static final char TAG_CONST = '\u0002'; + + /** + * Maximum number of argument slots in String Concat call. + * + * While the maximum number of argument slots that indy call can handle is 253, + * we do not use all those slots, to let the strategies with MethodHandle + * combinators to use some arguments. + */ + private static final int MAX_INDY_CONCAT_ARG_SLOTS = 200; + + /** + * Concatenation strategy to use. See {@link Strategy} for possible options. + * This option is controllable with -Djava.lang.invoke.stringConcat JDK option. + */ + private static final Strategy STRATEGY; + + /** + * Default strategy to use for concatenation. + */ + private static final Strategy DEFAULT_STRATEGY = Strategy.BC_SB_SIZED; + + private enum Strategy { + /** + * Bytecode generator, calling into {@link java.lang.StringBuilder}. + */ + BC_SB, + + /** + * Bytecode generator, calling into {@link java.lang.StringBuilder}; + * but trying to estimate the required storage. + */ + BC_SB_SIZED, + + /** + * Bytecode generator, calling into {@link java.lang.StringBuilder}; + * but computing the required storage exactly. + */ + BC_SB_SIZED_EXACT, + + /** + * MethodHandle-based generator, that in the end calls into {@link java.lang.StringBuilder}. + * This strategy also tries to estimate the required storage. + */ + MH_SB_SIZED, + + /** + * MethodHandle-based generator, that in the end calls into {@link java.lang.StringBuilder}. + * This strategy also estimate the required storage exactly. + */ + MH_SB_SIZED_EXACT, + + /** + * MethodHandle-based generator, that constructs its own byte[] array from + * the arguments. It computes the required storage exactly. + */ + MH_INLINE_SIZED_EXACT + } + + /** + * Enables debugging: this may print debugging messages, perform additional (non-neutral for performance) + * checks, etc. + */ + private static final boolean DEBUG; + + /** + * Enables caching of strategy stubs. This may improve the linkage time by reusing the generated + * code, at the expense of contaminating the profiles. + */ + private static final boolean CACHE_ENABLE; + + private static final ConcurrentMap CACHE; + + static { + // Poke the privileged block once, taking everything we need: + final Object[] values = new Object[3]; + AccessController.doPrivileged((PrivilegedAction) () -> { + values[0] = System.getProperty("java.lang.invoke.stringConcat"); + values[1] = Boolean.getBoolean("java.lang.invoke.stringConcat.cache"); + values[2] = Boolean.getBoolean("java.lang.invoke.stringConcat.debug"); + return null; + }); + + final String strategy = (String) values[0]; + CACHE_ENABLE = (Boolean) values[1]; + DEBUG = (Boolean) values[2]; + + STRATEGY = (strategy == null) ? DEFAULT_STRATEGY : Strategy.valueOf(strategy); + CACHE = CACHE_ENABLE ? new ConcurrentHashMap<>() : null; + } + + private static final class Key { + final MethodType mt; + final Recipe recipe; + + public Key(MethodType mt, Recipe recipe) { + this.mt = mt; + this.recipe = recipe; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Key key = (Key) o; + + if (!mt.equals(key.mt)) return false; + if (!recipe.equals(key.recipe)) return false; + return true; + } + + @Override + public int hashCode() { + int result = mt.hashCode(); + result = 31 * result + recipe.hashCode(); + return result; + } + } + + /** + * Parses the recipe string, and produces the traversable collection of + * {@link java.lang.invoke.StringConcatFactory.RecipeElement}-s for generator + * strategies. Notably, this class parses out the constants from the recipe + * and from other static arguments. + */ + private static class Recipe { + private final List elements; + private final List elementsRev; + + public Recipe(String src, Object[] constants) { + List el = new ArrayList<>(); + + int constC = 0; + int argC = 0; + + StringBuilder acc = new StringBuilder(); + + for (int i = 0; i < src.length(); i++) { + char c = src.charAt(i); + + if (c == TAG_CONST || c == TAG_ARG) { + // Detected a special tag, flush all accumulated characters + // as a constant first: + if (acc.length() > 0) { + el.add(new RecipeElement(acc.toString())); + acc = new StringBuilder(); + } + if (c == TAG_CONST) { + Object cnst = constants[constC++]; + el.add(new RecipeElement(cnst)); + } + if (c == TAG_ARG) { + el.add(new RecipeElement(argC++)); + } + } else { + // Not a special characters, this is a constant embedded into + // the recipe itself. + acc.append(c); + } + } + + // Flush the remaining characters as constant: + if (acc.length() > 0) { + el.add(new RecipeElement(acc.toString())); + } + + elements = new ArrayList<>(el); + Collections.reverse(el); + elementsRev = el; + } + + public Collection getElements() { + return elements; + } + + public Collection getElementsReversed() { + return elementsRev; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Recipe recipe = (Recipe) o; + return elements.equals(recipe.elements); + } + + @Override + public int hashCode() { + return elements.hashCode(); + } + } + + private static class RecipeElement { + private final Object value; + private final int argPos; + private final Tag tag; + + public RecipeElement(Object cnst) { + this.value = cnst; + this.argPos = -1; + this.tag = Tag.CONST; + } + + public RecipeElement(int arg) { + this.value = null; + this.argPos = arg; + this.tag = Tag.ARG; + } + + public Object getValue() { + assert (tag == Tag.CONST); + return value; + } + + public int getArgPos() { + assert (tag == Tag.ARG); + return argPos; + } + + public Tag getTag() { + return tag; + } + } + + private enum Tag { + CONST, + ARG, + } + + /** + * Facilitates the creation of optimized String concatenation methods, that + * can be used to efficiently concatenate a known number of arguments of + * known types, possibly after type adaptation and partial evaluation of + * arguments. Typically used as a bootstrap method for {@code + * invokedynamic} call sites, to support the string concatenation + * feature of the Java Programming Language. + * + *

When the target of the {@code CallSite} returned from this method is + * invoked, it returns the result of String concatenation, taking all + * function arguments passed to the linkage method as inputs for + * concatenation. The target signature is given by {@code concatType}. + * The arguments are concatenated as per requirements stated in JLS 15.18.1 + * "String Concatenation Operator +". Notably, the inputs are converted as + * per JLS 5.1.11 "String Conversion", and combined from left to right. + * + *

Assume the linkage arguments are as follows: + * + *

    + *
  • {@code concatType}, describing the {@code CallSite} signature
    • + *
+ * + *

Then the following linkage invariants must hold: + * + *

    + *
  • The parameter types in {@code concatType} describe only the concatenation + * arguments (i.e. there is no receiver, the method is static)
    • + * + *
  • The parameter count in {@code concatType} is less than or equal to 200
    • + * + *
  • The return type in {@code concatType} is assignable from {@link java.lang.String}
    • + *
+ * + * @param lookup Represents a lookup context with the accessibility + * privileges of the caller. When used with {@code + * invokedynamic}, this is stacked automatically by the VM. + * This argument has no meaning for this linkage method. + * @param name The name of the method to implement. This name is + * arbitrary, and has no meaning for this linkage method. + * When used with {@code invokedynamic}, this is provided by + * the {@code NameAndType} of the {@code InvokeDynamic} + * structure and is stacked automatically by the VM. + * @param concatType The expected signature of the {@code CallSite}. The + * parameter types represent the types of concatenation + * arguments; the return type is always assignable from {@link + * java.lang.String}. When used with {@code invokedynamic}, + * this is provided by the {@code NameAndType} of the {@code + * InvokeDynamic} structure and is stacked automatically by + * the VM. + * @return a CallSite whose target can be used to perform String + * concatenation for the given {@code concatType} signature. + * @throws StringConcatException If any of the linkage invariants described + * here are violated + * @throws NullPointerException If any of the incoming arguments is null; + * This will never happen when a bootstrap method + * is called with invokedynamic. + */ + public static CallSite makeConcat(MethodHandles.Lookup lookup, + String name, + MethodType concatType) throws StringConcatException { + if (DEBUG) { + System.out.println("StringConcatFactory " + STRATEGY + " is here for " + concatType); + } + + return doStringConcat(lookup, name, concatType, true, null); + } + + /** + * Facilitates the creation of optimized String concatenation methods, that + * can be used to efficiently concatenate a known number of arguments of + * known types, possibly after type adaptation and partial evaluation of + * arguments. Typically used as a bootstrap method for {@code + * invokedynamic} call sites, to support the string concatenation + * feature of the Java Programming Language. + * + *

When the target of the {@code CallSite} returned from this method is + * invoked, it returns the result of String concatenation, taking all + * function arguments and constants passed to the linkage method as inputs for + * concatenation. The target signature is given by {@code concatType}, and + * does not include constants. The arguments are concatenated as per requirements + * stated in JLS 15.18.1 "String Concatenation Operator +". Notably, the inputs + * are converted as per JLS 5.1.11 "String Conversion", and combined from left + * to right. + * + *

The concatenation recipe is a String description for the way to + * construct a concatenated String from the arguments and constants. The + * recipe is processed from left to right, and each character represents an + * input to concatenation. Recipe characters mean: + * + *

    + * + *
  • \1 (Unicode point 0001): an ordinary argument. This + * input is passed through dynamic argument, and is provided during the + * concatenation method invocation. This input can be null.
    • + * + *
  • \2 (Unicode point 0002): a constant. This input passed + * through static bootstrap argument. This constant can be any value + * representable in constant pool. If necessary, the factory would call + * {@code toString} to perform a one-time String conversion.
    • + * + *
  • Any other char value: a single character constant.
    • + *
+ * + *

Assume the linkage arguments are as follows: + * + *

    + *
  • {@code concatType}, describing the {@code CallSite} signature
    • + *
  • {@code recipe}, describing the String recipe
    • + *
  • {@code constants}, the vararg array of constants
    • + *
+ * + *

Then the following linkage invariants must hold: + * + *

    + *
  • The parameter types in {@code concatType} describe only the + * concatenation arguments (i.e. there is no receiver, the method + * is static)
    • + * + *
  • The parameter count in {@code concatType} is less than or equal to + * 200
    • + * + *
  • The parameter count in {@code concatType} equals to number of \1 tags + * in {@code recipe}
    • + * + *
  • The return type in {@code concatType} is assignable + * from {@link java.lang.String}, and matches the return type of the + * returned {@link MethodHandle}
    • + * + *
  • The number of elements in {@code constants} equals to number of \2 + * tags in {@code recipe}
    • + * + *
  • Every element in {@code constants} is not null.
    • + *
+ * + * @param lookup Represents a lookup context with the accessibility + * privileges of the caller. When used with {@code + * invokedynamic}, this is stacked automatically by the + * VM. This argument has no meaning for this linkage method. + * @param name The name of the method to implement. This name is + * arbitrary, and has no meaning for this linkage method. + * When used with {@code invokedynamic}, this is provided + * by the {@code NameAndType} of the {@code InvokeDynamic} + * structure and is stacked automatically by the VM. + * @param concatType The expected signature of the {@code CallSite}. The + * parameter types represent the types of concatenation + * arguments; the return type is always assignable from {@link + * java.lang.String}. When used with {@code + * invokedynamic}, this is provided by the {@code + * NameAndType} of the {@code InvokeDynamic} structure and + * is stacked automatically by the VM. + * @param recipe Concatenation recipe, described above. + * @param constants A vararg parameter representing the constants passed to + * the linkage method. + * @return a CallSite whose target can be used to perform String + * concatenation for the given {@code concatType} signature. + * @throws StringConcatException If any of the linkage invariants described + * here are violated + * @throws NullPointerException If any of the incoming arguments is null; + * This will never happen when a bootstrap method + * is called with invokedynamic. + * @apiNote Code generators have three distinct ways to process a constant + * string operand S in a string concatenation expression. First, S can be + * materialized as a reference (using ldc) and passed as an ordinary argument + * (recipe '\1'). Or, S can be stored in the constant pool and passed as a + * constant (recipe '\2') . Finally, if S contains neither of the recipe + * tag characters ('\1', '\2') then S can be interpolated into the recipe + * itself, causing its characters to be inserted into the result. + */ + public static CallSite makeConcatWithConstants(MethodHandles.Lookup lookup, + String name, + MethodType concatType, + String recipe, + Object... constants) throws StringConcatException { + if (DEBUG) { + System.out.println("StringConcatFactory " + STRATEGY + " is here for " + concatType + ", {" + recipe + "}, " + Arrays.toString(constants)); + } + + return doStringConcat(lookup, name, concatType, false, recipe, constants); + } + + private static CallSite doStringConcat(MethodHandles.Lookup caller, + String name, + MethodType concatType, + boolean generateRecipe, + String recipe, + Object... constants) throws StringConcatException { + Objects.requireNonNull(caller, "Lookup is null"); + Objects.requireNonNull(name, "Name is null"); + Objects.requireNonNull(concatType, "Concat type is null"); + Objects.requireNonNull(constants, "Constants are null"); + + for (Object o : constants) { + if (o == null) { + throw new StringConcatException("Cannot accept null constants"); + } + } + + if (generateRecipe) { + // Mock the recipe to reuse the concat generator code + StringBuilder sb = new StringBuilder(); + for (int c = 0; c < concatType.parameterCount(); c++) { + sb.append(TAG_ARG); + } + recipe = sb.toString(); + } else { + Objects.requireNonNull(recipe, "Recipe is null"); + } + + int cCount = 0; + int oCount = 0; + for (int i = 0; i < recipe.length(); i++) { + char c = recipe.charAt(i); + if (c == TAG_CONST) cCount++; + if (c == TAG_ARG) oCount++; + } + + if (concatType.parameterCount() > MAX_INDY_CONCAT_ARG_SLOTS) { + throw new StringConcatException("Too many concat argument slots: " + + concatType.parameterCount() + + ", can only accept " + + MAX_INDY_CONCAT_ARG_SLOTS); + } + + if (oCount != concatType.parameterCount()) { + throw new StringConcatException( + "Mismatched number of concat arguments: recipe wants " + + oCount + + " arguments, but signature provides " + + concatType.parameterCount()); + } + + if (cCount != constants.length) { + throw new StringConcatException( + "Mismatched number of concat constants: recipe wants " + + cCount + + " constants, but only " + + constants.length + + " are passed"); + } + + if (!concatType.returnType().isAssignableFrom(String.class)) { + throw new StringConcatException( + "The return type should be compatible with String, but it is " + + concatType.returnType()); + } + + + MethodType mt = adaptType(concatType); + + Recipe rec = new Recipe(recipe, constants); + + Key key = new Key(mt, rec); + MethodHandle mh = CACHE_ENABLE ? CACHE.get(key) : null; + if (mh == null) { + try { + mh = generate(caller, mt, rec); + } catch (Throwable t) { + if (t instanceof StringConcatException) { + throw (StringConcatException)t; + } else { + throw new StringConcatException("Generator failed", t); + } + } + if (CACHE_ENABLE) { + CACHE.put(key, mh); + } + } + + return new ConstantCallSite(mh.asType(concatType)); + } + + + /** + * Adapt method type to an API we are going to use. + * + * This strips the concrete classes from the signatures, thus preventing + * class leakage when we cache the concatenation stubs. + * + * @param args actual argument types + * @return argument types the strategy is going to use + */ + private static MethodType adaptType(MethodType args) { + Class[] ptypes = args.parameterArray(); + boolean changed = false; + for (int i = 0; i < ptypes.length; i++) { + Class ptype = ptypes[i]; + if (!ptype.isPrimitive() && + ptype != String.class && + ptype != Object.class) { // truncate to Object + ptypes[i] = Object.class; + changed = true; + } + // else other primitives or String or Object (unchanged) + } + return changed + ? MethodType.methodType(args.returnType(), ptypes) + : args; + } + + private static MethodHandle generate(Lookup lookup, MethodType mt, Recipe recipe) throws Throwable { + switch (STRATEGY) { + case BC_SB: + return BytecodeStringBuilderStrategy.generate(lookup, mt, recipe, Mode.DEFAULT); + case BC_SB_SIZED: + return BytecodeStringBuilderStrategy.generate(lookup, mt, recipe, Mode.SIZED); + case BC_SB_SIZED_EXACT: + return BytecodeStringBuilderStrategy.generate(lookup, mt, recipe, Mode.SIZED_EXACT); + case MH_SB_SIZED: + return MethodHandleStringBuilderStrategy.generate(lookup, mt, recipe, Mode.SIZED); + case MH_SB_SIZED_EXACT: + return MethodHandleStringBuilderStrategy.generate(lookup, mt, recipe, Mode.SIZED_EXACT); + case MH_INLINE_SIZED_EXACT: + return MethodHandleInlineCopyStrategy.generate(lookup, mt, recipe); + default: + throw new StringConcatException("Concatenation strategy " + STRATEGY + " is not implemented"); + } + } + + private enum Mode { + DEFAULT(false, false), + SIZED(true, false), + SIZED_EXACT(true, true), + ; + + boolean sized, exact; + + Mode(boolean sized, boolean exact) { + this.sized = sized; + this.exact = exact; + } + + boolean isSized() { + return sized; + } + + boolean isExact() { + return exact; + } + } + + /** + * Bytecode StringBuilder strategy. + * + *

This strategy operates in three modes, gated by {@link Mode}. + * + *

{@link Strategy#BC_SB}: "bytecode StringBuilder". + * + *

This strategy spins up the bytecode that has the same StringBuilder + * chain javac would otherwise emit. This strategy uses only the public API, + * and comes as the baseline for the current JDK behavior. On other words, + * this strategy moves the javac generated bytecode to runtime. The + * generated bytecode is loaded via Unsafe.defineAnonymousClass, but with + * the caller class coming from the BSM -- in other words, the protection + * guarantees are inherited from the method where invokedynamic was + * originally called. This means, among other things, that the bytecode is + * verified for all non-JDK uses. + * + *

{@link Strategy#BC_SB_SIZED}: "bytecode StringBuilder, but + * sized". + * + *

This strategy acts similarly to {@link Strategy#BC_SB}, but it also + * tries to guess the capacity required for StringBuilder to accept all + * arguments without resizing. This strategy only makes an educated guess: + * it only guesses the space required for known types (e.g. primitives and + * Strings), but does not otherwise convert arguments. Therefore, the + * capacity estimate may be wrong, and StringBuilder may have to + * transparently resize or trim when doing the actual concatenation. While + * this does not constitute a correctness issue (in the end, that what BC_SB + * has to do anyway), this does pose a potential performance problem. + * + *

{@link Strategy#BC_SB_SIZED_EXACT}: "bytecode StringBuilder, but + * sized exactly". + * + *

This strategy improves on @link Strategy#BC_SB_SIZED}, by first + * converting all arguments to String in order to get the exact capacity + * StringBuilder should have. The conversion is done via the public + * String.valueOf and/or Object.toString methods, and does not touch any + * private String API. + */ + private static final class BytecodeStringBuilderStrategy { + static final Unsafe UNSAFE = Unsafe.getUnsafe(); + static final int CLASSFILE_VERSION = 52; + static final String NAME_FACTORY = "concat"; + static final String CLASS_NAME = "java/lang/String$Concat"; + + private BytecodeStringBuilderStrategy() { + // no instantiation + } + + private static MethodHandle generate(MethodHandles.Lookup lookup, MethodType args, Recipe recipe, Mode mode) throws Exception { + Class targetClass = lookup.lookupClass(); + + ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS + ClassWriter.COMPUTE_FRAMES); + + cw.visit(CLASSFILE_VERSION, + ACC_SUPER + ACC_PUBLIC + ACC_FINAL + ACC_SYNTHETIC, + CLASS_NAME, + null, + "java/lang/Object", + null + ); + + MethodVisitor mv = cw.visitMethod( + ACC_PUBLIC + ACC_STATIC + ACC_FINAL, + NAME_FACTORY, + args.toMethodDescriptorString(), + null, + null); + + mv.visitAnnotation("Ljava/lang/invoke/ForceInline;", true); + mv.visitCode(); + + Class[] arr = args.parameterArray(); + boolean[] guaranteedNonNull = new boolean[arr.length]; + + if (mode.isExact()) { + /* + In exact mode, we need to convert all arguments to their String representations, + as this allows to compute their String sizes exactly. We cannot use private + methods for primitives in here, therefore we need to convert those as well. + + We also record what arguments are guaranteed to be non-null as the result + of the conversion. String.valueOf does the null checks for us. The only + corner case to take care of is String.valueOf(Object) returning null itself. + + Also, if any conversion happened, then the slot indices in the incoming + arguments are not equal to the final local maps. The only case this may break + is when converting 2-slot long/double argument to 1-slot String. Therefore, + we get away with tracking modified offset, since no conversion can overwrite + the upcoming the argument. + */ + + int off = 0; + int modOff = 0; + for (int c = 0; c < arr.length; c++) { + Class cl = arr[c]; + if (cl == String.class) { + if (off != modOff) { + mv.visitIntInsn(getLoadOpcode(cl), off); + mv.visitIntInsn(ASTORE, modOff); + } + } else { + mv.visitIntInsn(getLoadOpcode(cl), off); + mv.visitMethodInsn( + INVOKESTATIC, + "java/lang/String", + "valueOf", + getStringValueOfDesc(cl), + false + ); + mv.visitIntInsn(ASTORE, modOff); + arr[c] = String.class; + guaranteedNonNull[c] = cl.isPrimitive(); + } + off += getParameterSize(cl); + modOff += getParameterSize(String.class); + } + } + + if (mode.isSized()) { + /* + When operating in sized mode (this includes exact mode), it makes sense to make + StringBuilder append chains look familiar to OptimizeStringConcat. For that, we + need to do null-checks early, not make the append chain shape simpler. + */ + + int off = 0; + for (RecipeElement el : recipe.getElements()) { + switch (el.getTag()) { + case CONST: { + // Guaranteed non-null, no null check required. + break; + } + case ARG: { + // Null-checks are needed only for String arguments, and when a previous stage + // did not do implicit null-checks. If an String is null, we eagerly replace it + // with "null" constant. Note, we omit Objects here, because we don't call + // .length() on them down below. + int ac = el.getArgPos(); + Class cl = arr[ac]; + if (cl == String.class && !guaranteedNonNull[ac]) { + Label l0 = new Label(); + mv.visitIntInsn(ALOAD, off); + mv.visitJumpInsn(IFNONNULL, l0); + mv.visitLdcInsn("null"); + mv.visitIntInsn(ASTORE, off); + mv.visitLabel(l0); + } + off += getParameterSize(cl); + break; + } + default: + throw new StringConcatException("Unhandled tag: " + el.getTag()); + } + } + } + + // Prepare StringBuilder instance + mv.visitTypeInsn(NEW, "java/lang/StringBuilder"); + mv.visitInsn(DUP); + + if (mode.isSized()) { + /* + Sized mode requires us to walk through the arguments, and estimate the final length. + In exact mode, this will operate on Strings only. This code would accumulate the + final length on stack. + */ + int len = 0; + int off = 0; + + mv.visitInsn(ICONST_0); + + for (RecipeElement el : recipe.getElements()) { + switch (el.getTag()) { + case CONST: { + Object cnst = el.getValue(); + len += cnst.toString().length(); + break; + } + case ARG: { + /* + If an argument is String, then we can call .length() on it. Sized/Exact modes have + converted arguments for us. If an argument is primitive, we can provide a guess + for its String representation size. + */ + Class cl = arr[el.getArgPos()]; + if (cl == String.class) { + mv.visitIntInsn(ALOAD, off); + mv.visitMethodInsn( + INVOKEVIRTUAL, + "java/lang/String", + "length", + "()I", + false + ); + mv.visitInsn(IADD); + } else if (cl.isPrimitive()) { + len += estimateSize(cl); + } + off += getParameterSize(cl); + break; + } + default: + throw new StringConcatException("Unhandled tag: " + el.getTag()); + } + } + + // Constants have non-zero length, mix in + if (len > 0) { + iconst(mv, len); + mv.visitInsn(IADD); + } + + mv.visitMethodInsn( + INVOKESPECIAL, + "java/lang/StringBuilder", + "", + "(I)V", + false + ); + } else { + mv.visitMethodInsn( + INVOKESPECIAL, + "java/lang/StringBuilder", + "", + "()V", + false + ); + } + + // At this point, we have a blank StringBuilder on stack, fill it in with .append calls. + { + int off = 0; + for (RecipeElement el : recipe.getElements()) { + String desc; + switch (el.getTag()) { + case CONST: { + Object cnst = el.getValue(); + mv.visitLdcInsn(cnst); + desc = getSBAppendDesc(cnst.getClass()); + break; + } + case ARG: { + Class cl = arr[el.getArgPos()]; + mv.visitVarInsn(getLoadOpcode(cl), off); + off += getParameterSize(cl); + desc = getSBAppendDesc(cl); + break; + } + default: + throw new StringConcatException("Unhandled tag: " + el.getTag()); + } + mv.visitMethodInsn( + INVOKEVIRTUAL, + "java/lang/StringBuilder", + "append", + desc, + false + ); + } + } + + if (DEBUG && mode.isExact()) { + /* + Exactness checks compare the final StringBuilder.capacity() with a resulting + String.length(). If these values disagree, that means StringBuilder had to perform + storage trimming, which defeats the purpose of exact strategies. + */ + + mv.visitInsn(DUP); + + mv.visitMethodInsn( + INVOKEVIRTUAL, + "java/lang/StringBuilder", + "capacity", + "()I", + false + ); + + mv.visitIntInsn(ISTORE, 0); + + mv.visitMethodInsn( + INVOKEVIRTUAL, + "java/lang/StringBuilder", + "toString", + "()Ljava/lang/String;", + false + ); + + mv.visitInsn(DUP); + + mv.visitMethodInsn( + INVOKEVIRTUAL, + "java/lang/String", + "length", + "()I", + false + ); + + mv.visitIntInsn(ILOAD, 0); + + Label l0 = new Label(); + mv.visitJumpInsn(IF_ICMPEQ, l0); + + mv.visitTypeInsn(NEW, "java/lang/AssertionError"); + mv.visitInsn(DUP); + mv.visitLdcInsn("Failed exactness check"); + mv.visitMethodInsn(INVOKESPECIAL, + "java/lang/AssertionError", + "", + "(Ljava/lang/Object;)V", + false); + mv.visitInsn(ATHROW); + + mv.visitLabel(l0); + } else { + mv.visitMethodInsn( + INVOKEVIRTUAL, + "java/lang/StringBuilder", + "toString", + "()Ljava/lang/String;", + false + ); + } + + mv.visitInsn(ARETURN); + + mv.visitMaxs(-1, -1); + mv.visitEnd(); + cw.visitEnd(); + + final byte[] classBytes = cw.toByteArray(); + final Class innerClass = UNSAFE.defineAnonymousClass(targetClass, classBytes, null); + + try { + UNSAFE.ensureClassInitialized(innerClass); + return lookup.findStatic(innerClass, NAME_FACTORY, args); + } catch (ReflectiveOperationException e) { + throw new StringConcatException("Exception finding constructor", e); + } + } + + private static String getSBAppendDesc(Class cl) { + if (cl.isPrimitive()) { + if (cl == Integer.TYPE || cl == Byte.TYPE || cl == Short.TYPE) { + return "(I)Ljava/lang/StringBuilder;"; + } else if (cl == Boolean.TYPE) { + return "(Z)Ljava/lang/StringBuilder;"; + } else if (cl == Character.TYPE) { + return "(C)Ljava/lang/StringBuilder;"; + } else if (cl == Double.TYPE) { + return "(D)Ljava/lang/StringBuilder;"; + } else if (cl == Float.TYPE) { + return "(F)Ljava/lang/StringBuilder;"; + } else if (cl == Long.TYPE) { + return "(J)Ljava/lang/StringBuilder;"; + } else { + throw new IllegalStateException("Unhandled primitive StringBuilder.append: " + cl); + } + } else if (cl == String.class) { + return "(Ljava/lang/String;)Ljava/lang/StringBuilder;"; + } else { + return "(Ljava/lang/Object;)Ljava/lang/StringBuilder;"; + } + } + + private static String getStringValueOfDesc(Class cl) { + if (cl.isPrimitive()) { + if (cl == Integer.TYPE || cl == Byte.TYPE || cl == Short.TYPE) { + return "(I)Ljava/lang/String;"; + } else if (cl == Boolean.TYPE) { + return "(Z)Ljava/lang/String;"; + } else if (cl == Character.TYPE) { + return "(C)Ljava/lang/String;"; + } else if (cl == Double.TYPE) { + return "(D)Ljava/lang/String;"; + } else if (cl == Float.TYPE) { + return "(F)Ljava/lang/String;"; + } else if (cl == Long.TYPE) { + return "(J)Ljava/lang/String;"; + } else { + throw new IllegalStateException("Unhandled String.valueOf: " + cl); + } + } else if (cl == String.class) { + return "(Ljava/lang/String;)Ljava/lang/String;"; + } else { + return "(Ljava/lang/Object;)Ljava/lang/String;"; + } + } + + /** + * The following method is copied from + * org.objectweb.asm.commons.InstructionAdapter. Part of ASM: a very small + * and fast Java bytecode manipulation framework. + * Copyright (c) 2000-2005 INRIA, France Telecom All rights reserved. + */ + private static void iconst(MethodVisitor mv, final int cst) { + if (cst >= -1 && cst <= 5) { + mv.visitInsn(Opcodes.ICONST_0 + cst); + } else if (cst >= Byte.MIN_VALUE && cst <= Byte.MAX_VALUE) { + mv.visitIntInsn(Opcodes.BIPUSH, cst); + } else if (cst >= Short.MIN_VALUE && cst <= Short.MAX_VALUE) { + mv.visitIntInsn(Opcodes.SIPUSH, cst); + } else { + mv.visitLdcInsn(cst); + } + } + + private static int getLoadOpcode(Class c) { + if (c == Void.TYPE) { + throw new InternalError("Unexpected void type of load opcode"); + } + return ILOAD + getOpcodeOffset(c); + } + + private static int getOpcodeOffset(Class c) { + if (c.isPrimitive()) { + if (c == Long.TYPE) { + return 1; + } else if (c == Float.TYPE) { + return 2; + } else if (c == Double.TYPE) { + return 3; + } + return 0; + } else { + return 4; + } + } + + private static int getParameterSize(Class c) { + if (c == Void.TYPE) { + return 0; + } else if (c == Long.TYPE || c == Double.TYPE) { + return 2; + } + return 1; + } + } + + /** + * MethodHandle StringBuilder strategy. + * + *

This strategy operates in two modes, gated by {@link Mode}. + * + *

{@link Strategy#MH_SB_SIZED}: "MethodHandles StringBuilder, + * sized". + * + *

This strategy avoids spinning up the bytecode by building the + * computation on MethodHandle combinators. The computation is built with + * public MethodHandle APIs, resolved from a public Lookup sequence, and + * ends up calling the public StringBuilder API. Therefore, this strategy + * does not use any private API at all, even the Unsafe.defineAnonymousClass, + * since everything is handled under cover by java.lang.invoke APIs. + * + *

{@link Strategy#MH_SB_SIZED_EXACT}: "MethodHandles StringBuilder, + * sized exactly". + * + *

This strategy improves on @link Strategy#MH_SB_SIZED}, by first + * converting all arguments to String in order to get the exact capacity + * StringBuilder should have. The conversion is done via the public + * String.valueOf and/or Object.toString methods, and does not touch any + * private String API. + */ + private static final class MethodHandleStringBuilderStrategy { + + private MethodHandleStringBuilderStrategy() { + // no instantiation + } + + private static MethodHandle generate(Lookup lookup, MethodType mt, Recipe recipe, Mode mode) throws Exception { + int pc = mt.parameterCount(); + + Class[] ptypes = mt.parameterArray(); + MethodHandle[] filters = new MethodHandle[ptypes.length]; + for (int i = 0; i < ptypes.length; i++) { + MethodHandle filter; + switch (mode) { + case SIZED: + // In sized mode, we convert all references and floats/doubles + // to String: there is no specialization for different + // classes in StringBuilder API, and it will convert to + // String internally anyhow. + filter = Stringifiers.forMost(ptypes[i]); + break; + case SIZED_EXACT: + // In exact mode, we convert everything to String: + // this helps to compute the storage exactly. + filter = Stringifiers.forAny(ptypes[i]); + break; + default: + throw new StringConcatException("Not supported"); + } + if (filter != null) { + filters[i] = filter; + ptypes[i] = filter.type().returnType(); + } + } + + List> ptypesList = Arrays.asList(ptypes); + MethodHandle[] lengthers = new MethodHandle[pc]; + + // Figure out lengths: constants' lengths can be deduced on the spot. + // All reference arguments were filtered to String in the combinators below, so we can + // call the usual String.length(). Primitive values string sizes can be estimated. + int initial = 0; + for (RecipeElement el : recipe.getElements()) { + switch (el.getTag()) { + case CONST: { + Object cnst = el.getValue(); + initial += cnst.toString().length(); + break; + } + case ARG: { + final int i = el.getArgPos(); + Class type = ptypesList.get(i); + if (type.isPrimitive()) { + MethodHandle est = MethodHandles.constant(int.class, estimateSize(type)); + est = MethodHandles.dropArguments(est, 0, type); + lengthers[i] = est; + } else { + lengthers[i] = STRING_LENGTH; + } + break; + } + default: + throw new StringConcatException("Unhandled tag: " + el.getTag()); + } + } + + // Create (StringBuilder, ) shape for appending: + MethodHandle builder = MethodHandles.dropArguments(MethodHandles.identity(StringBuilder.class), 1, ptypesList); + + // Compose append calls. This is done in reverse because the application order is + // reverse as well. + for (RecipeElement el : recipe.getElementsReversed()) { + MethodHandle appender; + switch (el.getTag()) { + case CONST: { + Object constant = el.getValue(); + MethodHandle mh = appender(adaptToStringBuilder(constant.getClass())); + appender = MethodHandles.insertArguments(mh, 1, constant); + break; + } + case ARG: { + int ac = el.getArgPos(); + appender = appender(ptypesList.get(ac)); + + // Insert dummy arguments to match the prefix in the signature. + // The actual appender argument will be the ac-ith argument. + if (ac != 0) { + appender = MethodHandles.dropArguments(appender, 1, ptypesList.subList(0, ac)); + } + break; + } + default: + throw new StringConcatException("Unhandled tag: " + el.getTag()); + } + builder = MethodHandles.foldArguments(builder, appender); + } + + // Build the sub-tree that adds the sizes and produces a StringBuilder: + + // a) Start with the reducer that accepts all arguments, plus one + // slot for the initial value. Inject the initial value right away. + // This produces ()int shape: + MethodHandle sum = getReducerFor(pc + 1); + MethodHandle adder = MethodHandles.insertArguments(sum, 0, initial); + + // b) Apply lengthers to transform arguments to lengths, producing ()int + adder = MethodHandles.filterArguments(adder, 0, lengthers); + + // c) Instantiate StringBuilder ()int -> ()StringBuilder + MethodHandle newBuilder = MethodHandles.filterReturnValue(adder, NEW_STRING_BUILDER); + + // d) Fold in StringBuilder constructor, this produces ()StringBuilder + MethodHandle mh = MethodHandles.foldArguments(builder, newBuilder); + + // Convert non-primitive arguments to Strings + mh = MethodHandles.filterArguments(mh, 0, filters); + + // Convert ()StringBuilder to ()String + if (DEBUG && mode.isExact()) { + mh = MethodHandles.filterReturnValue(mh, BUILDER_TO_STRING_CHECKED); + } else { + mh = MethodHandles.filterReturnValue(mh, BUILDER_TO_STRING); + } + + return mh; + } + + private static MethodHandle getReducerFor(int cnt) { + return SUMMERS.computeIfAbsent(cnt, SUMMER); + } + + private static MethodHandle appender(Class appendType) { + MethodHandle appender = lookupVirtual(MethodHandles.publicLookup(), StringBuilder.class, "append", + StringBuilder.class, adaptToStringBuilder(appendType)); + + // appenders should return void, this would not modify the target signature during folding + MethodType nt = MethodType.methodType(void.class, StringBuilder.class, appendType); + return appender.asType(nt); + } + + private static String toStringChecked(StringBuilder sb) { + String s = sb.toString(); + if (s.length() != sb.capacity()) { + throw new AssertionError("Exactness check failed: result length = " + s.length() + ", buffer capacity = " + sb.capacity()); + } + return s; + } + + private static int sum(int v1, int v2) { + return v1 + v2; + } + + private static int sum(int v1, int v2, int v3) { + return v1 + v2 + v3; + } + + private static int sum(int v1, int v2, int v3, int v4) { + return v1 + v2 + v3 + v4; + } + + private static int sum(int v1, int v2, int v3, int v4, int v5) { + return v1 + v2 + v3 + v4 + v5; + } + + private static int sum(int v1, int v2, int v3, int v4, int v5, int v6) { + return v1 + v2 + v3 + v4 + v5 + v6; + } + + private static int sum(int v1, int v2, int v3, int v4, int v5, int v6, int v7) { + return v1 + v2 + v3 + v4 + v5 + v6 + v7; + } + + private static int sum(int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8) { + return v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; + } + + private static int sum(int initial, int[] vs) { + int sum = initial; + for (int v : vs) { + sum += v; + } + return sum; + } + + private static final ConcurrentMap SUMMERS; + + // This one is deliberately non-lambdified to optimize startup time: + private static final Function SUMMER = new Function() { + @Override + public MethodHandle apply(Integer cnt) { + if (cnt == 1) { + return MethodHandles.identity(int.class); + } else if (cnt <= 8) { + // Variable-arity collectors are not as efficient as small-count methods, + // unroll some initial sizes. + Class[] cls = new Class[cnt]; + for (int i = 0; i < cnt; i++) { + cls[i] = int.class; + } + return lookupStatic(Lookup.IMPL_LOOKUP, MethodHandleStringBuilderStrategy.class, "sum", int.class, cls); + } else { + return lookupStatic(Lookup.IMPL_LOOKUP, MethodHandleStringBuilderStrategy.class, "sum", int.class, int.class, int[].class) + .asCollector(int[].class, cnt - 1); + } + } + }; + + private static final MethodHandle NEW_STRING_BUILDER, STRING_LENGTH, BUILDER_TO_STRING, BUILDER_TO_STRING_CHECKED; + + static { + SUMMERS = new ConcurrentHashMap<>(); + Lookup publicLookup = MethodHandles.publicLookup(); + NEW_STRING_BUILDER = lookupConstructor(publicLookup, StringBuilder.class, int.class); + STRING_LENGTH = lookupVirtual(publicLookup, String.class, "length", int.class); + BUILDER_TO_STRING = lookupVirtual(publicLookup, StringBuilder.class, "toString", String.class); + if (DEBUG) { + BUILDER_TO_STRING_CHECKED = lookupStatic(MethodHandles.Lookup.IMPL_LOOKUP, + MethodHandleStringBuilderStrategy.class, "toStringChecked", String.class, StringBuilder.class); + } else { + BUILDER_TO_STRING_CHECKED = null; + } + } + + } + + + /** + *

{@link Strategy#MH_INLINE_SIZED_EXACT}: "MethodHandles inline, + * sized exactly". + * + *

This strategy replicates what StringBuilders are doing: it builds the + * byte[] array on its own and passes that byte[] array to String + * constructor. This strategy requires access to some private APIs in JDK, + * most notably, the read-only Integer/Long.stringSize methods that measure + * the character length of the integers, and the private String constructor + * that accepts byte[] arrays without copying. While this strategy assumes a + * particular implementation details for String, this opens the door for + * building a very optimal concatenation sequence. This is the only strategy + * that requires porting if there are private JDK changes occur. + */ + private static final class MethodHandleInlineCopyStrategy { + + private MethodHandleInlineCopyStrategy() { + // no instantiation + } + + static MethodHandle generate(Lookup lookup, MethodType mt, Recipe recipe) throws Throwable { + + // Create filters and obtain filtered parameter types. Filters would be used in the beginning + // to convert the incoming arguments into the arguments we can process (e.g. Objects -> Strings). + // The filtered argument type list is used all over in the combinators below. + Class[] ptypes = mt.parameterArray(); + MethodHandle[] filters = null; + for (int i = 0; i < ptypes.length; i++) { + MethodHandle filter = Stringifiers.forMost(ptypes[i]); + if (filter != null) { + if (filters == null) { + filters = new MethodHandle[ptypes.length]; + } + filters[i] = filter; + ptypes[i] = filter.type().returnType(); + } + } + List> ptypesList = Arrays.asList(ptypes); + + // Start building the combinator tree. The tree "starts" with ()String, and "finishes" + // with the (int, byte[], byte)String in String helper. The combinators are assembled bottom-up, + // which makes the code arguably hard to read. + + // Drop all remaining parameter types, leave only helper arguments: + MethodHandle mh; + + mh = MethodHandles.dropArguments(NEW_STRING, 2, ptypes); + mh = MethodHandles.dropArguments(mh, 0, int.class); + + // In debug mode, check that remaining index is zero. + if (DEBUG) { + mh = MethodHandles.filterArgument(mh, 0, CHECK_INDEX); + } + + // Mix in prependers. This happens when (int, byte[], byte) = (index, storage, coder) is already + // known from the combinators below. We are assembling the string backwards, so "index" is the + // *ending* index. + for (RecipeElement el : recipe.getElements()) { + MethodHandle prepender; + switch (el.getTag()) { + case CONST: { + Object cnst = el.getValue(); + prepender = MethodHandles.insertArguments(prepender(cnst.getClass()), 3, cnst); + break; + } + case ARG: { + int pos = el.getArgPos(); + prepender = selectArgument(prepender(ptypesList.get(pos)), 3, ptypesList, pos); + break; + } + default: + throw new StringConcatException("Unhandled tag: " + el.getTag()); + } + + // Remove "old" index from arguments + mh = MethodHandles.dropArguments(mh, 1, int.class); + + // Do the prepend, and put "new" index at index 0 + mh = MethodHandles.foldArguments(mh, prepender); + } + + // Prepare the argument list for prepending. The tree below would instantiate + // the storage byte[] into argument 0, so we need to swap "storage" and "index". + // The index at this point equals to "size", and resides at argument 1. + { + MethodType nmt = mh.type() + .changeParameterType(0, byte[].class) + .changeParameterType(1, int.class); + mh = MethodHandles.permuteArguments(mh, nmt, swap10(nmt.parameterCount())); + } + + // Fold in byte[] instantiation at argument 0. + MethodHandle combiner = MethodHandles.dropArguments(NEW_ARRAY, 2, ptypesList); + mh = MethodHandles.foldArguments(mh, combiner); + + // Start combining length and coder mixers. + // + // Length is easy: constant lengths can be computed on the spot, and all non-constant + // shapes have been either converted to Strings, or explicit methods for getting the + // string length out of primitives are provided. + // + // Coders are more interesting. Only Object, String and char arguments (and constants) + // can have non-Latin1 encoding. It is easier to blindly convert constants to String, + // and deduce the coder from there. Arguments would be either converted to Strings + // during the initial filtering, or handled by primitive specializations in CODER_MIXERS. + // + // The method handle shape after all length and coder mixers is: + // (int, byte, )String = ("index", "coder", ) + byte initialCoder = 0; // initial coder + int initialLen = 0; // initial length, in characters + for (RecipeElement el : recipe.getElements()) { + switch (el.getTag()) { + case CONST: { + Object constant = el.getValue(); + String s = constant.toString(); + initialCoder = (byte) coderMixer(String.class).invoke(initialCoder, s); + initialLen += s.length(); + break; + } + case ARG: { + int ac = el.getArgPos(); + + Class argClass = ptypesList.get(ac); + MethodHandle lm = selectArgument(lengthMixer(argClass), 1, ptypesList, ac); + lm = MethodHandles.dropArguments(lm, 0, byte.class); // (*) + lm = MethodHandles.dropArguments(lm, 2, byte.class); + + MethodHandle cm = selectArgument(coderMixer(argClass), 1, ptypesList, ac); + cm = MethodHandles.dropArguments(cm, 0, int.class); // (**) + + // Read this bottom up: + + // 4. Drop old index and coder, producing ("new-index", "new-coder", ) + mh = MethodHandles.dropArguments(mh, 2, int.class, byte.class); + + // 3. Compute "new-index", producing ("new-index", "new-coder", "old-index", "old-coder", ) + // Length mixer ignores both "new-coder" and "old-coder" due to dropArguments above (*) + mh = MethodHandles.foldArguments(mh, lm); + + // 2. Compute "new-coder", producing ("new-coder", "old-index", "old-coder", ) + // Coder mixer ignores the "old-index" arg due to dropArguments above (**) + mh = MethodHandles.foldArguments(mh, cm); + + // 1. The mh shape here is ("old-index", "old-coder", ) + break; + } + default: + throw new StringConcatException("Unhandled tag: " + el.getTag()); + } + } + + // Insert initial lengths and coders here. + // The method handle shape here is (). + mh = MethodHandles.insertArguments(mh, 0, initialLen, initialCoder); + + // Apply filters, converting the arguments: + if (filters != null) { + mh = MethodHandles.filterArguments(mh, 0, filters); + } + + return mh; + } + + private static int[] swap10(int count) { + int[] perm = new int[count]; + perm[0] = 1; + perm[1] = 0; + for (int i = 2; i < count; i++) { + perm[i] = i; + } + return perm; + } + + // (...prefix..., parameter[pos])R -> (...prefix..., ...parameters...)R + private static MethodHandle selectArgument(MethodHandle mh, int prefix, List> ptypes, int pos) { + if (pos == 0) { + return MethodHandles.dropArguments(mh, prefix + 1, ptypes.subList(1, ptypes.size())); + } else if (pos == ptypes.size() - 1) { + return MethodHandles.dropArguments(mh, prefix, ptypes.subList(0, ptypes.size() - 1)); + } else { // 0 < pos < ptypes.size() - 1 + return MethodHandles.dropArguments( + MethodHandles.dropArguments(mh, prefix, ptypes.subList(0, pos)), + prefix + 1 + pos, ptypes.subList(pos + 1, ptypes.size())); + } + } + + @ForceInline + private static byte[] newArray(int length, byte coder) { + return new byte[length << coder]; + } + + @ForceInline + private static int checkIndex(int index) { + if (index != 0) { + throw new AssertionError("Exactness check failed: " + index + " characters left in the buffer."); + } + return index; + } + + private static MethodHandle prepender(Class cl) { + return PREPENDERS.computeIfAbsent(cl, PREPEND); + } + + private static MethodHandle coderMixer(Class cl) { + return CODER_MIXERS.computeIfAbsent(cl, CODER_MIX); + } + + private static MethodHandle lengthMixer(Class cl) { + return LENGTH_MIXERS.computeIfAbsent(cl, LENGTH_MIX); + } + + // This one is deliberately non-lambdified to optimize startup time: + private static final Function, MethodHandle> PREPEND = new Function, MethodHandle>() { + @Override + public MethodHandle apply(Class c) { + return lookupStatic(Lookup.IMPL_LOOKUP, STRING_HELPER, "prepend", int.class, int.class, byte[].class, byte.class, c); + } + }; + + // This one is deliberately non-lambdified to optimize startup time: + private static final Function, MethodHandle> CODER_MIX = new Function, MethodHandle>() { + @Override + public MethodHandle apply(Class c) { + return lookupStatic(Lookup.IMPL_LOOKUP, STRING_HELPER, "mixCoder", byte.class, byte.class, c); + } + }; + + // This one is deliberately non-lambdified to optimize startup time: + private static final Function, MethodHandle> LENGTH_MIX = new Function, MethodHandle>() { + @Override + public MethodHandle apply(Class c) { + return lookupStatic(Lookup.IMPL_LOOKUP, STRING_HELPER, "mixLen", int.class, int.class, c); + } + }; + + private static final MethodHandle NEW_STRING; + private static final MethodHandle CHECK_INDEX; + private static final MethodHandle NEW_ARRAY; + private static final ConcurrentMap, MethodHandle> PREPENDERS; + private static final ConcurrentMap, MethodHandle> LENGTH_MIXERS; + private static final ConcurrentMap, MethodHandle> CODER_MIXERS; + private static Class STRING_HELPER; + + static { + try { + STRING_HELPER = Class.forName("java.lang.StringConcatHelper"); + } catch (ClassNotFoundException e) { + throw new AssertionError(e); + } + + PREPENDERS = new ConcurrentHashMap<>(); + LENGTH_MIXERS = new ConcurrentHashMap<>(); + CODER_MIXERS = new ConcurrentHashMap<>(); + + NEW_STRING = lookupStatic(Lookup.IMPL_LOOKUP, STRING_HELPER, "newString", String.class, byte[].class, byte.class); + NEW_ARRAY = lookupStatic(Lookup.IMPL_LOOKUP, MethodHandleInlineCopyStrategy.class, "newArray", byte[].class, int.class, byte.class); + + if (DEBUG) { + CHECK_INDEX = lookupStatic(Lookup.IMPL_LOOKUP, MethodHandleInlineCopyStrategy.class, "checkIndex", int.class, int.class); + } else { + CHECK_INDEX = null; + } + } + } + + /** + * Public gateways to public "stringify" methods. These methods have the form String apply(T obj), and normally + * delegate to {@code String.valueOf}, depending on argument's type. + */ + private static final class Stringifiers { + private Stringifiers() { + // no instantiation + } + + // This one is deliberately non-lambdified to optimize startup time: + private static final Function, MethodHandle> MOST = new Function, MethodHandle>() { + @Override + public MethodHandle apply(Class cl) { + MethodHandle mhObject = lookupStatic(Lookup.PUBLIC_LOOKUP, String.class, "valueOf", String.class, Object.class); + + // We need the additional conversion here, because String.valueOf(Object) may return null. + // String conversion rules in Java state we need to produce "null" String in this case. + // It can be easily done with applying valueOf the second time. + MethodHandle mhObjectNoNulls = MethodHandles.filterReturnValue(mhObject, + mhObject.asType(MethodType.methodType(String.class, String.class))); + + if (cl == String.class) { + return mhObject; + } else if (cl == float.class) { + return lookupStatic(Lookup.PUBLIC_LOOKUP, String.class, "valueOf", String.class, float.class); + } else if (cl == double.class) { + return lookupStatic(Lookup.PUBLIC_LOOKUP, String.class, "valueOf", String.class, double.class); + } else if (!cl.isPrimitive()) { + return mhObjectNoNulls; + } + + return null; + } + }; + + // This one is deliberately non-lambdified to optimize startup time: + private static final Function, MethodHandle> ANY = new Function, MethodHandle>() { + @Override + public MethodHandle apply(Class cl) { + MethodHandle mh = MOST.apply(cl); + if (mh != null) { + return mh; + } + + if (cl == byte.class || cl == short.class || cl == int.class) { + return lookupStatic(Lookup.PUBLIC_LOOKUP, String.class, "valueOf", String.class, int.class); + } else if (cl == boolean.class) { + return lookupStatic(Lookup.PUBLIC_LOOKUP, String.class, "valueOf", String.class, boolean.class); + } else if (cl == char.class) { + return lookupStatic(Lookup.PUBLIC_LOOKUP, String.class, "valueOf", String.class, char.class); + } else if (cl == long.class) { + return lookupStatic(Lookup.PUBLIC_LOOKUP, String.class, "valueOf", String.class, long.class); + } else { + throw new IllegalStateException("Unknown class: " + cl); + } + } + }; + + private static final ConcurrentMap, MethodHandle> STRINGIFIERS_MOST = new ConcurrentHashMap<>(); + private static final ConcurrentMap, MethodHandle> STRINGIFIERS_ANY = new ConcurrentHashMap<>(); + + /** + * Returns a stringifier for references and floats/doubles only. + * Always returns null for other primitives. + * + * @param t class to stringify + * @return stringifier; null, if not available + */ + static MethodHandle forMost(Class t) { + return STRINGIFIERS_MOST.computeIfAbsent(t, MOST); + } + + /** + * Returns a stringifier for any type. Never returns null. + * + * @param t class to stringify + * @return stringifier + */ + static MethodHandle forAny(Class t) { + return STRINGIFIERS_ANY.computeIfAbsent(t, ANY); + } + } + + /* ------------------------------- Common utilities ------------------------------------ */ + + private static MethodHandle lookupStatic(Lookup lookup, Class refc, String name, Class rtype, Class... ptypes) { + try { + return lookup.findStatic(refc, name, MethodType.methodType(rtype, ptypes)); + } catch (NoSuchMethodException | IllegalAccessException e) { + throw new AssertionError(e); + } + } + + private static MethodHandle lookupVirtual(Lookup lookup, Class refc, String name, Class rtype, Class... ptypes) { + try { + return lookup.findVirtual(refc, name, MethodType.methodType(rtype, ptypes)); + } catch (NoSuchMethodException | IllegalAccessException e) { + throw new AssertionError(e); + } + } + + private static MethodHandle lookupConstructor(Lookup lookup, Class refc, Class ptypes) { + try { + return lookup.findConstructor(refc, MethodType.methodType(void.class, ptypes)); + } catch (NoSuchMethodException | IllegalAccessException e) { + throw new AssertionError(e); + } + } + + private static int estimateSize(Class cl) { + if (cl == Integer.TYPE) { + return 11; // "-2147483648" + } else if (cl == Boolean.TYPE) { + return 5; // "false" + } else if (cl == Byte.TYPE) { + return 4; // "-128" + } else if (cl == Character.TYPE) { + return 1; // duh + } else if (cl == Short.TYPE) { + return 6; // "-32768" + } else if (cl == Double.TYPE) { + return 26; // apparently, no larger than this, see FloatingDecimal.BinaryToASCIIBuffer.buffer + } else if (cl == Float.TYPE) { + return 26; // apparently, no larger than this, see FloatingDecimal.BinaryToASCIIBuffer.buffer + } else if (cl == Long.TYPE) { + return 20; // "-9223372036854775808" + } else { + throw new IllegalArgumentException("Cannot estimate the size for " + cl); + } + } + + private static Class adaptToStringBuilder(Class c) { + if (c.isPrimitive()) { + if (c == Byte.TYPE || c == Short.TYPE) { + return int.class; + } + } else { + if (c != String.class) { + return Object.class; + } + } + return c; + } + + private StringConcatFactory() { + // no instantiation + } + +} --- /dev/null 2015-11-23 01:27:16.425045507 +0300 +++ new/test/java/lang/String/concat/ImplicitStringConcat.java 2015-11-26 01:38:41.733622936 +0300 @@ -0,0 +1,219 @@ +/* + * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/** + * @test + * @summary test implicit String concatenations + * + * @compile ImplicitStringConcat.java + * @run main/othervm ImplicitStringConcat + * + * @compile -XDstringConcat=inline ImplicitStringConcat.java + * @run main/othervm ImplicitStringConcat + * + * @compile -XDstringConcat=indy -source 1.9 -target 1.9 ImplicitStringConcat.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT ImplicitStringConcat + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcat + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * + * @compile -XDstringConcat=indyWithConstants -source 1.9 -target 1.9 ImplicitStringConcat.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT ImplicitStringConcat + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcat + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcat +*/ +import java.lang.StringBuilder; + +public class ImplicitStringConcat { + + static boolean b = true; + static byte by = 42; + static short sh = 42; + static char ch = 'a'; + static int i = 42; + static float fl = 42.0f; + static long l = 42; + static double d = 42.0d; + static String s = "foo"; + static String sNull = null; + static Object o = "bar"; + static Object oNull = null; + static CharSequence cs = "bar"; + static char[] chars = new char[] {'a'}; + + static MyClass myCl = new MyClass(); + static MyClassNull myClNull = new MyClassNull(); + static Object myCl2 = new MyClass(); + static Object[] myArr = new Object[] { myCl }; + static final Object[] s_myArr = new Object[] { myCl }; + + static StringBuffer sb = new StringBuffer(); + static { + sb.append('a'); + } + + public static void main(String[] args) throws Exception { + + test("footrue", s + b); + test("foo42", s + by); + test("foo42", s + sh); + test("fooa", s + ch); + test("foo42", s + i); + test("foo42", s + l); + test("foo42.0", s + fl); + test("foo42.0", s + d); + test("foofoo", s + s); + test("foonull", s + sNull); + test("foobar", s + o); + test("foonull", s + oNull); + test("foobar", s + cs); + + { + StringBuilder sb = new StringBuilder(); + sb.append("foo"); + sb.append(myArr.toString()); + test(sb.toString(), s + myArr); + } + + { + StringBuilder sb = new StringBuilder(); + sb.append("foo"); + sb.append(s_myArr.toString()); + test(sb.toString(), s + s_myArr); + } + + { + StringBuilder sb = new StringBuilder(); + sb.append("foo[C@"); + sb.append(Integer.toHexString(System.identityHashCode(chars))); + test(sb.toString(), s + chars); + } + + test("fooa", s + ImplicitStringConcat.sb); + test("foonull", s + null); + test("fooMyClass", s + myCl); + test("foonull", s + myClNull); + test("fooMyClass", s + myCl2); + + s = "foo"; s += b; test("footrue", s); + s = "foo"; s += by; test("foo42", s); + s = "foo"; s += sh; test("foo42", s); + s = "foo"; s += ch; test("fooa", s); + s = "foo"; s += i; test("foo42", s); + s = "foo"; s += l; test("foo42", s); + s = "foo"; s += fl; test("foo42.0", s); + s = "foo"; s += d; test("foo42.0", s); + s = "foo"; s += s; test("foofoo", s); + s = "foo"; s += sNull; test("foonull", s); + s = "foo"; s += o; test("foobar", s); + s = "foo"; s += oNull; test("foonull", s); + s = "foo"; s += cs; test("foobar", s); + + { + StringBuilder sb = new StringBuilder(); + sb.append("foo[C@"); + sb.append(Integer.toHexString(System.identityHashCode(chars))); + s = "foo"; + s += chars; + test(sb.toString(), s); + } + + s = "foo"; s += ImplicitStringConcat.sb; test("fooa", s); + s = "foo"; s += null; test("foonull", s); + s = "foo"; s += myCl; test("fooMyClass", s); + s = "foo"; s += myCl2; test("fooMyClass", s); + } + + public static void test(String expected, String actual) { + // Fingers crossed: String concat should work. + if (!expected.equals(actual)) { + StringBuilder sb = new StringBuilder(); + sb.append("Expected = "); + sb.append(expected); + sb.append(", actual = "); + sb.append(actual); + throw new IllegalStateException(sb.toString()); + } + } + + static class MyClass { + public String toString() { + return "MyClass"; + } + } + + static class MyClassNull { + public String toString() { + return null; + } + } +} --- /dev/null 2015-11-23 01:27:16.425045507 +0300 +++ new/test/java/lang/String/concat/ImplicitStringConcatArgCount.java 2015-11-26 01:38:42.165620802 +0300 @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/** + * @test + * @summary Test multiple number of arguments to concatenate. + * + * @compile ImplicitStringConcatArgCount.java + * @run main/othervm ImplicitStringConcatArgCount + * + * @compile -XDallowStringFolding=false -XDstringConcat=inline ImplicitStringConcatArgCount.java + * @run main/othervm ImplicitStringConcatArgCount + * + * @compile -XDallowStringFolding=false -XDstringConcat=indy -source 1.9 -target 1.9 ImplicitStringConcatArgCount.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT ImplicitStringConcatArgCount + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatArgCount + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * + * @compile -XDallowStringFolding=false -XDstringConcat=indyWithConstants -source 1.9 -target 1.9 ImplicitStringConcatArgCount.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT ImplicitStringConcatArgCount + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatArgCount + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatArgCount +*/ +public class ImplicitStringConcatArgCount { + static final String s = "f"; + static final String s1 = "o"; + static String s2 = "o"; + static int i = 7; + + public static void main(String[] args) throws Exception { + test("fo", s + s1); + test("foo", s + s1 + s2); + test("foo7", s + s1 + s2 + i); + test("foo77", s + s1 + s2 + i + i); + test("foo777", s + s1 + s2 + i + i + i); + test("foo7777", s + s1 + s2 + i + i + i + i); + test("foo77777", s + s1 + s2 + i + i + i + i + i); + test("foo777777", s + s1 + s2 + i + i + i + i + i + i); + test("foo7777777", s + s1 + s2 + i + i + i + i + i + i + i); + test("foo77777777", s + s1 + s2 + i + i + i + i + i + i + i + i); + } + + public static void test(String expected, String actual) { + if (!expected.equals(actual)) { + StringBuilder sb = new StringBuilder(); + sb.append("Expected = "); + sb.append(expected); + sb.append(", actual = "); + sb.append(actual); + throw new IllegalStateException(sb.toString()); + } + } +} --- /dev/null 2015-11-23 01:27:16.425045507 +0300 +++ new/test/java/lang/String/concat/ImplicitStringConcatBoundaries.java 2015-11-26 01:38:42.597618669 +0300 @@ -0,0 +1,206 @@ +/* + * Copyright (c) 2015, 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/** + * @test + * @summary Test the boundary values for concatenation arguments. + * + * @compile ImplicitStringConcatBoundaries.java + * @run main/othervm ImplicitStringConcatBoundaries + * + * @compile -XDstringConcat=inline ImplicitStringConcatBoundaries.java + * @run main/othervm ImplicitStringConcatBoundaries + * + * @compile -XDstringConcat=indy -source 1.9 -target 1.9 ImplicitStringConcatBoundaries.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT ImplicitStringConcatBoundaries + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatBoundaries + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * + * @compile -XDstringConcat=indyWithConstants -source 1.9 -target 1.9 ImplicitStringConcatBoundaries.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT ImplicitStringConcatBoundaries + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatBoundaries + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatBoundaries + +*/ + +public class ImplicitStringConcatBoundaries { + + public static final boolean BOOL_TRUE_1 = true; + public static boolean BOOL_TRUE_2 = true; + public static final boolean BOOL_FALSE_1 = false; + public static boolean BOOL_FALSE_2 = false; + + public static final byte BYTE_MIN_1 = Byte.MIN_VALUE; + public static byte BYTE_MIN_2 = Byte.MIN_VALUE; + public static final byte BYTE_MAX_1 = Byte.MAX_VALUE; + public static byte BYTE_MAX_2 = Byte.MAX_VALUE; + + public static final short SHORT_MIN_1 = Short.MIN_VALUE; + public static short SHORT_MIN_2 = Short.MIN_VALUE; + public static final short SHORT_MAX_1 = Short.MAX_VALUE; + public static short SHORT_MAX_2 = Short.MAX_VALUE; + + public static final char CHAR_MIN_1 = Character.MIN_VALUE; + public static char CHAR_MIN_2 = Character.MIN_VALUE; + public static final char CHAR_MAX_1 = Character.MAX_VALUE; + public static char CHAR_MAX_2 = Character.MAX_VALUE; + + public static final int INT_MIN_1 = Integer.MIN_VALUE; + public static int INT_MIN_2 = Integer.MIN_VALUE; + public static final int INT_MAX_1 = Integer.MAX_VALUE; + public static int INT_MAX_2 = Integer.MAX_VALUE; + + public static final float FLOAT_MIN_EXP_1 = Float.MIN_EXPONENT; + public static float FLOAT_MIN_EXP_2 = Float.MIN_EXPONENT; + public static final float FLOAT_MIN_NORM_1 = Float.MIN_NORMAL; + public static float FLOAT_MIN_NORM_2 = Float.MIN_NORMAL; + public static final float FLOAT_MIN_1 = Float.MIN_VALUE; + public static float FLOAT_MIN_2 = Float.MIN_VALUE; + public static final float FLOAT_MAX_1 = Float.MAX_VALUE; + public static float FLOAT_MAX_2 = Float.MAX_VALUE; + + public static final long LONG_MIN_1 = Long.MIN_VALUE; + public static long LONG_MIN_2 = Long.MIN_VALUE; + public static final long LONG_MAX_1 = Long.MAX_VALUE; + public static long LONG_MAX_2 = Long.MAX_VALUE; + + public static final double DOUBLE_MIN_EXP_1 = Double.MIN_EXPONENT; + public static double DOUBLE_MIN_EXP_2 = Double.MIN_EXPONENT; + public static final double DOUBLE_MIN_NORM_1 = Double.MIN_NORMAL; + public static double DOUBLE_MIN_NORM_2 = Double.MIN_NORMAL; + public static final double DOUBLE_MIN_1 = Double.MIN_VALUE; + public static double DOUBLE_MIN_2 = Double.MIN_VALUE; + public static final double DOUBLE_MAX_1 = Double.MAX_VALUE; + public static double DOUBLE_MAX_2 = Double.MAX_VALUE; + + public static void main(String[] args) throws Exception { + test("foofalse", "foo" + BOOL_FALSE_1); + test("foofalse", "foo" + BOOL_FALSE_2); + test("footrue", "foo" + BOOL_TRUE_1); + test("footrue", "foo" + BOOL_TRUE_2); + + test("foo127", "foo" + BYTE_MAX_1); + test("foo127", "foo" + BYTE_MAX_2); + test("foo-128", "foo" + BYTE_MIN_1); + test("foo-128", "foo" + BYTE_MIN_2); + + test("foo32767", "foo" + SHORT_MAX_1); + test("foo32767", "foo" + SHORT_MAX_2); + test("foo-32768", "foo" + SHORT_MIN_1); + test("foo-32768", "foo" + SHORT_MIN_2); + + test("foo\u0000", "foo" + CHAR_MIN_1); + test("foo\u0000", "foo" + CHAR_MIN_2); + test("foo\uFFFF", "foo" + CHAR_MAX_1); + test("foo\uFFFF", "foo" + CHAR_MAX_2); + + test("foo2147483647", "foo" + INT_MAX_1); + test("foo2147483647", "foo" + INT_MAX_2); + test("foo-2147483648", "foo" + INT_MIN_1); + test("foo-2147483648", "foo" + INT_MIN_2); + + test("foo1.17549435E-38", "foo" + FLOAT_MIN_NORM_1); + test("foo1.17549435E-38", "foo" + FLOAT_MIN_NORM_2); + test("foo-126.0", "foo" + FLOAT_MIN_EXP_1); + test("foo-126.0", "foo" + FLOAT_MIN_EXP_2); + test("foo1.4E-45", "foo" + FLOAT_MIN_1); + test("foo1.4E-45", "foo" + FLOAT_MIN_2); + test("foo3.4028235E38", "foo" + FLOAT_MAX_1); + test("foo3.4028235E38", "foo" + FLOAT_MAX_2); + + test("foo-9223372036854775808", "foo" + LONG_MIN_1); + test("foo-9223372036854775808", "foo" + LONG_MIN_2); + test("foo9223372036854775807", "foo" + LONG_MAX_1); + test("foo9223372036854775807", "foo" + LONG_MAX_2); + + test("foo2.2250738585072014E-308", "foo" + DOUBLE_MIN_NORM_1); + test("foo2.2250738585072014E-308", "foo" + DOUBLE_MIN_NORM_2); + test("foo-1022.0", "foo" + DOUBLE_MIN_EXP_1); + test("foo-1022.0", "foo" + DOUBLE_MIN_EXP_2); + test("foo4.9E-324", "foo" + DOUBLE_MIN_1); + test("foo4.9E-324", "foo" + DOUBLE_MIN_2); + test("foo1.7976931348623157E308", "foo" + DOUBLE_MAX_1); + test("foo1.7976931348623157E308", "foo" + DOUBLE_MAX_2); + } + + public static void test(String expected, String actual) { + if (!expected.equals(actual)) { + StringBuilder sb = new StringBuilder(); + sb.append("Expected = "); + sb.append(expected); + sb.append(", actual = "); + sb.append(actual); + throw new IllegalStateException(sb.toString()); + } + } +} --- /dev/null 2015-11-23 01:27:16.425045507 +0300 +++ new/test/java/lang/String/concat/ImplicitStringConcatMany.java 2015-11-26 01:38:43.033616517 +0300 @@ -0,0 +1,195 @@ +/* + * Copyright (c) 2015, 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/** + * @test + * @summary Test implicit String concatenations with lots of arguments. + * + * @compile ImplicitStringConcatMany.java + * @run main/othervm ImplicitStringConcatMany + * + * @compile -XDstringConcat=inline ImplicitStringConcatMany.java + * @run main/othervm ImplicitStringConcatMany + * + * @compile -XDstringConcat=indy -source 1.9 -target 1.9 ImplicitStringConcatMany.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT ImplicitStringConcatMany + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatMany + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * + * @compile -XDstringConcat=indyWithConstants -source 1.9 -target 1.9 ImplicitStringConcatMany.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT ImplicitStringConcatMany + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatMany + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatMany +*/ + +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; + +public class ImplicitStringConcatMany { + + static String s000, s001, s002, s003, s004, s005, s006, s007, s008, s009; + static String s010, s011, s012, s013, s014, s015, s016, s017, s018, s019; + static String s020, s021, s022, s023, s024, s025, s026, s027, s028, s029; + static String s030, s031, s032, s033, s034, s035, s036, s037, s038, s039; + static String s040, s041, s042, s043, s044, s045, s046, s047, s048, s049; + static String s050, s051, s052, s053, s054, s055, s056, s057, s058, s059; + static String s060, s061, s062, s063, s064, s065, s066, s067, s068, s069; + static String s070, s071, s072, s073, s074, s075, s076, s077, s078, s079; + static String s080, s081, s082, s083, s084, s085, s086, s087, s088, s089; + static String s090, s091, s092, s093, s094, s095, s096, s097, s098, s099; + + static String s100, s101, s102, s103, s104, s105, s106, s107, s108, s109; + static String s110, s111, s112, s113, s114, s115, s116, s117, s118, s119; + static String s120, s121, s122, s123, s124, s125, s126, s127, s128, s129; + static String s130, s131, s132, s133, s134, s135, s136, s137, s138, s139; + static String s140, s141, s142, s143, s144, s145, s146, s147, s148, s149; + static String s150, s151, s152, s153, s154, s155, s156, s157, s158, s159; + static String s160, s161, s162, s163, s164, s165, s166, s167, s168, s169; + static String s170, s171, s172, s173, s174, s175, s176, s177, s178, s179; + static String s180, s181, s182, s183, s184, s185, s186, s187, s188, s189; + static String s190, s191, s192, s193, s194, s195, s196, s197, s198, s199; + + static String s200, s201, s202, s203, s204, s205, s206, s207, s208, s209; + static String s210, s211, s212, s213, s214, s215, s216, s217, s218, s219; + static String s220, s221, s222, s223, s224, s225, s226, s227, s228, s229; + static String s230, s231, s232, s233, s234, s235, s236, s237, s238, s239; + static String s240, s241, s242, s243, s244, s245, s246, s247, s248, s249; + static String s250, s251, s252, s253, s254, s255, s256, s257, s258, s259; + static String s260, s261, s262, s263, s264, s265, s266, s267, s268, s269; + static String s270, s271, s272, s273, s274, s275, s276, s277, s278, s279; + static String s280, s281, s282, s283, s284, s285, s286, s287, s288, s289; + static String s290, s291, s292, s293, s294, s295, s296, s297, s298, s299; + + static { + for (Field f : ImplicitStringConcatMany.class.getDeclaredFields()) { + if (Modifier.isStatic(f.getModifiers())) { + String name = f.getName(); + try { + f.set(null, name); + } catch (IllegalAccessException e) { + throw new IllegalStateException(e); + } + } + } + } + + public static void main(String[] args) throws Exception { + String res = + s000 + s001 + s002 + s003 + s004 + s005 + s006 + s007 + s008 + s009 + + s010 + s011 + s012 + s013 + s014 + s015 + s016 + s017 + s018 + s019 + + s020 + s021 + s022 + s023 + s024 + s025 + s026 + s027 + s028 + s029 + + s030 + s031 + s032 + s033 + s034 + s035 + s036 + s037 + s038 + s039 + + s040 + s041 + s042 + s043 + s044 + s045 + s046 + s047 + s048 + s049 + + s050 + s051 + s052 + s053 + s054 + s055 + s056 + s057 + s058 + s059 + + s060 + s061 + s062 + s063 + s064 + s065 + s066 + s067 + s068 + s069 + + s070 + s071 + s072 + s073 + s074 + s075 + s076 + s077 + s078 + s079 + + s080 + s081 + s082 + s083 + s084 + s085 + s086 + s087 + s088 + s089 + + s090 + s091 + s092 + s093 + s094 + s095 + s096 + s097 + s098 + s099 + + + s100 + s101 + s102 + s103 + s104 + s105 + s106 + s107 + s108 + s109 + + s110 + s111 + s112 + s113 + s114 + s115 + s116 + s117 + s118 + s119 + + s120 + s121 + s122 + s123 + s124 + s125 + s126 + s127 + s128 + s129 + + s130 + s131 + s132 + s133 + s134 + s135 + s136 + s137 + s138 + s139 + + s140 + s141 + s142 + s143 + s144 + s145 + s146 + s147 + s148 + s149 + + s150 + s151 + s152 + s153 + s154 + s155 + s156 + s157 + s158 + s159 + + s160 + s161 + s162 + s163 + s164 + s165 + s166 + s167 + s168 + s169 + + s170 + s171 + s172 + s173 + s174 + s175 + s176 + s177 + s178 + s179 + + s180 + s181 + s182 + s183 + s184 + s185 + s186 + s187 + s188 + s189 + + s190 + s191 + s192 + s193 + s194 + s195 + s196 + s197 + s198 + s199 + + + s200 + s201 + s202 + s203 + s204 + s205 + s206 + s207 + s208 + s209 + + s210 + s211 + s212 + s213 + s214 + s215 + s216 + s217 + s218 + s219 + + s220 + s221 + s222 + s223 + s224 + s225 + s226 + s227 + s228 + s229 + + s230 + s231 + s232 + s233 + s234 + s235 + s236 + s237 + s238 + s239 + + s240 + s241 + s242 + s243 + s244 + s245 + s246 + s247 + s248 + s249 + + s250 + s251 + s252 + s253 + s254 + s255 + s256 + s257 + s258 + s259 + + s260 + s261 + s262 + s263 + s264 + s265 + s266 + s267 + s268 + s269 + + s270 + s271 + s272 + s273 + s274 + s275 + s276 + s277 + s278 + s279 + + s280 + s281 + s282 + s283 + s284 + s285 + s286 + s287 + s288 + s289 + + s290 + s291 + s292 + s293 + s294 + s295 + s296 + s297 + s298 + s299; + + StringBuilder sb = new StringBuilder(); + for (int c = 0; c < 300; c++) { + sb.append(String.format("s%03d", c)); + } + test(sb.toString(), res); + } + + public static void test(String expected, String actual) { + // Fingers crossed: String concat should work. + if (!expected.equals(actual)) { + throw new IllegalStateException("Expected = " + expected + ", actual = " + actual); + } + } +} + --- /dev/null 2015-11-23 01:27:16.425045507 +0300 +++ new/test/java/lang/String/concat/ImplicitStringConcatManyLongs.java 2015-11-26 01:38:43.465614384 +0300 @@ -0,0 +1,195 @@ +/* + * Copyright (c) 2015, 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/** + * @test + * @summary Test implicit String concatenations with lots of arguments (two-slot version) + * + * @compile ImplicitStringConcatManyLongs.java + * @run main/othervm ImplicitStringConcatManyLongs + * + * @compile -XDstringConcat=inline ImplicitStringConcatManyLongs.java + * @run main/othervm ImplicitStringConcatManyLongs + * + * @compile -XDstringConcat=indy -source 1.9 -target 1.9 ImplicitStringConcatManyLongs.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT ImplicitStringConcatManyLongs + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatManyLongs + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * + * @compile -XDstringConcat=indyWithConstants -source 1.9 -target 1.9 ImplicitStringConcatManyLongs.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT ImplicitStringConcatManyLongs + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatManyLongs + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatManyLongs +*/ + +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; + +public class ImplicitStringConcatManyLongs { + + static long s000, s001, s002, s003, s004, s005, s006, s007, s008, s009; + static long s010, s011, s012, s013, s014, s015, s016, s017, s018, s019; + static long s020, s021, s022, s023, s024, s025, s026, s027, s028, s029; + static long s030, s031, s032, s033, s034, s035, s036, s037, s038, s039; + static long s040, s041, s042, s043, s044, s045, s046, s047, s048, s049; + static long s050, s051, s052, s053, s054, s055, s056, s057, s058, s059; + static long s060, s061, s062, s063, s064, s065, s066, s067, s068, s069; + static long s070, s071, s072, s073, s074, s075, s076, s077, s078, s079; + static long s080, s081, s082, s083, s084, s085, s086, s087, s088, s089; + static long s090, s091, s092, s093, s094, s095, s096, s097, s098, s099; + + static long s100, s101, s102, s103, s104, s105, s106, s107, s108, s109; + static long s110, s111, s112, s113, s114, s115, s116, s117, s118, s119; + static long s120, s121, s122, s123, s124, s125, s126, s127, s128, s129; + static long s130, s131, s132, s133, s134, s135, s136, s137, s138, s139; + static long s140, s141, s142, s143, s144, s145, s146, s147, s148, s149; + static long s150, s151, s152, s153, s154, s155, s156, s157, s158, s159; + static long s160, s161, s162, s163, s164, s165, s166, s167, s168, s169; + static long s170, s171, s172, s173, s174, s175, s176, s177, s178, s179; + static long s180, s181, s182, s183, s184, s185, s186, s187, s188, s189; + static long s190, s191, s192, s193, s194, s195, s196, s197, s198, s199; + + static long s200, s201, s202, s203, s204, s205, s206, s207, s208, s209; + static long s210, s211, s212, s213, s214, s215, s216, s217, s218, s219; + static long s220, s221, s222, s223, s224, s225, s226, s227, s228, s229; + static long s230, s231, s232, s233, s234, s235, s236, s237, s238, s239; + static long s240, s241, s242, s243, s244, s245, s246, s247, s248, s249; + static long s250, s251, s252, s253, s254, s255, s256, s257, s258, s259; + static long s260, s261, s262, s263, s264, s265, s266, s267, s268, s269; + static long s270, s271, s272, s273, s274, s275, s276, s277, s278, s279; + static long s280, s281, s282, s283, s284, s285, s286, s287, s288, s289; + static long s290, s291, s292, s293, s294, s295, s296, s297, s298, s299; + + static { + for (Field f : ImplicitStringConcatManyLongs.class.getDeclaredFields()) { + if (Modifier.isStatic(f.getModifiers())) { + String name = f.getName(); + try { + f.set(null, Long.valueOf(name.substring(1))); + } catch (IllegalAccessException e) { + throw new IllegalStateException(e); + } + } + } + } + + public static void main(String[] args) throws Exception { + String res = "" + + s000 + s001 + s002 + s003 + s004 + s005 + s006 + s007 + s008 + s009 + + s010 + s011 + s012 + s013 + s014 + s015 + s016 + s017 + s018 + s019 + + s020 + s021 + s022 + s023 + s024 + s025 + s026 + s027 + s028 + s029 + + s030 + s031 + s032 + s033 + s034 + s035 + s036 + s037 + s038 + s039 + + s040 + s041 + s042 + s043 + s044 + s045 + s046 + s047 + s048 + s049 + + s050 + s051 + s052 + s053 + s054 + s055 + s056 + s057 + s058 + s059 + + s060 + s061 + s062 + s063 + s064 + s065 + s066 + s067 + s068 + s069 + + s070 + s071 + s072 + s073 + s074 + s075 + s076 + s077 + s078 + s079 + + s080 + s081 + s082 + s083 + s084 + s085 + s086 + s087 + s088 + s089 + + s090 + s091 + s092 + s093 + s094 + s095 + s096 + s097 + s098 + s099 + + + s100 + s101 + s102 + s103 + s104 + s105 + s106 + s107 + s108 + s109 + + s110 + s111 + s112 + s113 + s114 + s115 + s116 + s117 + s118 + s119 + + s120 + s121 + s122 + s123 + s124 + s125 + s126 + s127 + s128 + s129 + + s130 + s131 + s132 + s133 + s134 + s135 + s136 + s137 + s138 + s139 + + s140 + s141 + s142 + s143 + s144 + s145 + s146 + s147 + s148 + s149 + + s150 + s151 + s152 + s153 + s154 + s155 + s156 + s157 + s158 + s159 + + s160 + s161 + s162 + s163 + s164 + s165 + s166 + s167 + s168 + s169 + + s170 + s171 + s172 + s173 + s174 + s175 + s176 + s177 + s178 + s179 + + s180 + s181 + s182 + s183 + s184 + s185 + s186 + s187 + s188 + s189 + + s190 + s191 + s192 + s193 + s194 + s195 + s196 + s197 + s198 + s199 + + + s200 + s201 + s202 + s203 + s204 + s205 + s206 + s207 + s208 + s209 + + s210 + s211 + s212 + s213 + s214 + s215 + s216 + s217 + s218 + s219 + + s220 + s221 + s222 + s223 + s224 + s225 + s226 + s227 + s228 + s229 + + s230 + s231 + s232 + s233 + s234 + s235 + s236 + s237 + s238 + s239 + + s240 + s241 + s242 + s243 + s244 + s245 + s246 + s247 + s248 + s249 + + s250 + s251 + s252 + s253 + s254 + s255 + s256 + s257 + s258 + s259 + + s260 + s261 + s262 + s263 + s264 + s265 + s266 + s267 + s268 + s269 + + s270 + s271 + s272 + s273 + s274 + s275 + s276 + s277 + s278 + s279 + + s280 + s281 + s282 + s283 + s284 + s285 + s286 + s287 + s288 + s289 + + s290 + s291 + s292 + s293 + s294 + s295 + s296 + s297 + s298 + s299; + + StringBuilder sb = new StringBuilder(); + for (int c = 0; c < 300; c++) { + sb.append(c); + } + test(sb.toString(), res); + } + + public static void test(String expected, String actual) { + // Fingers crossed: String concat should work. + if (!expected.equals(actual)) { + throw new IllegalStateException("Expected = " + expected + ", actual = " + actual); + } + } +} + --- /dev/null 2015-11-23 01:27:16.425045507 +0300 +++ new/test/java/lang/String/concat/ImplicitStringConcatShapes-head.template 2015-11-26 01:38:43.905612214 +0300 @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2015, 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/** + * @test + * @summary Test implicit String concatenations, multiple shapes. + * + * @compile ImplicitStringConcatShapes.java + * @run main/othervm ImplicitStringConcatShapes + * + * @compile -XDstringConcat=inline ImplicitStringConcatShapes.java + * @run main/othervm ImplicitStringConcatShapes + * + * @compile -XDstringConcat=indy -source 1.9 -target 1.9 ImplicitStringConcatShapes.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT ImplicitStringConcatShapes + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * + * @compile -XDstringConcat=indyWithConstants -source 1.9 -target 1.9 ImplicitStringConcatShapes.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT ImplicitStringConcatShapes + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes +*/ +public class ImplicitStringConcatShapes { + public static void test(String expected, String actual) { + // Fingers crossed: String concat should work. + if (!expected.equals(actual)) { + StringBuilder sb = new StringBuilder(); + sb.append("Expected = "); + sb.append(expected); + sb.append(", actual = "); + sb.append(actual); + throw new IllegalStateException(sb.toString()); + } + } + + static class MyClass { + private final int i; + + public MyClass(int i) { + this.i = i; + } + + public String toString() { + return new StringBuilder("C(").append(i).append(")").toString(); + } + } + + static class MyClassNullToString { + public String toString() { + return null; + } + } + + public static void main(String[] args) throws Exception { + new ImplicitStringConcatShapes().run(); + } --- /dev/null 2015-11-23 01:27:16.425045507 +0300 +++ new/test/java/lang/String/concat/ImplicitStringConcatShapes.java 2015-11-26 01:38:44.341610062 +0300 @@ -0,0 +1,5931 @@ +/* + * Copyright (c) 2015, 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/** + * @test + * @summary Test implicit String concatenations, multiple shapes. + * + * @compile ImplicitStringConcatShapes.java + * @run main/othervm ImplicitStringConcatShapes + * + * @compile -XDstringConcat=inline ImplicitStringConcatShapes.java + * @run main/othervm ImplicitStringConcatShapes + * + * @compile -XDstringConcat=indy -source 1.9 -target 1.9 ImplicitStringConcatShapes.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT ImplicitStringConcatShapes + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * + * @compile -XDstringConcat=indyWithConstants -source 1.9 -target 1.9 ImplicitStringConcatShapes.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT ImplicitStringConcatShapes + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true ImplicitStringConcatShapes + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true ImplicitStringConcatShapes +*/ +public class ImplicitStringConcatShapes { + public static void test(String expected, String actual) { + // Fingers crossed: String concat should work. + if (!expected.equals(actual)) { + StringBuilder sb = new StringBuilder(); + sb.append("Expected = "); + sb.append(expected); + sb.append(", actual = "); + sb.append(actual); + throw new IllegalStateException(sb.toString()); + } + } + + static class MyClass { + private final int i; + + public MyClass(int i) { + this.i = i; + } + + public String toString() { + return new StringBuilder("C(").append(i).append(")").toString(); + } + } + + static class MyClassNullToString { + public String toString() { + return null; + } + } + + public static void main(String[] args) throws Exception { + new ImplicitStringConcatShapes().run(); + } + static final boolean sf_bl = true; + static final byte sf_b = 80; + static final byte sf_bM = -41; + static final char sf_c = 'C'; + static final short sf_s = 5500; + static final short sf_sM = -8400; + static final int sf_i = 75000000; + static final int sf_iM = -2000000; + static final Integer sf_I = 1000000; + static final Integer sf_IN = null; + static final float sf_f = 17.0f; + static final float sf_fM = -42.0f; + static final long sf_l = -194313216L; + static final long sf_lM = -1705032704L; + static final double sf_d = 12.0d; + static final double sf_dM = -84.0d; + static final Object sf_o = new MyClass(87); + static final Object sf_oN = null; + static final Object sf_oNtS = new MyClassNullToString(); + static final String sf_str = "75"; + static final String sf_strU = "\u04511"; + static final String sf_strU1 = "\u000151"; + static final String sf_strU2 = "\u000292"; + static final int[] sf_iAN = null; + static final Object[] sf_oAN = null; + static boolean s_bl = true; + static byte s_b = 25; + static byte s_bM = -43; + static char s_c = 'T'; + static short s_s = 3900; + static short s_sM = -2900; + static int s_i = 97000000; + static int s_iM = -1000000; + static Integer s_I = 25000000; + static Integer s_IN = null; + static float s_f = 55.0f; + static float s_fM = -52.0f; + static long s_l = 935228928L; + static long s_lM = -1410065408L; + static double s_d = 8.0d; + static double s_dM = -96.0d; + static Object s_o = new MyClass(82); + static Object s_oN = null; + static Object s_oNtS = new MyClassNullToString(); + static String s_str = "18"; + static String s_strU = "\u045180"; + static String s_strU1 = "\u000112"; + static String s_strU2 = "\u000291"; + static int[] s_iAN = null; + static Object[] s_oAN = null; + final boolean f_bl = false; + final byte f_b = 44; + final byte f_bM = -54; + final char f_c = 'I'; + final short f_s = 8000; + final short f_sM = -9900; + final int f_i = 58000000; + final int f_iM = -55000000; + final Integer f_I = 94000000; + final Integer f_IN = null; + final float f_f = 94.0f; + final float f_fM = -87.0f; + final long f_l = 1460392448L; + final long f_lM = -820130816L; + final double f_d = 83.0d; + final double f_dM = -99.0d; + final Object f_o = new MyClass(70); + final Object f_oN = null; + final Object f_oNtS = new MyClassNullToString(); + final String f_str = "19"; + final String f_strU = "\u045176"; + final String f_strU1 = "\u000121"; + final String f_strU2 = "\u000218"; + final int[] f_iAN = null; + final Object[] f_oAN = null; + + public void run() { + run0(); + run1(); + run2(); + run3(); + run4(); + run5(); + } + + public void run0() { + test("-96.0", "" + s_dM); + test("null", "" + s_oNtS); + test("\u045176", "" + f_strU); + test("92", "" + sf_strU2); + test("51", "" + sf_strU1); + test("null", "" + s_iAN); + test("-54", "" + f_bM); + test("-87.0", "" + f_fM); + test("null", "" + s_oAN); + test("19", "" + f_str); + test("-41", "" + sf_bM); + test("null", "" + sf_IN); + test("T", "" + s_c); + test("-42.0", "" + sf_fM); + test("25", "" + s_b); + test("null", "" + f_oN); + test("-1410065408", "" + s_lM); + test("8.0", "" + s_d); + test("55.0", "" + s_f); + test("97000000", "" + s_i); + test("-9900", "" + f_sM); + test("935228928", "" + s_l); + test("-8400", "" + sf_sM); + test("C(82)", "" + s_o); + test("null", "" + sf_oNtS); + test("true", "" + s_bl); + test("3900", "" + s_s); + test("null", "" + sf_oN); + test("94000000", "" + f_I); + test("null", "" + f_IN); + test("true", "" + sf_bl); + test("5500", "" + sf_s); + test("-2900", "" + s_sM); + test("-194313216", "" + sf_l); + test("12", "" + s_strU1); + test("C(87)", "" + sf_o); + test("91", "" + s_strU2); + test("21", "" + f_strU1); + test("18", "" + f_strU2); + test("null", "" + f_iAN); + test("null", "" + s_oN); + test("\u045180", "" + s_strU); + test("C", "" + sf_c); + test("75", "" + sf_str); + test("-43", "" + s_bM); + test("80", "" + sf_b); + test("null", "" + s_IN); + test("-52.0", "" + s_fM); + test("75000000", "" + sf_i); + test("44", "" + f_b); + test("-1705032704", "" + sf_lM); + test("null", "" + f_oAN); + test("83.0", "" + f_d); + test("I", "" + f_c); + test("94.0", "" + f_f); + test("12.0", "" + sf_d); + test("-99.0", "" + f_dM); + test("17.0", "" + sf_f); + test("-84.0", "" + sf_dM); + test("58000000", "" + f_i); + test("-55000000", "" + f_iM); + test("1460392448", "" + f_l); + test("C(70)", "" + f_o); + test("\u04511", "" + sf_strU); + test("8000", "" + f_s); + test("18", "" + s_str); + test("-1000000", "" + s_iM); + test("1000000", "" + sf_I); + test("null", "" + f_oNtS); + test("false", "" + f_bl); + test("null", "" + sf_iAN); + test("-2000000", "" + sf_iM); + test("-820130816", "" + f_lM); + test("null", "" + sf_oAN); + test("25000000", "" + s_I); + test("-96.0-96.0", "" + s_dM + s_dM); + test("-96.0null", "" + s_dM + s_oNtS); + test("-96.0\u045176", "" + s_dM + f_strU); + test("-96.092", "" + s_dM + sf_strU2); + test("-96.051", "" + s_dM + sf_strU1); + test("-96.0null", "" + s_dM + s_iAN); + test("-96.0-54", "" + s_dM + f_bM); + test("-96.0-87.0", "" + s_dM + f_fM); + test("-96.0null", "" + s_dM + s_oAN); + test("-96.019", "" + s_dM + f_str); + test("-96.0-41", "" + s_dM + sf_bM); + test("-96.0null", "" + s_dM + sf_IN); + test("-96.0T", "" + s_dM + s_c); + test("-96.0-42.0", "" + s_dM + sf_fM); + test("-96.025", "" + s_dM + s_b); + test("-96.0null", "" + s_dM + f_oN); + test("-96.0-1410065408", "" + s_dM + s_lM); + test("-96.08.0", "" + s_dM + s_d); + test("-96.055.0", "" + s_dM + s_f); + test("-96.097000000", "" + s_dM + s_i); + test("-96.0-9900", "" + s_dM + f_sM); + test("-96.0935228928", "" + s_dM + s_l); + test("-96.0-8400", "" + s_dM + sf_sM); + test("-96.0C(82)", "" + s_dM + s_o); + test("-96.0null", "" + s_dM + sf_oNtS); + test("-96.0true", "" + s_dM + s_bl); + test("-96.03900", "" + s_dM + s_s); + test("-96.0null", "" + s_dM + sf_oN); + test("-96.094000000", "" + s_dM + f_I); + test("-96.0null", "" + s_dM + f_IN); + test("-96.0true", "" + s_dM + sf_bl); + test("-96.05500", "" + s_dM + sf_s); + test("-96.0-2900", "" + s_dM + s_sM); + test("-96.0-194313216", "" + s_dM + sf_l); + test("-96.012", "" + s_dM + s_strU1); + test("-96.0C(87)", "" + s_dM + sf_o); + test("-96.091", "" + s_dM + s_strU2); + test("-96.021", "" + s_dM + f_strU1); + test("-96.018", "" + s_dM + f_strU2); + test("-96.0null", "" + s_dM + f_iAN); + test("-96.0null", "" + s_dM + s_oN); + test("-96.0\u045180", "" + s_dM + s_strU); + test("-96.0C", "" + s_dM + sf_c); + test("-96.075", "" + s_dM + sf_str); + test("-96.0-43", "" + s_dM + s_bM); + test("-96.080", "" + s_dM + sf_b); + test("-96.0null", "" + s_dM + s_IN); + test("-96.0-52.0", "" + s_dM + s_fM); + test("-96.075000000", "" + s_dM + sf_i); + test("-96.044", "" + s_dM + f_b); + test("-96.0-1705032704", "" + s_dM + sf_lM); + test("-96.0null", "" + s_dM + f_oAN); + test("-96.083.0", "" + s_dM + f_d); + test("-96.0I", "" + s_dM + f_c); + test("-96.094.0", "" + s_dM + f_f); + test("-96.012.0", "" + s_dM + sf_d); + test("-96.0-99.0", "" + s_dM + f_dM); + test("-96.017.0", "" + s_dM + sf_f); + test("-96.0-84.0", "" + s_dM + sf_dM); + test("-96.058000000", "" + s_dM + f_i); + test("-96.0-55000000", "" + s_dM + f_iM); + test("-96.01460392448", "" + s_dM + f_l); + test("-96.0C(70)", "" + s_dM + f_o); + test("-96.0\u04511", "" + s_dM + sf_strU); + test("-96.08000", "" + s_dM + f_s); + test("-96.018", "" + s_dM + s_str); + test("-96.0-1000000", "" + s_dM + s_iM); + test("-96.01000000", "" + s_dM + sf_I); + test("-96.0null", "" + s_dM + f_oNtS); + test("-96.0false", "" + s_dM + f_bl); + test("-96.0null", "" + s_dM + sf_iAN); + test("-96.0-2000000", "" + s_dM + sf_iM); + test("-96.0-820130816", "" + s_dM + f_lM); + test("-96.0null", "" + s_dM + sf_oAN); + test("-96.025000000", "" + s_dM + s_I); + test("null-96.0", "" + s_oNtS + s_dM); + test("nullnull", "" + s_oNtS + s_oNtS); + test("null\u045176", "" + s_oNtS + f_strU); + test("null92", "" + s_oNtS + sf_strU2); + test("null51", "" + s_oNtS + sf_strU1); + test("nullnull", "" + s_oNtS + s_iAN); + test("null-54", "" + s_oNtS + f_bM); + test("null-87.0", "" + s_oNtS + f_fM); + test("nullnull", "" + s_oNtS + s_oAN); + test("null19", "" + s_oNtS + f_str); + test("null-41", "" + s_oNtS + sf_bM); + test("nullnull", "" + s_oNtS + sf_IN); + test("nullT", "" + s_oNtS + s_c); + test("null-42.0", "" + s_oNtS + sf_fM); + test("null25", "" + s_oNtS + s_b); + test("nullnull", "" + s_oNtS + f_oN); + test("null-1410065408", "" + s_oNtS + s_lM); + test("null8.0", "" + s_oNtS + s_d); + test("null55.0", "" + s_oNtS + s_f); + test("null97000000", "" + s_oNtS + s_i); + test("null-9900", "" + s_oNtS + f_sM); + test("null935228928", "" + s_oNtS + s_l); + test("null-8400", "" + s_oNtS + sf_sM); + test("nullC(82)", "" + s_oNtS + s_o); + test("nullnull", "" + s_oNtS + sf_oNtS); + test("nulltrue", "" + s_oNtS + s_bl); + test("null3900", "" + s_oNtS + s_s); + test("nullnull", "" + s_oNtS + sf_oN); + test("null94000000", "" + s_oNtS + f_I); + test("nullnull", "" + s_oNtS + f_IN); + test("nulltrue", "" + s_oNtS + sf_bl); + test("null5500", "" + s_oNtS + sf_s); + test("null-2900", "" + s_oNtS + s_sM); + test("null-194313216", "" + s_oNtS + sf_l); + test("null12", "" + s_oNtS + s_strU1); + test("nullC(87)", "" + s_oNtS + sf_o); + test("null91", "" + s_oNtS + s_strU2); + test("null21", "" + s_oNtS + f_strU1); + test("null18", "" + s_oNtS + f_strU2); + test("nullnull", "" + s_oNtS + f_iAN); + test("nullnull", "" + s_oNtS + s_oN); + test("null\u045180", "" + s_oNtS + s_strU); + test("nullC", "" + s_oNtS + sf_c); + test("null75", "" + s_oNtS + sf_str); + test("null-43", "" + s_oNtS + s_bM); + test("null80", "" + s_oNtS + sf_b); + test("nullnull", "" + s_oNtS + s_IN); + test("null-52.0", "" + s_oNtS + s_fM); + test("null75000000", "" + s_oNtS + sf_i); + test("null44", "" + s_oNtS + f_b); + test("null-1705032704", "" + s_oNtS + sf_lM); + test("nullnull", "" + s_oNtS + f_oAN); + test("null83.0", "" + s_oNtS + f_d); + test("nullI", "" + s_oNtS + f_c); + test("null94.0", "" + s_oNtS + f_f); + test("null12.0", "" + s_oNtS + sf_d); + test("null-99.0", "" + s_oNtS + f_dM); + test("null17.0", "" + s_oNtS + sf_f); + test("null-84.0", "" + s_oNtS + sf_dM); + test("null58000000", "" + s_oNtS + f_i); + test("null-55000000", "" + s_oNtS + f_iM); + test("null1460392448", "" + s_oNtS + f_l); + test("nullC(70)", "" + s_oNtS + f_o); + test("null\u04511", "" + s_oNtS + sf_strU); + test("null8000", "" + s_oNtS + f_s); + test("null18", "" + s_oNtS + s_str); + test("null-1000000", "" + s_oNtS + s_iM); + test("null1000000", "" + s_oNtS + sf_I); + test("nullnull", "" + s_oNtS + f_oNtS); + test("nullfalse", "" + s_oNtS + f_bl); + test("nullnull", "" + s_oNtS + sf_iAN); + test("null-2000000", "" + s_oNtS + sf_iM); + test("null-820130816", "" + s_oNtS + f_lM); + test("nullnull", "" + s_oNtS + sf_oAN); + test("null25000000", "" + s_oNtS + s_I); + test("\u045176-96.0", "" + f_strU + s_dM); + test("\u045176null", "" + f_strU + s_oNtS); + test("\u045176\u045176", "" + f_strU + f_strU); + test("\u04517692", "" + f_strU + sf_strU2); + test("\u04517651", "" + f_strU + sf_strU1); + test("\u045176null", "" + f_strU + s_iAN); + test("\u045176-54", "" + f_strU + f_bM); + test("\u045176-87.0", "" + f_strU + f_fM); + test("\u045176null", "" + f_strU + s_oAN); + test("\u04517619", "" + f_strU + f_str); + test("\u045176-41", "" + f_strU + sf_bM); + test("\u045176null", "" + f_strU + sf_IN); + test("\u045176T", "" + f_strU + s_c); + test("\u045176-42.0", "" + f_strU + sf_fM); + test("\u04517625", "" + f_strU + s_b); + test("\u045176null", "" + f_strU + f_oN); + test("\u045176-1410065408", "" + f_strU + s_lM); + test("\u0451768.0", "" + f_strU + s_d); + test("\u04517655.0", "" + f_strU + s_f); + test("\u04517697000000", "" + f_strU + s_i); + test("\u045176-9900", "" + f_strU + f_sM); + test("\u045176935228928", "" + f_strU + s_l); + test("\u045176-8400", "" + f_strU + sf_sM); + test("\u045176C(82)", "" + f_strU + s_o); + test("\u045176null", "" + f_strU + sf_oNtS); + test("\u045176true", "" + f_strU + s_bl); + test("\u0451763900", "" + f_strU + s_s); + test("\u045176null", "" + f_strU + sf_oN); + test("\u04517694000000", "" + f_strU + f_I); + test("\u045176null", "" + f_strU + f_IN); + test("\u045176true", "" + f_strU + sf_bl); + test("\u0451765500", "" + f_strU + sf_s); + test("\u045176-2900", "" + f_strU + s_sM); + test("\u045176-194313216", "" + f_strU + sf_l); + test("\u04517612", "" + f_strU + s_strU1); + test("\u045176C(87)", "" + f_strU + sf_o); + test("\u04517691", "" + f_strU + s_strU2); + test("\u04517621", "" + f_strU + f_strU1); + test("\u04517618", "" + f_strU + f_strU2); + test("\u045176null", "" + f_strU + f_iAN); + test("\u045176null", "" + f_strU + s_oN); + test("\u045176\u045180", "" + f_strU + s_strU); + test("\u045176C", "" + f_strU + sf_c); + test("\u04517675", "" + f_strU + sf_str); + test("\u045176-43", "" + f_strU + s_bM); + test("\u04517680", "" + f_strU + sf_b); + test("\u045176null", "" + f_strU + s_IN); + test("\u045176-52.0", "" + f_strU + s_fM); + test("\u04517675000000", "" + f_strU + sf_i); + test("\u04517644", "" + f_strU + f_b); + test("\u045176-1705032704", "" + f_strU + sf_lM); + test("\u045176null", "" + f_strU + f_oAN); + test("\u04517683.0", "" + f_strU + f_d); + test("\u045176I", "" + f_strU + f_c); + test("\u04517694.0", "" + f_strU + f_f); + test("\u04517612.0", "" + f_strU + sf_d); + test("\u045176-99.0", "" + f_strU + f_dM); + test("\u04517617.0", "" + f_strU + sf_f); + test("\u045176-84.0", "" + f_strU + sf_dM); + test("\u04517658000000", "" + f_strU + f_i); + test("\u045176-55000000", "" + f_strU + f_iM); + test("\u0451761460392448", "" + f_strU + f_l); + test("\u045176C(70)", "" + f_strU + f_o); + test("\u045176\u04511", "" + f_strU + sf_strU); + test("\u0451768000", "" + f_strU + f_s); + test("\u04517618", "" + f_strU + s_str); + test("\u045176-1000000", "" + f_strU + s_iM); + test("\u0451761000000", "" + f_strU + sf_I); + test("\u045176null", "" + f_strU + f_oNtS); + test("\u045176false", "" + f_strU + f_bl); + test("\u045176null", "" + f_strU + sf_iAN); + test("\u045176-2000000", "" + f_strU + sf_iM); + test("\u045176-820130816", "" + f_strU + f_lM); + test("\u045176null", "" + f_strU + sf_oAN); + test("\u04517625000000", "" + f_strU + s_I); + test("92-96.0", "" + sf_strU2 + s_dM); + test("92null", "" + sf_strU2 + s_oNtS); + test("92\u045176", "" + sf_strU2 + f_strU); + test("9292", "" + sf_strU2 + sf_strU2); + test("9251", "" + sf_strU2 + sf_strU1); + test("92null", "" + sf_strU2 + s_iAN); + test("92-54", "" + sf_strU2 + f_bM); + test("92-87.0", "" + sf_strU2 + f_fM); + test("92null", "" + sf_strU2 + s_oAN); + test("9219", "" + sf_strU2 + f_str); + test("92-41", "" + sf_strU2 + sf_bM); + test("92null", "" + sf_strU2 + sf_IN); + test("92T", "" + sf_strU2 + s_c); + test("92-42.0", "" + sf_strU2 + sf_fM); + test("9225", "" + sf_strU2 + s_b); + test("92null", "" + sf_strU2 + f_oN); + test("92-1410065408", "" + sf_strU2 + s_lM); + test("928.0", "" + sf_strU2 + s_d); + test("9255.0", "" + sf_strU2 + s_f); + test("9297000000", "" + sf_strU2 + s_i); + test("92-9900", "" + sf_strU2 + f_sM); + test("92935228928", "" + sf_strU2 + s_l); + test("92-8400", "" + sf_strU2 + sf_sM); + test("92C(82)", "" + sf_strU2 + s_o); + test("92null", "" + sf_strU2 + sf_oNtS); + test("92true", "" + sf_strU2 + s_bl); + test("923900", "" + sf_strU2 + s_s); + test("92null", "" + sf_strU2 + sf_oN); + test("9294000000", "" + sf_strU2 + f_I); + test("92null", "" + sf_strU2 + f_IN); + test("92true", "" + sf_strU2 + sf_bl); + test("925500", "" + sf_strU2 + sf_s); + test("92-2900", "" + sf_strU2 + s_sM); + test("92-194313216", "" + sf_strU2 + sf_l); + test("9212", "" + sf_strU2 + s_strU1); + test("92C(87)", "" + sf_strU2 + sf_o); + test("9291", "" + sf_strU2 + s_strU2); + test("9221", "" + sf_strU2 + f_strU1); + test("9218", "" + sf_strU2 + f_strU2); + test("92null", "" + sf_strU2 + f_iAN); + test("92null", "" + sf_strU2 + s_oN); + test("92\u045180", "" + sf_strU2 + s_strU); + test("92C", "" + sf_strU2 + sf_c); + test("9275", "" + sf_strU2 + sf_str); + test("92-43", "" + sf_strU2 + s_bM); + test("9280", "" + sf_strU2 + sf_b); + test("92null", "" + sf_strU2 + s_IN); + test("92-52.0", "" + sf_strU2 + s_fM); + test("9275000000", "" + sf_strU2 + sf_i); + test("9244", "" + sf_strU2 + f_b); + test("92-1705032704", "" + sf_strU2 + sf_lM); + test("92null", "" + sf_strU2 + f_oAN); + test("9283.0", "" + sf_strU2 + f_d); + test("92I", "" + sf_strU2 + f_c); + test("9294.0", "" + sf_strU2 + f_f); + test("9212.0", "" + sf_strU2 + sf_d); + test("92-99.0", "" + sf_strU2 + f_dM); + test("9217.0", "" + sf_strU2 + sf_f); + test("92-84.0", "" + sf_strU2 + sf_dM); + test("9258000000", "" + sf_strU2 + f_i); + test("92-55000000", "" + sf_strU2 + f_iM); + test("921460392448", "" + sf_strU2 + f_l); + test("92C(70)", "" + sf_strU2 + f_o); + test("92\u04511", "" + sf_strU2 + sf_strU); + test("928000", "" + sf_strU2 + f_s); + test("9218", "" + sf_strU2 + s_str); + test("92-1000000", "" + sf_strU2 + s_iM); + test("921000000", "" + sf_strU2 + sf_I); + test("92null", "" + sf_strU2 + f_oNtS); + test("92false", "" + sf_strU2 + f_bl); + test("92null", "" + sf_strU2 + sf_iAN); + test("92-2000000", "" + sf_strU2 + sf_iM); + test("92-820130816", "" + sf_strU2 + f_lM); + test("92null", "" + sf_strU2 + sf_oAN); + test("9225000000", "" + sf_strU2 + s_I); + test("51-96.0", "" + sf_strU1 + s_dM); + test("51null", "" + sf_strU1 + s_oNtS); + test("51\u045176", "" + sf_strU1 + f_strU); + test("5192", "" + sf_strU1 + sf_strU2); + test("5151", "" + sf_strU1 + sf_strU1); + test("51null", "" + sf_strU1 + s_iAN); + test("51-54", "" + sf_strU1 + f_bM); + test("51-87.0", "" + sf_strU1 + f_fM); + test("51null", "" + sf_strU1 + s_oAN); + test("5119", "" + sf_strU1 + f_str); + test("51-41", "" + sf_strU1 + sf_bM); + test("51null", "" + sf_strU1 + sf_IN); + test("51T", "" + sf_strU1 + s_c); + test("51-42.0", "" + sf_strU1 + sf_fM); + test("5125", "" + sf_strU1 + s_b); + test("51null", "" + sf_strU1 + f_oN); + test("51-1410065408", "" + sf_strU1 + s_lM); + test("518.0", "" + sf_strU1 + s_d); + test("5155.0", "" + sf_strU1 + s_f); + test("5197000000", "" + sf_strU1 + s_i); + test("51-9900", "" + sf_strU1 + f_sM); + test("51935228928", "" + sf_strU1 + s_l); + test("51-8400", "" + sf_strU1 + sf_sM); + test("51C(82)", "" + sf_strU1 + s_o); + test("51null", "" + sf_strU1 + sf_oNtS); + test("51true", "" + sf_strU1 + s_bl); + test("513900", "" + sf_strU1 + s_s); + test("51null", "" + sf_strU1 + sf_oN); + test("5194000000", "" + sf_strU1 + f_I); + test("51null", "" + sf_strU1 + f_IN); + test("51true", "" + sf_strU1 + sf_bl); + test("515500", "" + sf_strU1 + sf_s); + test("51-2900", "" + sf_strU1 + s_sM); + test("51-194313216", "" + sf_strU1 + sf_l); + test("5112", "" + sf_strU1 + s_strU1); + test("51C(87)", "" + sf_strU1 + sf_o); + test("5191", "" + sf_strU1 + s_strU2); + test("5121", "" + sf_strU1 + f_strU1); + test("5118", "" + sf_strU1 + f_strU2); + test("51null", "" + sf_strU1 + f_iAN); + test("51null", "" + sf_strU1 + s_oN); + test("51\u045180", "" + sf_strU1 + s_strU); + test("51C", "" + sf_strU1 + sf_c); + test("5175", "" + sf_strU1 + sf_str); + test("51-43", "" + sf_strU1 + s_bM); + test("5180", "" + sf_strU1 + sf_b); + test("51null", "" + sf_strU1 + s_IN); + test("51-52.0", "" + sf_strU1 + s_fM); + test("5175000000", "" + sf_strU1 + sf_i); + test("5144", "" + sf_strU1 + f_b); + test("51-1705032704", "" + sf_strU1 + sf_lM); + test("51null", "" + sf_strU1 + f_oAN); + test("5183.0", "" + sf_strU1 + f_d); + test("51I", "" + sf_strU1 + f_c); + test("5194.0", "" + sf_strU1 + f_f); + test("5112.0", "" + sf_strU1 + sf_d); + test("51-99.0", "" + sf_strU1 + f_dM); + test("5117.0", "" + sf_strU1 + sf_f); + test("51-84.0", "" + sf_strU1 + sf_dM); + test("5158000000", "" + sf_strU1 + f_i); + test("51-55000000", "" + sf_strU1 + f_iM); + test("511460392448", "" + sf_strU1 + f_l); + test("51C(70)", "" + sf_strU1 + f_o); + test("51\u04511", "" + sf_strU1 + sf_strU); + test("518000", "" + sf_strU1 + f_s); + test("5118", "" + sf_strU1 + s_str); + test("51-1000000", "" + sf_strU1 + s_iM); + test("511000000", "" + sf_strU1 + sf_I); + test("51null", "" + sf_strU1 + f_oNtS); + test("51false", "" + sf_strU1 + f_bl); + test("51null", "" + sf_strU1 + sf_iAN); + test("51-2000000", "" + sf_strU1 + sf_iM); + test("51-820130816", "" + sf_strU1 + f_lM); + test("51null", "" + sf_strU1 + sf_oAN); + test("5125000000", "" + sf_strU1 + s_I); + test("null-96.0", "" + s_iAN + s_dM); + test("nullnull", "" + s_iAN + s_oNtS); + test("null\u045176", "" + s_iAN + f_strU); + test("null92", "" + s_iAN + sf_strU2); + test("null51", "" + s_iAN + sf_strU1); + test("nullnull", "" + s_iAN + s_iAN); + test("null-54", "" + s_iAN + f_bM); + test("null-87.0", "" + s_iAN + f_fM); + test("nullnull", "" + s_iAN + s_oAN); + test("null19", "" + s_iAN + f_str); + test("null-41", "" + s_iAN + sf_bM); + test("nullnull", "" + s_iAN + sf_IN); + test("nullT", "" + s_iAN + s_c); + test("null-42.0", "" + s_iAN + sf_fM); + test("null25", "" + s_iAN + s_b); + test("nullnull", "" + s_iAN + f_oN); + test("null-1410065408", "" + s_iAN + s_lM); + test("null8.0", "" + s_iAN + s_d); + test("null55.0", "" + s_iAN + s_f); + test("null97000000", "" + s_iAN + s_i); + test("null-9900", "" + s_iAN + f_sM); + test("null935228928", "" + s_iAN + s_l); + test("null-8400", "" + s_iAN + sf_sM); + test("nullC(82)", "" + s_iAN + s_o); + test("nullnull", "" + s_iAN + sf_oNtS); + test("nulltrue", "" + s_iAN + s_bl); + test("null3900", "" + s_iAN + s_s); + test("nullnull", "" + s_iAN + sf_oN); + test("null94000000", "" + s_iAN + f_I); + test("nullnull", "" + s_iAN + f_IN); + test("nulltrue", "" + s_iAN + sf_bl); + test("null5500", "" + s_iAN + sf_s); + test("null-2900", "" + s_iAN + s_sM); + test("null-194313216", "" + s_iAN + sf_l); + test("null12", "" + s_iAN + s_strU1); + test("nullC(87)", "" + s_iAN + sf_o); + test("null91", "" + s_iAN + s_strU2); + test("null21", "" + s_iAN + f_strU1); + test("null18", "" + s_iAN + f_strU2); + test("nullnull", "" + s_iAN + f_iAN); + test("nullnull", "" + s_iAN + s_oN); + test("null\u045180", "" + s_iAN + s_strU); + test("nullC", "" + s_iAN + sf_c); + test("null75", "" + s_iAN + sf_str); + test("null-43", "" + s_iAN + s_bM); + test("null80", "" + s_iAN + sf_b); + test("nullnull", "" + s_iAN + s_IN); + test("null-52.0", "" + s_iAN + s_fM); + test("null75000000", "" + s_iAN + sf_i); + test("null44", "" + s_iAN + f_b); + test("null-1705032704", "" + s_iAN + sf_lM); + test("nullnull", "" + s_iAN + f_oAN); + test("null83.0", "" + s_iAN + f_d); + test("nullI", "" + s_iAN + f_c); + test("null94.0", "" + s_iAN + f_f); + test("null12.0", "" + s_iAN + sf_d); + test("null-99.0", "" + s_iAN + f_dM); + test("null17.0", "" + s_iAN + sf_f); + test("null-84.0", "" + s_iAN + sf_dM); + test("null58000000", "" + s_iAN + f_i); + test("null-55000000", "" + s_iAN + f_iM); + test("null1460392448", "" + s_iAN + f_l); + test("nullC(70)", "" + s_iAN + f_o); + test("null\u04511", "" + s_iAN + sf_strU); + test("null8000", "" + s_iAN + f_s); + test("null18", "" + s_iAN + s_str); + test("null-1000000", "" + s_iAN + s_iM); + test("null1000000", "" + s_iAN + sf_I); + test("nullnull", "" + s_iAN + f_oNtS); + test("nullfalse", "" + s_iAN + f_bl); + test("nullnull", "" + s_iAN + sf_iAN); + test("null-2000000", "" + s_iAN + sf_iM); + test("null-820130816", "" + s_iAN + f_lM); + test("nullnull", "" + s_iAN + sf_oAN); + test("null25000000", "" + s_iAN + s_I); + test("-54-96.0", "" + f_bM + s_dM); + test("-54null", "" + f_bM + s_oNtS); + test("-54\u045176", "" + f_bM + f_strU); + test("-5492", "" + f_bM + sf_strU2); + test("-5451", "" + f_bM + sf_strU1); + test("-54null", "" + f_bM + s_iAN); + test("-54-54", "" + f_bM + f_bM); + test("-54-87.0", "" + f_bM + f_fM); + test("-54null", "" + f_bM + s_oAN); + test("-5419", "" + f_bM + f_str); + test("-54-41", "" + f_bM + sf_bM); + test("-54null", "" + f_bM + sf_IN); + test("-54T", "" + f_bM + s_c); + test("-54-42.0", "" + f_bM + sf_fM); + test("-5425", "" + f_bM + s_b); + test("-54null", "" + f_bM + f_oN); + test("-54-1410065408", "" + f_bM + s_lM); + test("-548.0", "" + f_bM + s_d); + test("-5455.0", "" + f_bM + s_f); + test("-5497000000", "" + f_bM + s_i); + test("-54-9900", "" + f_bM + f_sM); + test("-54935228928", "" + f_bM + s_l); + test("-54-8400", "" + f_bM + sf_sM); + test("-54C(82)", "" + f_bM + s_o); + test("-54null", "" + f_bM + sf_oNtS); + test("-54true", "" + f_bM + s_bl); + test("-543900", "" + f_bM + s_s); + test("-54null", "" + f_bM + sf_oN); + test("-5494000000", "" + f_bM + f_I); + test("-54null", "" + f_bM + f_IN); + test("-54true", "" + f_bM + sf_bl); + test("-545500", "" + f_bM + sf_s); + test("-54-2900", "" + f_bM + s_sM); + test("-54-194313216", "" + f_bM + sf_l); + test("-5412", "" + f_bM + s_strU1); + test("-54C(87)", "" + f_bM + sf_o); + test("-5491", "" + f_bM + s_strU2); + test("-5421", "" + f_bM + f_strU1); + test("-5418", "" + f_bM + f_strU2); + test("-54null", "" + f_bM + f_iAN); + test("-54null", "" + f_bM + s_oN); + test("-54\u045180", "" + f_bM + s_strU); + test("-54C", "" + f_bM + sf_c); + test("-5475", "" + f_bM + sf_str); + test("-54-43", "" + f_bM + s_bM); + test("-5480", "" + f_bM + sf_b); + test("-54null", "" + f_bM + s_IN); + test("-54-52.0", "" + f_bM + s_fM); + test("-5475000000", "" + f_bM + sf_i); + test("-5444", "" + f_bM + f_b); + test("-54-1705032704", "" + f_bM + sf_lM); + test("-54null", "" + f_bM + f_oAN); + test("-5483.0", "" + f_bM + f_d); + test("-54I", "" + f_bM + f_c); + test("-5494.0", "" + f_bM + f_f); + test("-5412.0", "" + f_bM + sf_d); + test("-54-99.0", "" + f_bM + f_dM); + test("-5417.0", "" + f_bM + sf_f); + test("-54-84.0", "" + f_bM + sf_dM); + test("-5458000000", "" + f_bM + f_i); + test("-54-55000000", "" + f_bM + f_iM); + test("-541460392448", "" + f_bM + f_l); + test("-54C(70)", "" + f_bM + f_o); + test("-54\u04511", "" + f_bM + sf_strU); + test("-548000", "" + f_bM + f_s); + test("-5418", "" + f_bM + s_str); + test("-54-1000000", "" + f_bM + s_iM); + test("-541000000", "" + f_bM + sf_I); + test("-54null", "" + f_bM + f_oNtS); + test("-54false", "" + f_bM + f_bl); + test("-54null", "" + f_bM + sf_iAN); + test("-54-2000000", "" + f_bM + sf_iM); + test("-54-820130816", "" + f_bM + f_lM); + test("-54null", "" + f_bM + sf_oAN); + test("-5425000000", "" + f_bM + s_I); + test("-87.0-96.0", "" + f_fM + s_dM); + test("-87.0null", "" + f_fM + s_oNtS); + test("-87.0\u045176", "" + f_fM + f_strU); + test("-87.092", "" + f_fM + sf_strU2); + test("-87.051", "" + f_fM + sf_strU1); + test("-87.0null", "" + f_fM + s_iAN); + test("-87.0-54", "" + f_fM + f_bM); + test("-87.0-87.0", "" + f_fM + f_fM); + test("-87.0null", "" + f_fM + s_oAN); + test("-87.019", "" + f_fM + f_str); + test("-87.0-41", "" + f_fM + sf_bM); + test("-87.0null", "" + f_fM + sf_IN); + test("-87.0T", "" + f_fM + s_c); + test("-87.0-42.0", "" + f_fM + sf_fM); + test("-87.025", "" + f_fM + s_b); + test("-87.0null", "" + f_fM + f_oN); + test("-87.0-1410065408", "" + f_fM + s_lM); + test("-87.08.0", "" + f_fM + s_d); + test("-87.055.0", "" + f_fM + s_f); + test("-87.097000000", "" + f_fM + s_i); + test("-87.0-9900", "" + f_fM + f_sM); + test("-87.0935228928", "" + f_fM + s_l); + test("-87.0-8400", "" + f_fM + sf_sM); + test("-87.0C(82)", "" + f_fM + s_o); + test("-87.0null", "" + f_fM + sf_oNtS); + test("-87.0true", "" + f_fM + s_bl); + test("-87.03900", "" + f_fM + s_s); + test("-87.0null", "" + f_fM + sf_oN); + test("-87.094000000", "" + f_fM + f_I); + test("-87.0null", "" + f_fM + f_IN); + test("-87.0true", "" + f_fM + sf_bl); + test("-87.05500", "" + f_fM + sf_s); + test("-87.0-2900", "" + f_fM + s_sM); + test("-87.0-194313216", "" + f_fM + sf_l); + test("-87.012", "" + f_fM + s_strU1); + test("-87.0C(87)", "" + f_fM + sf_o); + test("-87.091", "" + f_fM + s_strU2); + test("-87.021", "" + f_fM + f_strU1); + test("-87.018", "" + f_fM + f_strU2); + test("-87.0null", "" + f_fM + f_iAN); + test("-87.0null", "" + f_fM + s_oN); + test("-87.0\u045180", "" + f_fM + s_strU); + test("-87.0C", "" + f_fM + sf_c); + test("-87.075", "" + f_fM + sf_str); + test("-87.0-43", "" + f_fM + s_bM); + test("-87.080", "" + f_fM + sf_b); + test("-87.0null", "" + f_fM + s_IN); + test("-87.0-52.0", "" + f_fM + s_fM); + test("-87.075000000", "" + f_fM + sf_i); + test("-87.044", "" + f_fM + f_b); + test("-87.0-1705032704", "" + f_fM + sf_lM); + test("-87.0null", "" + f_fM + f_oAN); + test("-87.083.0", "" + f_fM + f_d); + test("-87.0I", "" + f_fM + f_c); + test("-87.094.0", "" + f_fM + f_f); + test("-87.012.0", "" + f_fM + sf_d); + test("-87.0-99.0", "" + f_fM + f_dM); + test("-87.017.0", "" + f_fM + sf_f); + test("-87.0-84.0", "" + f_fM + sf_dM); + test("-87.058000000", "" + f_fM + f_i); + test("-87.0-55000000", "" + f_fM + f_iM); + test("-87.01460392448", "" + f_fM + f_l); + test("-87.0C(70)", "" + f_fM + f_o); + test("-87.0\u04511", "" + f_fM + sf_strU); + test("-87.08000", "" + f_fM + f_s); + test("-87.018", "" + f_fM + s_str); + test("-87.0-1000000", "" + f_fM + s_iM); + test("-87.01000000", "" + f_fM + sf_I); + test("-87.0null", "" + f_fM + f_oNtS); + test("-87.0false", "" + f_fM + f_bl); + test("-87.0null", "" + f_fM + sf_iAN); + test("-87.0-2000000", "" + f_fM + sf_iM); + test("-87.0-820130816", "" + f_fM + f_lM); + test("-87.0null", "" + f_fM + sf_oAN); + test("-87.025000000", "" + f_fM + s_I); + test("null-96.0", "" + s_oAN + s_dM); + test("nullnull", "" + s_oAN + s_oNtS); + test("null\u045176", "" + s_oAN + f_strU); + test("null92", "" + s_oAN + sf_strU2); + test("null51", "" + s_oAN + sf_strU1); + test("nullnull", "" + s_oAN + s_iAN); + test("null-54", "" + s_oAN + f_bM); + test("null-87.0", "" + s_oAN + f_fM); + test("nullnull", "" + s_oAN + s_oAN); + test("null19", "" + s_oAN + f_str); + test("null-41", "" + s_oAN + sf_bM); + test("nullnull", "" + s_oAN + sf_IN); + test("nullT", "" + s_oAN + s_c); + test("null-42.0", "" + s_oAN + sf_fM); + test("null25", "" + s_oAN + s_b); + test("nullnull", "" + s_oAN + f_oN); + test("null-1410065408", "" + s_oAN + s_lM); + test("null8.0", "" + s_oAN + s_d); + test("null55.0", "" + s_oAN + s_f); + test("null97000000", "" + s_oAN + s_i); + test("null-9900", "" + s_oAN + f_sM); + test("null935228928", "" + s_oAN + s_l); + test("null-8400", "" + s_oAN + sf_sM); + test("nullC(82)", "" + s_oAN + s_o); + test("nullnull", "" + s_oAN + sf_oNtS); + test("nulltrue", "" + s_oAN + s_bl); + test("null3900", "" + s_oAN + s_s); + test("nullnull", "" + s_oAN + sf_oN); + test("null94000000", "" + s_oAN + f_I); + test("nullnull", "" + s_oAN + f_IN); + test("nulltrue", "" + s_oAN + sf_bl); + test("null5500", "" + s_oAN + sf_s); + test("null-2900", "" + s_oAN + s_sM); + test("null-194313216", "" + s_oAN + sf_l); + test("null12", "" + s_oAN + s_strU1); + test("nullC(87)", "" + s_oAN + sf_o); + test("null91", "" + s_oAN + s_strU2); + test("null21", "" + s_oAN + f_strU1); + test("null18", "" + s_oAN + f_strU2); + test("nullnull", "" + s_oAN + f_iAN); + test("nullnull", "" + s_oAN + s_oN); + test("null\u045180", "" + s_oAN + s_strU); + test("nullC", "" + s_oAN + sf_c); + test("null75", "" + s_oAN + sf_str); + test("null-43", "" + s_oAN + s_bM); + test("null80", "" + s_oAN + sf_b); + test("nullnull", "" + s_oAN + s_IN); + test("null-52.0", "" + s_oAN + s_fM); + test("null75000000", "" + s_oAN + sf_i); + test("null44", "" + s_oAN + f_b); + test("null-1705032704", "" + s_oAN + sf_lM); + test("nullnull", "" + s_oAN + f_oAN); + test("null83.0", "" + s_oAN + f_d); + test("nullI", "" + s_oAN + f_c); + test("null94.0", "" + s_oAN + f_f); + test("null12.0", "" + s_oAN + sf_d); + test("null-99.0", "" + s_oAN + f_dM); + test("null17.0", "" + s_oAN + sf_f); + test("null-84.0", "" + s_oAN + sf_dM); + test("null58000000", "" + s_oAN + f_i); + test("null-55000000", "" + s_oAN + f_iM); + test("null1460392448", "" + s_oAN + f_l); + test("nullC(70)", "" + s_oAN + f_o); + test("null\u04511", "" + s_oAN + sf_strU); + test("null8000", "" + s_oAN + f_s); + test("null18", "" + s_oAN + s_str); + test("null-1000000", "" + s_oAN + s_iM); + test("null1000000", "" + s_oAN + sf_I); + test("nullnull", "" + s_oAN + f_oNtS); + test("nullfalse", "" + s_oAN + f_bl); + test("nullnull", "" + s_oAN + sf_iAN); + test("null-2000000", "" + s_oAN + sf_iM); + test("null-820130816", "" + s_oAN + f_lM); + test("nullnull", "" + s_oAN + sf_oAN); + test("null25000000", "" + s_oAN + s_I); + test("19-96.0", "" + f_str + s_dM); + test("19null", "" + f_str + s_oNtS); + test("19\u045176", "" + f_str + f_strU); + test("1992", "" + f_str + sf_strU2); + test("1951", "" + f_str + sf_strU1); + test("19null", "" + f_str + s_iAN); + test("19-54", "" + f_str + f_bM); + test("19-87.0", "" + f_str + f_fM); + test("19null", "" + f_str + s_oAN); + test("1919", "" + f_str + f_str); + test("19-41", "" + f_str + sf_bM); + test("19null", "" + f_str + sf_IN); + test("19T", "" + f_str + s_c); + test("19-42.0", "" + f_str + sf_fM); + test("1925", "" + f_str + s_b); + test("19null", "" + f_str + f_oN); + test("19-1410065408", "" + f_str + s_lM); + test("198.0", "" + f_str + s_d); + test("1955.0", "" + f_str + s_f); + test("1997000000", "" + f_str + s_i); + test("19-9900", "" + f_str + f_sM); + test("19935228928", "" + f_str + s_l); + test("19-8400", "" + f_str + sf_sM); + test("19C(82)", "" + f_str + s_o); + test("19null", "" + f_str + sf_oNtS); + test("19true", "" + f_str + s_bl); + test("193900", "" + f_str + s_s); + test("19null", "" + f_str + sf_oN); + test("1994000000", "" + f_str + f_I); + test("19null", "" + f_str + f_IN); + test("19true", "" + f_str + sf_bl); + test("195500", "" + f_str + sf_s); + test("19-2900", "" + f_str + s_sM); + test("19-194313216", "" + f_str + sf_l); + test("1912", "" + f_str + s_strU1); + test("19C(87)", "" + f_str + sf_o); + test("1991", "" + f_str + s_strU2); + test("1921", "" + f_str + f_strU1); + test("1918", "" + f_str + f_strU2); + test("19null", "" + f_str + f_iAN); + test("19null", "" + f_str + s_oN); + test("19\u045180", "" + f_str + s_strU); + test("19C", "" + f_str + sf_c); + test("1975", "" + f_str + sf_str); + test("19-43", "" + f_str + s_bM); + test("1980", "" + f_str + sf_b); + test("19null", "" + f_str + s_IN); + test("19-52.0", "" + f_str + s_fM); + test("1975000000", "" + f_str + sf_i); + test("1944", "" + f_str + f_b); + test("19-1705032704", "" + f_str + sf_lM); + test("19null", "" + f_str + f_oAN); + test("1983.0", "" + f_str + f_d); + test("19I", "" + f_str + f_c); + test("1994.0", "" + f_str + f_f); + test("1912.0", "" + f_str + sf_d); + test("19-99.0", "" + f_str + f_dM); + test("1917.0", "" + f_str + sf_f); + test("19-84.0", "" + f_str + sf_dM); + test("1958000000", "" + f_str + f_i); + test("19-55000000", "" + f_str + f_iM); + test("191460392448", "" + f_str + f_l); + test("19C(70)", "" + f_str + f_o); + test("19\u04511", "" + f_str + sf_strU); + test("198000", "" + f_str + f_s); + test("1918", "" + f_str + s_str); + test("19-1000000", "" + f_str + s_iM); + test("191000000", "" + f_str + sf_I); + test("19null", "" + f_str + f_oNtS); + test("19false", "" + f_str + f_bl); + test("19null", "" + f_str + sf_iAN); + test("19-2000000", "" + f_str + sf_iM); + test("19-820130816", "" + f_str + f_lM); + test("19null", "" + f_str + sf_oAN); + test("1925000000", "" + f_str + s_I); + test("-41-96.0", "" + sf_bM + s_dM); + test("-41null", "" + sf_bM + s_oNtS); + test("-41\u045176", "" + sf_bM + f_strU); + test("-4192", "" + sf_bM + sf_strU2); + test("-4151", "" + sf_bM + sf_strU1); + test("-41null", "" + sf_bM + s_iAN); + test("-41-54", "" + sf_bM + f_bM); + test("-41-87.0", "" + sf_bM + f_fM); + test("-41null", "" + sf_bM + s_oAN); + test("-4119", "" + sf_bM + f_str); + test("-41-41", "" + sf_bM + sf_bM); + test("-41null", "" + sf_bM + sf_IN); + test("-41T", "" + sf_bM + s_c); + test("-41-42.0", "" + sf_bM + sf_fM); + test("-4125", "" + sf_bM + s_b); + test("-41null", "" + sf_bM + f_oN); + test("-41-1410065408", "" + sf_bM + s_lM); + test("-418.0", "" + sf_bM + s_d); + test("-4155.0", "" + sf_bM + s_f); + test("-4197000000", "" + sf_bM + s_i); + test("-41-9900", "" + sf_bM + f_sM); + test("-41935228928", "" + sf_bM + s_l); + test("-41-8400", "" + sf_bM + sf_sM); + test("-41C(82)", "" + sf_bM + s_o); + test("-41null", "" + sf_bM + sf_oNtS); + test("-41true", "" + sf_bM + s_bl); + test("-413900", "" + sf_bM + s_s); + test("-41null", "" + sf_bM + sf_oN); + test("-4194000000", "" + sf_bM + f_I); + test("-41null", "" + sf_bM + f_IN); + test("-41true", "" + sf_bM + sf_bl); + test("-415500", "" + sf_bM + sf_s); + test("-41-2900", "" + sf_bM + s_sM); + test("-41-194313216", "" + sf_bM + sf_l); + test("-4112", "" + sf_bM + s_strU1); + test("-41C(87)", "" + sf_bM + sf_o); + test("-4191", "" + sf_bM + s_strU2); + test("-4121", "" + sf_bM + f_strU1); + test("-4118", "" + sf_bM + f_strU2); + test("-41null", "" + sf_bM + f_iAN); + test("-41null", "" + sf_bM + s_oN); + test("-41\u045180", "" + sf_bM + s_strU); + test("-41C", "" + sf_bM + sf_c); + test("-4175", "" + sf_bM + sf_str); + test("-41-43", "" + sf_bM + s_bM); + test("-4180", "" + sf_bM + sf_b); + test("-41null", "" + sf_bM + s_IN); + test("-41-52.0", "" + sf_bM + s_fM); + test("-4175000000", "" + sf_bM + sf_i); + test("-4144", "" + sf_bM + f_b); + test("-41-1705032704", "" + sf_bM + sf_lM); + test("-41null", "" + sf_bM + f_oAN); + test("-4183.0", "" + sf_bM + f_d); + test("-41I", "" + sf_bM + f_c); + test("-4194.0", "" + sf_bM + f_f); + test("-4112.0", "" + sf_bM + sf_d); + test("-41-99.0", "" + sf_bM + f_dM); + test("-4117.0", "" + sf_bM + sf_f); + test("-41-84.0", "" + sf_bM + sf_dM); + test("-4158000000", "" + sf_bM + f_i); + test("-41-55000000", "" + sf_bM + f_iM); + test("-411460392448", "" + sf_bM + f_l); + test("-41C(70)", "" + sf_bM + f_o); + test("-41\u04511", "" + sf_bM + sf_strU); + test("-418000", "" + sf_bM + f_s); + test("-4118", "" + sf_bM + s_str); + test("-41-1000000", "" + sf_bM + s_iM); + test("-411000000", "" + sf_bM + sf_I); + test("-41null", "" + sf_bM + f_oNtS); + test("-41false", "" + sf_bM + f_bl); + test("-41null", "" + sf_bM + sf_iAN); + test("-41-2000000", "" + sf_bM + sf_iM); + test("-41-820130816", "" + sf_bM + f_lM); + test("-41null", "" + sf_bM + sf_oAN); + test("-4125000000", "" + sf_bM + s_I); + test("null-96.0", "" + sf_IN + s_dM); + test("nullnull", "" + sf_IN + s_oNtS); + test("null\u045176", "" + sf_IN + f_strU); + test("null92", "" + sf_IN + sf_strU2); + test("null51", "" + sf_IN + sf_strU1); + test("nullnull", "" + sf_IN + s_iAN); + test("null-54", "" + sf_IN + f_bM); + test("null-87.0", "" + sf_IN + f_fM); + test("nullnull", "" + sf_IN + s_oAN); + test("null19", "" + sf_IN + f_str); + test("null-41", "" + sf_IN + sf_bM); + test("nullnull", "" + sf_IN + sf_IN); + test("nullT", "" + sf_IN + s_c); + test("null-42.0", "" + sf_IN + sf_fM); + test("null25", "" + sf_IN + s_b); + test("nullnull", "" + sf_IN + f_oN); + test("null-1410065408", "" + sf_IN + s_lM); + test("null8.0", "" + sf_IN + s_d); + test("null55.0", "" + sf_IN + s_f); + test("null97000000", "" + sf_IN + s_i); + test("null-9900", "" + sf_IN + f_sM); + test("null935228928", "" + sf_IN + s_l); + test("null-8400", "" + sf_IN + sf_sM); + test("nullC(82)", "" + sf_IN + s_o); + test("nullnull", "" + sf_IN + sf_oNtS); + test("nulltrue", "" + sf_IN + s_bl); + test("null3900", "" + sf_IN + s_s); + test("nullnull", "" + sf_IN + sf_oN); + test("null94000000", "" + sf_IN + f_I); + test("nullnull", "" + sf_IN + f_IN); + test("nulltrue", "" + sf_IN + sf_bl); + test("null5500", "" + sf_IN + sf_s); + test("null-2900", "" + sf_IN + s_sM); + test("null-194313216", "" + sf_IN + sf_l); + test("null12", "" + sf_IN + s_strU1); + test("nullC(87)", "" + sf_IN + sf_o); + test("null91", "" + sf_IN + s_strU2); + test("null21", "" + sf_IN + f_strU1); + test("null18", "" + sf_IN + f_strU2); + test("nullnull", "" + sf_IN + f_iAN); + test("nullnull", "" + sf_IN + s_oN); + test("null\u045180", "" + sf_IN + s_strU); + test("nullC", "" + sf_IN + sf_c); + test("null75", "" + sf_IN + sf_str); + test("null-43", "" + sf_IN + s_bM); + test("null80", "" + sf_IN + sf_b); + test("nullnull", "" + sf_IN + s_IN); + test("null-52.0", "" + sf_IN + s_fM); + test("null75000000", "" + sf_IN + sf_i); + test("null44", "" + sf_IN + f_b); + test("null-1705032704", "" + sf_IN + sf_lM); + test("nullnull", "" + sf_IN + f_oAN); + test("null83.0", "" + sf_IN + f_d); + test("nullI", "" + sf_IN + f_c); + test("null94.0", "" + sf_IN + f_f); + test("null12.0", "" + sf_IN + sf_d); + test("null-99.0", "" + sf_IN + f_dM); + test("null17.0", "" + sf_IN + sf_f); + test("null-84.0", "" + sf_IN + sf_dM); + test("null58000000", "" + sf_IN + f_i); + test("null-55000000", "" + sf_IN + f_iM); + test("null1460392448", "" + sf_IN + f_l); + test("nullC(70)", "" + sf_IN + f_o); + test("null\u04511", "" + sf_IN + sf_strU); + test("null8000", "" + sf_IN + f_s); + test("null18", "" + sf_IN + s_str); + test("null-1000000", "" + sf_IN + s_iM); + test("null1000000", "" + sf_IN + sf_I); + test("nullnull", "" + sf_IN + f_oNtS); + test("nullfalse", "" + sf_IN + f_bl); + test("nullnull", "" + sf_IN + sf_iAN); + test("null-2000000", "" + sf_IN + sf_iM); + test("null-820130816", "" + sf_IN + f_lM); + test("nullnull", "" + sf_IN + sf_oAN); + test("null25000000", "" + sf_IN + s_I); + test("T-96.0", "" + s_c + s_dM); + test("Tnull", "" + s_c + s_oNtS); + test("T\u045176", "" + s_c + f_strU); + test("T92", "" + s_c + sf_strU2); + test("T51", "" + s_c + sf_strU1); + test("Tnull", "" + s_c + s_iAN); + test("T-54", "" + s_c + f_bM); + test("T-87.0", "" + s_c + f_fM); + test("Tnull", "" + s_c + s_oAN); + test("T19", "" + s_c + f_str); + test("T-41", "" + s_c + sf_bM); + test("Tnull", "" + s_c + sf_IN); + test("TT", "" + s_c + s_c); + test("T-42.0", "" + s_c + sf_fM); + test("T25", "" + s_c + s_b); + test("Tnull", "" + s_c + f_oN); + test("T-1410065408", "" + s_c + s_lM); + test("T8.0", "" + s_c + s_d); + test("T55.0", "" + s_c + s_f); + test("T97000000", "" + s_c + s_i); + test("T-9900", "" + s_c + f_sM); + test("T935228928", "" + s_c + s_l); + test("T-8400", "" + s_c + sf_sM); + test("TC(82)", "" + s_c + s_o); + test("Tnull", "" + s_c + sf_oNtS); + } + + public void run1() { + test("Ttrue", "" + s_c + s_bl); + test("T3900", "" + s_c + s_s); + test("Tnull", "" + s_c + sf_oN); + test("T94000000", "" + s_c + f_I); + test("Tnull", "" + s_c + f_IN); + test("Ttrue", "" + s_c + sf_bl); + test("T5500", "" + s_c + sf_s); + test("T-2900", "" + s_c + s_sM); + test("T-194313216", "" + s_c + sf_l); + test("T12", "" + s_c + s_strU1); + test("TC(87)", "" + s_c + sf_o); + test("T91", "" + s_c + s_strU2); + test("T21", "" + s_c + f_strU1); + test("T18", "" + s_c + f_strU2); + test("Tnull", "" + s_c + f_iAN); + test("Tnull", "" + s_c + s_oN); + test("T\u045180", "" + s_c + s_strU); + test("TC", "" + s_c + sf_c); + test("T75", "" + s_c + sf_str); + test("T-43", "" + s_c + s_bM); + test("T80", "" + s_c + sf_b); + test("Tnull", "" + s_c + s_IN); + test("T-52.0", "" + s_c + s_fM); + test("T75000000", "" + s_c + sf_i); + test("T44", "" + s_c + f_b); + test("T-1705032704", "" + s_c + sf_lM); + test("Tnull", "" + s_c + f_oAN); + test("T83.0", "" + s_c + f_d); + test("TI", "" + s_c + f_c); + test("T94.0", "" + s_c + f_f); + test("T12.0", "" + s_c + sf_d); + test("T-99.0", "" + s_c + f_dM); + test("T17.0", "" + s_c + sf_f); + test("T-84.0", "" + s_c + sf_dM); + test("T58000000", "" + s_c + f_i); + test("T-55000000", "" + s_c + f_iM); + test("T1460392448", "" + s_c + f_l); + test("TC(70)", "" + s_c + f_o); + test("T\u04511", "" + s_c + sf_strU); + test("T8000", "" + s_c + f_s); + test("T18", "" + s_c + s_str); + test("T-1000000", "" + s_c + s_iM); + test("T1000000", "" + s_c + sf_I); + test("Tnull", "" + s_c + f_oNtS); + test("Tfalse", "" + s_c + f_bl); + test("Tnull", "" + s_c + sf_iAN); + test("T-2000000", "" + s_c + sf_iM); + test("T-820130816", "" + s_c + f_lM); + test("Tnull", "" + s_c + sf_oAN); + test("T25000000", "" + s_c + s_I); + test("-42.0-96.0", "" + sf_fM + s_dM); + test("-42.0null", "" + sf_fM + s_oNtS); + test("-42.0\u045176", "" + sf_fM + f_strU); + test("-42.092", "" + sf_fM + sf_strU2); + test("-42.051", "" + sf_fM + sf_strU1); + test("-42.0null", "" + sf_fM + s_iAN); + test("-42.0-54", "" + sf_fM + f_bM); + test("-42.0-87.0", "" + sf_fM + f_fM); + test("-42.0null", "" + sf_fM + s_oAN); + test("-42.019", "" + sf_fM + f_str); + test("-42.0-41", "" + sf_fM + sf_bM); + test("-42.0null", "" + sf_fM + sf_IN); + test("-42.0T", "" + sf_fM + s_c); + test("-42.0-42.0", "" + sf_fM + sf_fM); + test("-42.025", "" + sf_fM + s_b); + test("-42.0null", "" + sf_fM + f_oN); + test("-42.0-1410065408", "" + sf_fM + s_lM); + test("-42.08.0", "" + sf_fM + s_d); + test("-42.055.0", "" + sf_fM + s_f); + test("-42.097000000", "" + sf_fM + s_i); + test("-42.0-9900", "" + sf_fM + f_sM); + test("-42.0935228928", "" + sf_fM + s_l); + test("-42.0-8400", "" + sf_fM + sf_sM); + test("-42.0C(82)", "" + sf_fM + s_o); + test("-42.0null", "" + sf_fM + sf_oNtS); + test("-42.0true", "" + sf_fM + s_bl); + test("-42.03900", "" + sf_fM + s_s); + test("-42.0null", "" + sf_fM + sf_oN); + test("-42.094000000", "" + sf_fM + f_I); + test("-42.0null", "" + sf_fM + f_IN); + test("-42.0true", "" + sf_fM + sf_bl); + test("-42.05500", "" + sf_fM + sf_s); + test("-42.0-2900", "" + sf_fM + s_sM); + test("-42.0-194313216", "" + sf_fM + sf_l); + test("-42.012", "" + sf_fM + s_strU1); + test("-42.0C(87)", "" + sf_fM + sf_o); + test("-42.091", "" + sf_fM + s_strU2); + test("-42.021", "" + sf_fM + f_strU1); + test("-42.018", "" + sf_fM + f_strU2); + test("-42.0null", "" + sf_fM + f_iAN); + test("-42.0null", "" + sf_fM + s_oN); + test("-42.0\u045180", "" + sf_fM + s_strU); + test("-42.0C", "" + sf_fM + sf_c); + test("-42.075", "" + sf_fM + sf_str); + test("-42.0-43", "" + sf_fM + s_bM); + test("-42.080", "" + sf_fM + sf_b); + test("-42.0null", "" + sf_fM + s_IN); + test("-42.0-52.0", "" + sf_fM + s_fM); + test("-42.075000000", "" + sf_fM + sf_i); + test("-42.044", "" + sf_fM + f_b); + test("-42.0-1705032704", "" + sf_fM + sf_lM); + test("-42.0null", "" + sf_fM + f_oAN); + test("-42.083.0", "" + sf_fM + f_d); + test("-42.0I", "" + sf_fM + f_c); + test("-42.094.0", "" + sf_fM + f_f); + test("-42.012.0", "" + sf_fM + sf_d); + test("-42.0-99.0", "" + sf_fM + f_dM); + test("-42.017.0", "" + sf_fM + sf_f); + test("-42.0-84.0", "" + sf_fM + sf_dM); + test("-42.058000000", "" + sf_fM + f_i); + test("-42.0-55000000", "" + sf_fM + f_iM); + test("-42.01460392448", "" + sf_fM + f_l); + test("-42.0C(70)", "" + sf_fM + f_o); + test("-42.0\u04511", "" + sf_fM + sf_strU); + test("-42.08000", "" + sf_fM + f_s); + test("-42.018", "" + sf_fM + s_str); + test("-42.0-1000000", "" + sf_fM + s_iM); + test("-42.01000000", "" + sf_fM + sf_I); + test("-42.0null", "" + sf_fM + f_oNtS); + test("-42.0false", "" + sf_fM + f_bl); + test("-42.0null", "" + sf_fM + sf_iAN); + test("-42.0-2000000", "" + sf_fM + sf_iM); + test("-42.0-820130816", "" + sf_fM + f_lM); + test("-42.0null", "" + sf_fM + sf_oAN); + test("-42.025000000", "" + sf_fM + s_I); + test("25-96.0", "" + s_b + s_dM); + test("25null", "" + s_b + s_oNtS); + test("25\u045176", "" + s_b + f_strU); + test("2592", "" + s_b + sf_strU2); + test("2551", "" + s_b + sf_strU1); + test("25null", "" + s_b + s_iAN); + test("25-54", "" + s_b + f_bM); + test("25-87.0", "" + s_b + f_fM); + test("25null", "" + s_b + s_oAN); + test("2519", "" + s_b + f_str); + test("25-41", "" + s_b + sf_bM); + test("25null", "" + s_b + sf_IN); + test("25T", "" + s_b + s_c); + test("25-42.0", "" + s_b + sf_fM); + test("2525", "" + s_b + s_b); + test("25null", "" + s_b + f_oN); + test("25-1410065408", "" + s_b + s_lM); + test("258.0", "" + s_b + s_d); + test("2555.0", "" + s_b + s_f); + test("2597000000", "" + s_b + s_i); + test("25-9900", "" + s_b + f_sM); + test("25935228928", "" + s_b + s_l); + test("25-8400", "" + s_b + sf_sM); + test("25C(82)", "" + s_b + s_o); + test("25null", "" + s_b + sf_oNtS); + test("25true", "" + s_b + s_bl); + test("253900", "" + s_b + s_s); + test("25null", "" + s_b + sf_oN); + test("2594000000", "" + s_b + f_I); + test("25null", "" + s_b + f_IN); + test("25true", "" + s_b + sf_bl); + test("255500", "" + s_b + sf_s); + test("25-2900", "" + s_b + s_sM); + test("25-194313216", "" + s_b + sf_l); + test("2512", "" + s_b + s_strU1); + test("25C(87)", "" + s_b + sf_o); + test("2591", "" + s_b + s_strU2); + test("2521", "" + s_b + f_strU1); + test("2518", "" + s_b + f_strU2); + test("25null", "" + s_b + f_iAN); + test("25null", "" + s_b + s_oN); + test("25\u045180", "" + s_b + s_strU); + test("25C", "" + s_b + sf_c); + test("2575", "" + s_b + sf_str); + test("25-43", "" + s_b + s_bM); + test("2580", "" + s_b + sf_b); + test("25null", "" + s_b + s_IN); + test("25-52.0", "" + s_b + s_fM); + test("2575000000", "" + s_b + sf_i); + test("2544", "" + s_b + f_b); + test("25-1705032704", "" + s_b + sf_lM); + test("25null", "" + s_b + f_oAN); + test("2583.0", "" + s_b + f_d); + test("25I", "" + s_b + f_c); + test("2594.0", "" + s_b + f_f); + test("2512.0", "" + s_b + sf_d); + test("25-99.0", "" + s_b + f_dM); + test("2517.0", "" + s_b + sf_f); + test("25-84.0", "" + s_b + sf_dM); + test("2558000000", "" + s_b + f_i); + test("25-55000000", "" + s_b + f_iM); + test("251460392448", "" + s_b + f_l); + test("25C(70)", "" + s_b + f_o); + test("25\u04511", "" + s_b + sf_strU); + test("258000", "" + s_b + f_s); + test("2518", "" + s_b + s_str); + test("25-1000000", "" + s_b + s_iM); + test("251000000", "" + s_b + sf_I); + test("25null", "" + s_b + f_oNtS); + test("25false", "" + s_b + f_bl); + test("25null", "" + s_b + sf_iAN); + test("25-2000000", "" + s_b + sf_iM); + test("25-820130816", "" + s_b + f_lM); + test("25null", "" + s_b + sf_oAN); + test("2525000000", "" + s_b + s_I); + test("null-96.0", "" + f_oN + s_dM); + test("nullnull", "" + f_oN + s_oNtS); + test("null\u045176", "" + f_oN + f_strU); + test("null92", "" + f_oN + sf_strU2); + test("null51", "" + f_oN + sf_strU1); + test("nullnull", "" + f_oN + s_iAN); + test("null-54", "" + f_oN + f_bM); + test("null-87.0", "" + f_oN + f_fM); + test("nullnull", "" + f_oN + s_oAN); + test("null19", "" + f_oN + f_str); + test("null-41", "" + f_oN + sf_bM); + test("nullnull", "" + f_oN + sf_IN); + test("nullT", "" + f_oN + s_c); + test("null-42.0", "" + f_oN + sf_fM); + test("null25", "" + f_oN + s_b); + test("nullnull", "" + f_oN + f_oN); + test("null-1410065408", "" + f_oN + s_lM); + test("null8.0", "" + f_oN + s_d); + test("null55.0", "" + f_oN + s_f); + test("null97000000", "" + f_oN + s_i); + test("null-9900", "" + f_oN + f_sM); + test("null935228928", "" + f_oN + s_l); + test("null-8400", "" + f_oN + sf_sM); + test("nullC(82)", "" + f_oN + s_o); + test("nullnull", "" + f_oN + sf_oNtS); + test("nulltrue", "" + f_oN + s_bl); + test("null3900", "" + f_oN + s_s); + test("nullnull", "" + f_oN + sf_oN); + test("null94000000", "" + f_oN + f_I); + test("nullnull", "" + f_oN + f_IN); + test("nulltrue", "" + f_oN + sf_bl); + test("null5500", "" + f_oN + sf_s); + test("null-2900", "" + f_oN + s_sM); + test("null-194313216", "" + f_oN + sf_l); + test("null12", "" + f_oN + s_strU1); + test("nullC(87)", "" + f_oN + sf_o); + test("null91", "" + f_oN + s_strU2); + test("null21", "" + f_oN + f_strU1); + test("null18", "" + f_oN + f_strU2); + test("nullnull", "" + f_oN + f_iAN); + test("nullnull", "" + f_oN + s_oN); + test("null\u045180", "" + f_oN + s_strU); + test("nullC", "" + f_oN + sf_c); + test("null75", "" + f_oN + sf_str); + test("null-43", "" + f_oN + s_bM); + test("null80", "" + f_oN + sf_b); + test("nullnull", "" + f_oN + s_IN); + test("null-52.0", "" + f_oN + s_fM); + test("null75000000", "" + f_oN + sf_i); + test("null44", "" + f_oN + f_b); + test("null-1705032704", "" + f_oN + sf_lM); + test("nullnull", "" + f_oN + f_oAN); + test("null83.0", "" + f_oN + f_d); + test("nullI", "" + f_oN + f_c); + test("null94.0", "" + f_oN + f_f); + test("null12.0", "" + f_oN + sf_d); + test("null-99.0", "" + f_oN + f_dM); + test("null17.0", "" + f_oN + sf_f); + test("null-84.0", "" + f_oN + sf_dM); + test("null58000000", "" + f_oN + f_i); + test("null-55000000", "" + f_oN + f_iM); + test("null1460392448", "" + f_oN + f_l); + test("nullC(70)", "" + f_oN + f_o); + test("null\u04511", "" + f_oN + sf_strU); + test("null8000", "" + f_oN + f_s); + test("null18", "" + f_oN + s_str); + test("null-1000000", "" + f_oN + s_iM); + test("null1000000", "" + f_oN + sf_I); + test("nullnull", "" + f_oN + f_oNtS); + test("nullfalse", "" + f_oN + f_bl); + test("nullnull", "" + f_oN + sf_iAN); + test("null-2000000", "" + f_oN + sf_iM); + test("null-820130816", "" + f_oN + f_lM); + test("nullnull", "" + f_oN + sf_oAN); + test("null25000000", "" + f_oN + s_I); + test("-1410065408-96.0", "" + s_lM + s_dM); + test("-1410065408null", "" + s_lM + s_oNtS); + test("-1410065408\u045176", "" + s_lM + f_strU); + test("-141006540892", "" + s_lM + sf_strU2); + test("-141006540851", "" + s_lM + sf_strU1); + test("-1410065408null", "" + s_lM + s_iAN); + test("-1410065408-54", "" + s_lM + f_bM); + test("-1410065408-87.0", "" + s_lM + f_fM); + test("-1410065408null", "" + s_lM + s_oAN); + test("-141006540819", "" + s_lM + f_str); + test("-1410065408-41", "" + s_lM + sf_bM); + test("-1410065408null", "" + s_lM + sf_IN); + test("-1410065408T", "" + s_lM + s_c); + test("-1410065408-42.0", "" + s_lM + sf_fM); + test("-141006540825", "" + s_lM + s_b); + test("-1410065408null", "" + s_lM + f_oN); + test("-1410065408-1410065408", "" + s_lM + s_lM); + test("-14100654088.0", "" + s_lM + s_d); + test("-141006540855.0", "" + s_lM + s_f); + test("-141006540897000000", "" + s_lM + s_i); + test("-1410065408-9900", "" + s_lM + f_sM); + test("-1410065408935228928", "" + s_lM + s_l); + test("-1410065408-8400", "" + s_lM + sf_sM); + test("-1410065408C(82)", "" + s_lM + s_o); + test("-1410065408null", "" + s_lM + sf_oNtS); + test("-1410065408true", "" + s_lM + s_bl); + test("-14100654083900", "" + s_lM + s_s); + test("-1410065408null", "" + s_lM + sf_oN); + test("-141006540894000000", "" + s_lM + f_I); + test("-1410065408null", "" + s_lM + f_IN); + test("-1410065408true", "" + s_lM + sf_bl); + test("-14100654085500", "" + s_lM + sf_s); + test("-1410065408-2900", "" + s_lM + s_sM); + test("-1410065408-194313216", "" + s_lM + sf_l); + test("-141006540812", "" + s_lM + s_strU1); + test("-1410065408C(87)", "" + s_lM + sf_o); + test("-141006540891", "" + s_lM + s_strU2); + test("-141006540821", "" + s_lM + f_strU1); + test("-141006540818", "" + s_lM + f_strU2); + test("-1410065408null", "" + s_lM + f_iAN); + test("-1410065408null", "" + s_lM + s_oN); + test("-1410065408\u045180", "" + s_lM + s_strU); + test("-1410065408C", "" + s_lM + sf_c); + test("-141006540875", "" + s_lM + sf_str); + test("-1410065408-43", "" + s_lM + s_bM); + test("-141006540880", "" + s_lM + sf_b); + test("-1410065408null", "" + s_lM + s_IN); + test("-1410065408-52.0", "" + s_lM + s_fM); + test("-141006540875000000", "" + s_lM + sf_i); + test("-141006540844", "" + s_lM + f_b); + test("-1410065408-1705032704", "" + s_lM + sf_lM); + test("-1410065408null", "" + s_lM + f_oAN); + test("-141006540883.0", "" + s_lM + f_d); + test("-1410065408I", "" + s_lM + f_c); + test("-141006540894.0", "" + s_lM + f_f); + test("-141006540812.0", "" + s_lM + sf_d); + test("-1410065408-99.0", "" + s_lM + f_dM); + test("-141006540817.0", "" + s_lM + sf_f); + test("-1410065408-84.0", "" + s_lM + sf_dM); + test("-141006540858000000", "" + s_lM + f_i); + test("-1410065408-55000000", "" + s_lM + f_iM); + test("-14100654081460392448", "" + s_lM + f_l); + test("-1410065408C(70)", "" + s_lM + f_o); + test("-1410065408\u04511", "" + s_lM + sf_strU); + test("-14100654088000", "" + s_lM + f_s); + test("-141006540818", "" + s_lM + s_str); + test("-1410065408-1000000", "" + s_lM + s_iM); + test("-14100654081000000", "" + s_lM + sf_I); + test("-1410065408null", "" + s_lM + f_oNtS); + test("-1410065408false", "" + s_lM + f_bl); + test("-1410065408null", "" + s_lM + sf_iAN); + test("-1410065408-2000000", "" + s_lM + sf_iM); + test("-1410065408-820130816", "" + s_lM + f_lM); + test("-1410065408null", "" + s_lM + sf_oAN); + test("-141006540825000000", "" + s_lM + s_I); + test("8.0-96.0", "" + s_d + s_dM); + test("8.0null", "" + s_d + s_oNtS); + test("8.0\u045176", "" + s_d + f_strU); + test("8.092", "" + s_d + sf_strU2); + test("8.051", "" + s_d + sf_strU1); + test("8.0null", "" + s_d + s_iAN); + test("8.0-54", "" + s_d + f_bM); + test("8.0-87.0", "" + s_d + f_fM); + test("8.0null", "" + s_d + s_oAN); + test("8.019", "" + s_d + f_str); + test("8.0-41", "" + s_d + sf_bM); + test("8.0null", "" + s_d + sf_IN); + test("8.0T", "" + s_d + s_c); + test("8.0-42.0", "" + s_d + sf_fM); + test("8.025", "" + s_d + s_b); + test("8.0null", "" + s_d + f_oN); + test("8.0-1410065408", "" + s_d + s_lM); + test("8.08.0", "" + s_d + s_d); + test("8.055.0", "" + s_d + s_f); + test("8.097000000", "" + s_d + s_i); + test("8.0-9900", "" + s_d + f_sM); + test("8.0935228928", "" + s_d + s_l); + test("8.0-8400", "" + s_d + sf_sM); + test("8.0C(82)", "" + s_d + s_o); + test("8.0null", "" + s_d + sf_oNtS); + test("8.0true", "" + s_d + s_bl); + test("8.03900", "" + s_d + s_s); + test("8.0null", "" + s_d + sf_oN); + test("8.094000000", "" + s_d + f_I); + test("8.0null", "" + s_d + f_IN); + test("8.0true", "" + s_d + sf_bl); + test("8.05500", "" + s_d + sf_s); + test("8.0-2900", "" + s_d + s_sM); + test("8.0-194313216", "" + s_d + sf_l); + test("8.012", "" + s_d + s_strU1); + test("8.0C(87)", "" + s_d + sf_o); + test("8.091", "" + s_d + s_strU2); + test("8.021", "" + s_d + f_strU1); + test("8.018", "" + s_d + f_strU2); + test("8.0null", "" + s_d + f_iAN); + test("8.0null", "" + s_d + s_oN); + test("8.0\u045180", "" + s_d + s_strU); + test("8.0C", "" + s_d + sf_c); + test("8.075", "" + s_d + sf_str); + test("8.0-43", "" + s_d + s_bM); + test("8.080", "" + s_d + sf_b); + test("8.0null", "" + s_d + s_IN); + test("8.0-52.0", "" + s_d + s_fM); + test("8.075000000", "" + s_d + sf_i); + test("8.044", "" + s_d + f_b); + test("8.0-1705032704", "" + s_d + sf_lM); + test("8.0null", "" + s_d + f_oAN); + test("8.083.0", "" + s_d + f_d); + test("8.0I", "" + s_d + f_c); + test("8.094.0", "" + s_d + f_f); + test("8.012.0", "" + s_d + sf_d); + test("8.0-99.0", "" + s_d + f_dM); + test("8.017.0", "" + s_d + sf_f); + test("8.0-84.0", "" + s_d + sf_dM); + test("8.058000000", "" + s_d + f_i); + test("8.0-55000000", "" + s_d + f_iM); + test("8.01460392448", "" + s_d + f_l); + test("8.0C(70)", "" + s_d + f_o); + test("8.0\u04511", "" + s_d + sf_strU); + test("8.08000", "" + s_d + f_s); + test("8.018", "" + s_d + s_str); + test("8.0-1000000", "" + s_d + s_iM); + test("8.01000000", "" + s_d + sf_I); + test("8.0null", "" + s_d + f_oNtS); + test("8.0false", "" + s_d + f_bl); + test("8.0null", "" + s_d + sf_iAN); + test("8.0-2000000", "" + s_d + sf_iM); + test("8.0-820130816", "" + s_d + f_lM); + test("8.0null", "" + s_d + sf_oAN); + test("8.025000000", "" + s_d + s_I); + test("55.0-96.0", "" + s_f + s_dM); + test("55.0null", "" + s_f + s_oNtS); + test("55.0\u045176", "" + s_f + f_strU); + test("55.092", "" + s_f + sf_strU2); + test("55.051", "" + s_f + sf_strU1); + test("55.0null", "" + s_f + s_iAN); + test("55.0-54", "" + s_f + f_bM); + test("55.0-87.0", "" + s_f + f_fM); + test("55.0null", "" + s_f + s_oAN); + test("55.019", "" + s_f + f_str); + test("55.0-41", "" + s_f + sf_bM); + test("55.0null", "" + s_f + sf_IN); + test("55.0T", "" + s_f + s_c); + test("55.0-42.0", "" + s_f + sf_fM); + test("55.025", "" + s_f + s_b); + test("55.0null", "" + s_f + f_oN); + test("55.0-1410065408", "" + s_f + s_lM); + test("55.08.0", "" + s_f + s_d); + test("55.055.0", "" + s_f + s_f); + test("55.097000000", "" + s_f + s_i); + test("55.0-9900", "" + s_f + f_sM); + test("55.0935228928", "" + s_f + s_l); + test("55.0-8400", "" + s_f + sf_sM); + test("55.0C(82)", "" + s_f + s_o); + test("55.0null", "" + s_f + sf_oNtS); + test("55.0true", "" + s_f + s_bl); + test("55.03900", "" + s_f + s_s); + test("55.0null", "" + s_f + sf_oN); + test("55.094000000", "" + s_f + f_I); + test("55.0null", "" + s_f + f_IN); + test("55.0true", "" + s_f + sf_bl); + test("55.05500", "" + s_f + sf_s); + test("55.0-2900", "" + s_f + s_sM); + test("55.0-194313216", "" + s_f + sf_l); + test("55.012", "" + s_f + s_strU1); + test("55.0C(87)", "" + s_f + sf_o); + test("55.091", "" + s_f + s_strU2); + test("55.021", "" + s_f + f_strU1); + test("55.018", "" + s_f + f_strU2); + test("55.0null", "" + s_f + f_iAN); + test("55.0null", "" + s_f + s_oN); + test("55.0\u045180", "" + s_f + s_strU); + test("55.0C", "" + s_f + sf_c); + test("55.075", "" + s_f + sf_str); + test("55.0-43", "" + s_f + s_bM); + test("55.080", "" + s_f + sf_b); + test("55.0null", "" + s_f + s_IN); + test("55.0-52.0", "" + s_f + s_fM); + test("55.075000000", "" + s_f + sf_i); + test("55.044", "" + s_f + f_b); + test("55.0-1705032704", "" + s_f + sf_lM); + test("55.0null", "" + s_f + f_oAN); + test("55.083.0", "" + s_f + f_d); + test("55.0I", "" + s_f + f_c); + test("55.094.0", "" + s_f + f_f); + test("55.012.0", "" + s_f + sf_d); + test("55.0-99.0", "" + s_f + f_dM); + test("55.017.0", "" + s_f + sf_f); + test("55.0-84.0", "" + s_f + sf_dM); + test("55.058000000", "" + s_f + f_i); + test("55.0-55000000", "" + s_f + f_iM); + test("55.01460392448", "" + s_f + f_l); + test("55.0C(70)", "" + s_f + f_o); + test("55.0\u04511", "" + s_f + sf_strU); + test("55.08000", "" + s_f + f_s); + test("55.018", "" + s_f + s_str); + test("55.0-1000000", "" + s_f + s_iM); + test("55.01000000", "" + s_f + sf_I); + test("55.0null", "" + s_f + f_oNtS); + test("55.0false", "" + s_f + f_bl); + test("55.0null", "" + s_f + sf_iAN); + test("55.0-2000000", "" + s_f + sf_iM); + test("55.0-820130816", "" + s_f + f_lM); + test("55.0null", "" + s_f + sf_oAN); + test("55.025000000", "" + s_f + s_I); + test("97000000-96.0", "" + s_i + s_dM); + test("97000000null", "" + s_i + s_oNtS); + test("97000000\u045176", "" + s_i + f_strU); + test("9700000092", "" + s_i + sf_strU2); + test("9700000051", "" + s_i + sf_strU1); + test("97000000null", "" + s_i + s_iAN); + test("97000000-54", "" + s_i + f_bM); + test("97000000-87.0", "" + s_i + f_fM); + test("97000000null", "" + s_i + s_oAN); + test("9700000019", "" + s_i + f_str); + test("97000000-41", "" + s_i + sf_bM); + test("97000000null", "" + s_i + sf_IN); + test("97000000T", "" + s_i + s_c); + test("97000000-42.0", "" + s_i + sf_fM); + test("9700000025", "" + s_i + s_b); + test("97000000null", "" + s_i + f_oN); + test("97000000-1410065408", "" + s_i + s_lM); + test("970000008.0", "" + s_i + s_d); + test("9700000055.0", "" + s_i + s_f); + test("9700000097000000", "" + s_i + s_i); + test("97000000-9900", "" + s_i + f_sM); + test("97000000935228928", "" + s_i + s_l); + test("97000000-8400", "" + s_i + sf_sM); + test("97000000C(82)", "" + s_i + s_o); + test("97000000null", "" + s_i + sf_oNtS); + test("97000000true", "" + s_i + s_bl); + test("970000003900", "" + s_i + s_s); + test("97000000null", "" + s_i + sf_oN); + test("9700000094000000", "" + s_i + f_I); + test("97000000null", "" + s_i + f_IN); + test("97000000true", "" + s_i + sf_bl); + test("970000005500", "" + s_i + sf_s); + test("97000000-2900", "" + s_i + s_sM); + test("97000000-194313216", "" + s_i + sf_l); + test("9700000012", "" + s_i + s_strU1); + test("97000000C(87)", "" + s_i + sf_o); + test("9700000091", "" + s_i + s_strU2); + test("9700000021", "" + s_i + f_strU1); + test("9700000018", "" + s_i + f_strU2); + test("97000000null", "" + s_i + f_iAN); + test("97000000null", "" + s_i + s_oN); + test("97000000\u045180", "" + s_i + s_strU); + test("97000000C", "" + s_i + sf_c); + test("9700000075", "" + s_i + sf_str); + test("97000000-43", "" + s_i + s_bM); + test("9700000080", "" + s_i + sf_b); + test("97000000null", "" + s_i + s_IN); + test("97000000-52.0", "" + s_i + s_fM); + test("9700000075000000", "" + s_i + sf_i); + test("9700000044", "" + s_i + f_b); + test("97000000-1705032704", "" + s_i + sf_lM); + test("97000000null", "" + s_i + f_oAN); + test("9700000083.0", "" + s_i + f_d); + test("97000000I", "" + s_i + f_c); + test("9700000094.0", "" + s_i + f_f); + test("9700000012.0", "" + s_i + sf_d); + test("97000000-99.0", "" + s_i + f_dM); + test("9700000017.0", "" + s_i + sf_f); + test("97000000-84.0", "" + s_i + sf_dM); + test("9700000058000000", "" + s_i + f_i); + test("97000000-55000000", "" + s_i + f_iM); + test("970000001460392448", "" + s_i + f_l); + test("97000000C(70)", "" + s_i + f_o); + test("97000000\u04511", "" + s_i + sf_strU); + test("970000008000", "" + s_i + f_s); + test("9700000018", "" + s_i + s_str); + test("97000000-1000000", "" + s_i + s_iM); + test("970000001000000", "" + s_i + sf_I); + test("97000000null", "" + s_i + f_oNtS); + test("97000000false", "" + s_i + f_bl); + test("97000000null", "" + s_i + sf_iAN); + test("97000000-2000000", "" + s_i + sf_iM); + test("97000000-820130816", "" + s_i + f_lM); + test("97000000null", "" + s_i + sf_oAN); + test("9700000025000000", "" + s_i + s_I); + test("-9900-96.0", "" + f_sM + s_dM); + test("-9900null", "" + f_sM + s_oNtS); + test("-9900\u045176", "" + f_sM + f_strU); + test("-990092", "" + f_sM + sf_strU2); + test("-990051", "" + f_sM + sf_strU1); + test("-9900null", "" + f_sM + s_iAN); + test("-9900-54", "" + f_sM + f_bM); + test("-9900-87.0", "" + f_sM + f_fM); + test("-9900null", "" + f_sM + s_oAN); + test("-990019", "" + f_sM + f_str); + test("-9900-41", "" + f_sM + sf_bM); + test("-9900null", "" + f_sM + sf_IN); + test("-9900T", "" + f_sM + s_c); + test("-9900-42.0", "" + f_sM + sf_fM); + test("-990025", "" + f_sM + s_b); + test("-9900null", "" + f_sM + f_oN); + test("-9900-1410065408", "" + f_sM + s_lM); + test("-99008.0", "" + f_sM + s_d); + test("-990055.0", "" + f_sM + s_f); + test("-990097000000", "" + f_sM + s_i); + test("-9900-9900", "" + f_sM + f_sM); + test("-9900935228928", "" + f_sM + s_l); + test("-9900-8400", "" + f_sM + sf_sM); + test("-9900C(82)", "" + f_sM + s_o); + test("-9900null", "" + f_sM + sf_oNtS); + test("-9900true", "" + f_sM + s_bl); + test("-99003900", "" + f_sM + s_s); + test("-9900null", "" + f_sM + sf_oN); + test("-990094000000", "" + f_sM + f_I); + test("-9900null", "" + f_sM + f_IN); + test("-9900true", "" + f_sM + sf_bl); + test("-99005500", "" + f_sM + sf_s); + test("-9900-2900", "" + f_sM + s_sM); + test("-9900-194313216", "" + f_sM + sf_l); + test("-990012", "" + f_sM + s_strU1); + test("-9900C(87)", "" + f_sM + sf_o); + test("-990091", "" + f_sM + s_strU2); + test("-990021", "" + f_sM + f_strU1); + test("-990018", "" + f_sM + f_strU2); + test("-9900null", "" + f_sM + f_iAN); + test("-9900null", "" + f_sM + s_oN); + test("-9900\u045180", "" + f_sM + s_strU); + test("-9900C", "" + f_sM + sf_c); + test("-990075", "" + f_sM + sf_str); + test("-9900-43", "" + f_sM + s_bM); + test("-990080", "" + f_sM + sf_b); + test("-9900null", "" + f_sM + s_IN); + test("-9900-52.0", "" + f_sM + s_fM); + test("-990075000000", "" + f_sM + sf_i); + test("-990044", "" + f_sM + f_b); + test("-9900-1705032704", "" + f_sM + sf_lM); + test("-9900null", "" + f_sM + f_oAN); + test("-990083.0", "" + f_sM + f_d); + test("-9900I", "" + f_sM + f_c); + test("-990094.0", "" + f_sM + f_f); + test("-990012.0", "" + f_sM + sf_d); + test("-9900-99.0", "" + f_sM + f_dM); + test("-990017.0", "" + f_sM + sf_f); + test("-9900-84.0", "" + f_sM + sf_dM); + test("-990058000000", "" + f_sM + f_i); + test("-9900-55000000", "" + f_sM + f_iM); + test("-99001460392448", "" + f_sM + f_l); + test("-9900C(70)", "" + f_sM + f_o); + test("-9900\u04511", "" + f_sM + sf_strU); + test("-99008000", "" + f_sM + f_s); + test("-990018", "" + f_sM + s_str); + test("-9900-1000000", "" + f_sM + s_iM); + test("-99001000000", "" + f_sM + sf_I); + test("-9900null", "" + f_sM + f_oNtS); + test("-9900false", "" + f_sM + f_bl); + test("-9900null", "" + f_sM + sf_iAN); + test("-9900-2000000", "" + f_sM + sf_iM); + test("-9900-820130816", "" + f_sM + f_lM); + test("-9900null", "" + f_sM + sf_oAN); + test("-990025000000", "" + f_sM + s_I); + test("935228928-96.0", "" + s_l + s_dM); + test("935228928null", "" + s_l + s_oNtS); + test("935228928\u045176", "" + s_l + f_strU); + test("93522892892", "" + s_l + sf_strU2); + test("93522892851", "" + s_l + sf_strU1); + test("935228928null", "" + s_l + s_iAN); + test("935228928-54", "" + s_l + f_bM); + test("935228928-87.0", "" + s_l + f_fM); + test("935228928null", "" + s_l + s_oAN); + test("93522892819", "" + s_l + f_str); + test("935228928-41", "" + s_l + sf_bM); + test("935228928null", "" + s_l + sf_IN); + test("935228928T", "" + s_l + s_c); + test("935228928-42.0", "" + s_l + sf_fM); + test("93522892825", "" + s_l + s_b); + test("935228928null", "" + s_l + f_oN); + test("935228928-1410065408", "" + s_l + s_lM); + test("9352289288.0", "" + s_l + s_d); + test("93522892855.0", "" + s_l + s_f); + test("93522892897000000", "" + s_l + s_i); + test("935228928-9900", "" + s_l + f_sM); + test("935228928935228928", "" + s_l + s_l); + test("935228928-8400", "" + s_l + sf_sM); + test("935228928C(82)", "" + s_l + s_o); + test("935228928null", "" + s_l + sf_oNtS); + test("935228928true", "" + s_l + s_bl); + test("9352289283900", "" + s_l + s_s); + test("935228928null", "" + s_l + sf_oN); + test("93522892894000000", "" + s_l + f_I); + test("935228928null", "" + s_l + f_IN); + test("935228928true", "" + s_l + sf_bl); + test("9352289285500", "" + s_l + sf_s); + test("935228928-2900", "" + s_l + s_sM); + test("935228928-194313216", "" + s_l + sf_l); + test("93522892812", "" + s_l + s_strU1); + test("935228928C(87)", "" + s_l + sf_o); + test("93522892891", "" + s_l + s_strU2); + test("93522892821", "" + s_l + f_strU1); + test("93522892818", "" + s_l + f_strU2); + test("935228928null", "" + s_l + f_iAN); + test("935228928null", "" + s_l + s_oN); + test("935228928\u045180", "" + s_l + s_strU); + test("935228928C", "" + s_l + sf_c); + test("93522892875", "" + s_l + sf_str); + test("935228928-43", "" + s_l + s_bM); + test("93522892880", "" + s_l + sf_b); + test("935228928null", "" + s_l + s_IN); + test("935228928-52.0", "" + s_l + s_fM); + test("93522892875000000", "" + s_l + sf_i); + test("93522892844", "" + s_l + f_b); + test("935228928-1705032704", "" + s_l + sf_lM); + test("935228928null", "" + s_l + f_oAN); + test("93522892883.0", "" + s_l + f_d); + test("935228928I", "" + s_l + f_c); + test("93522892894.0", "" + s_l + f_f); + test("93522892812.0", "" + s_l + sf_d); + test("935228928-99.0", "" + s_l + f_dM); + test("93522892817.0", "" + s_l + sf_f); + test("935228928-84.0", "" + s_l + sf_dM); + test("93522892858000000", "" + s_l + f_i); + test("935228928-55000000", "" + s_l + f_iM); + test("9352289281460392448", "" + s_l + f_l); + test("935228928C(70)", "" + s_l + f_o); + test("935228928\u04511", "" + s_l + sf_strU); + test("9352289288000", "" + s_l + f_s); + test("93522892818", "" + s_l + s_str); + test("935228928-1000000", "" + s_l + s_iM); + test("9352289281000000", "" + s_l + sf_I); + test("935228928null", "" + s_l + f_oNtS); + test("935228928false", "" + s_l + f_bl); + test("935228928null", "" + s_l + sf_iAN); + test("935228928-2000000", "" + s_l + sf_iM); + test("935228928-820130816", "" + s_l + f_lM); + test("935228928null", "" + s_l + sf_oAN); + test("93522892825000000", "" + s_l + s_I); + test("-8400-96.0", "" + sf_sM + s_dM); + test("-8400null", "" + sf_sM + s_oNtS); + test("-8400\u045176", "" + sf_sM + f_strU); + test("-840092", "" + sf_sM + sf_strU2); + test("-840051", "" + sf_sM + sf_strU1); + test("-8400null", "" + sf_sM + s_iAN); + test("-8400-54", "" + sf_sM + f_bM); + test("-8400-87.0", "" + sf_sM + f_fM); + test("-8400null", "" + sf_sM + s_oAN); + test("-840019", "" + sf_sM + f_str); + test("-8400-41", "" + sf_sM + sf_bM); + test("-8400null", "" + sf_sM + sf_IN); + test("-8400T", "" + sf_sM + s_c); + test("-8400-42.0", "" + sf_sM + sf_fM); + test("-840025", "" + sf_sM + s_b); + test("-8400null", "" + sf_sM + f_oN); + test("-8400-1410065408", "" + sf_sM + s_lM); + test("-84008.0", "" + sf_sM + s_d); + test("-840055.0", "" + sf_sM + s_f); + test("-840097000000", "" + sf_sM + s_i); + test("-8400-9900", "" + sf_sM + f_sM); + test("-8400935228928", "" + sf_sM + s_l); + test("-8400-8400", "" + sf_sM + sf_sM); + test("-8400C(82)", "" + sf_sM + s_o); + test("-8400null", "" + sf_sM + sf_oNtS); + test("-8400true", "" + sf_sM + s_bl); + test("-84003900", "" + sf_sM + s_s); + test("-8400null", "" + sf_sM + sf_oN); + test("-840094000000", "" + sf_sM + f_I); + test("-8400null", "" + sf_sM + f_IN); + test("-8400true", "" + sf_sM + sf_bl); + test("-84005500", "" + sf_sM + sf_s); + test("-8400-2900", "" + sf_sM + s_sM); + test("-8400-194313216", "" + sf_sM + sf_l); + test("-840012", "" + sf_sM + s_strU1); + test("-8400C(87)", "" + sf_sM + sf_o); + test("-840091", "" + sf_sM + s_strU2); + test("-840021", "" + sf_sM + f_strU1); + test("-840018", "" + sf_sM + f_strU2); + test("-8400null", "" + sf_sM + f_iAN); + test("-8400null", "" + sf_sM + s_oN); + test("-8400\u045180", "" + sf_sM + s_strU); + test("-8400C", "" + sf_sM + sf_c); + test("-840075", "" + sf_sM + sf_str); + test("-8400-43", "" + sf_sM + s_bM); + test("-840080", "" + sf_sM + sf_b); + test("-8400null", "" + sf_sM + s_IN); + test("-8400-52.0", "" + sf_sM + s_fM); + test("-840075000000", "" + sf_sM + sf_i); + test("-840044", "" + sf_sM + f_b); + test("-8400-1705032704", "" + sf_sM + sf_lM); + test("-8400null", "" + sf_sM + f_oAN); + test("-840083.0", "" + sf_sM + f_d); + test("-8400I", "" + sf_sM + f_c); + test("-840094.0", "" + sf_sM + f_f); + test("-840012.0", "" + sf_sM + sf_d); + test("-8400-99.0", "" + sf_sM + f_dM); + test("-840017.0", "" + sf_sM + sf_f); + test("-8400-84.0", "" + sf_sM + sf_dM); + test("-840058000000", "" + sf_sM + f_i); + test("-8400-55000000", "" + sf_sM + f_iM); + test("-84001460392448", "" + sf_sM + f_l); + test("-8400C(70)", "" + sf_sM + f_o); + test("-8400\u04511", "" + sf_sM + sf_strU); + test("-84008000", "" + sf_sM + f_s); + test("-840018", "" + sf_sM + s_str); + test("-8400-1000000", "" + sf_sM + s_iM); + test("-84001000000", "" + sf_sM + sf_I); + test("-8400null", "" + sf_sM + f_oNtS); + test("-8400false", "" + sf_sM + f_bl); + test("-8400null", "" + sf_sM + sf_iAN); + test("-8400-2000000", "" + sf_sM + sf_iM); + test("-8400-820130816", "" + sf_sM + f_lM); + test("-8400null", "" + sf_sM + sf_oAN); + test("-840025000000", "" + sf_sM + s_I); + test("C(82)-96.0", "" + s_o + s_dM); + test("C(82)null", "" + s_o + s_oNtS); + test("C(82)\u045176", "" + s_o + f_strU); + test("C(82)92", "" + s_o + sf_strU2); + test("C(82)51", "" + s_o + sf_strU1); + test("C(82)null", "" + s_o + s_iAN); + test("C(82)-54", "" + s_o + f_bM); + test("C(82)-87.0", "" + s_o + f_fM); + test("C(82)null", "" + s_o + s_oAN); + test("C(82)19", "" + s_o + f_str); + test("C(82)-41", "" + s_o + sf_bM); + test("C(82)null", "" + s_o + sf_IN); + test("C(82)T", "" + s_o + s_c); + test("C(82)-42.0", "" + s_o + sf_fM); + test("C(82)25", "" + s_o + s_b); + test("C(82)null", "" + s_o + f_oN); + test("C(82)-1410065408", "" + s_o + s_lM); + test("C(82)8.0", "" + s_o + s_d); + test("C(82)55.0", "" + s_o + s_f); + test("C(82)97000000", "" + s_o + s_i); + test("C(82)-9900", "" + s_o + f_sM); + test("C(82)935228928", "" + s_o + s_l); + test("C(82)-8400", "" + s_o + sf_sM); + test("C(82)C(82)", "" + s_o + s_o); + test("C(82)null", "" + s_o + sf_oNtS); + test("C(82)true", "" + s_o + s_bl); + test("C(82)3900", "" + s_o + s_s); + test("C(82)null", "" + s_o + sf_oN); + test("C(82)94000000", "" + s_o + f_I); + test("C(82)null", "" + s_o + f_IN); + test("C(82)true", "" + s_o + sf_bl); + test("C(82)5500", "" + s_o + sf_s); + test("C(82)-2900", "" + s_o + s_sM); + test("C(82)-194313216", "" + s_o + sf_l); + test("C(82)12", "" + s_o + s_strU1); + test("C(82)C(87)", "" + s_o + sf_o); + test("C(82)91", "" + s_o + s_strU2); + test("C(82)21", "" + s_o + f_strU1); + test("C(82)18", "" + s_o + f_strU2); + test("C(82)null", "" + s_o + f_iAN); + test("C(82)null", "" + s_o + s_oN); + test("C(82)\u045180", "" + s_o + s_strU); + test("C(82)C", "" + s_o + sf_c); + test("C(82)75", "" + s_o + sf_str); + test("C(82)-43", "" + s_o + s_bM); + test("C(82)80", "" + s_o + sf_b); + test("C(82)null", "" + s_o + s_IN); + test("C(82)-52.0", "" + s_o + s_fM); + test("C(82)75000000", "" + s_o + sf_i); + test("C(82)44", "" + s_o + f_b); + test("C(82)-1705032704", "" + s_o + sf_lM); + test("C(82)null", "" + s_o + f_oAN); + test("C(82)83.0", "" + s_o + f_d); + test("C(82)I", "" + s_o + f_c); + test("C(82)94.0", "" + s_o + f_f); + test("C(82)12.0", "" + s_o + sf_d); + test("C(82)-99.0", "" + s_o + f_dM); + test("C(82)17.0", "" + s_o + sf_f); + test("C(82)-84.0", "" + s_o + sf_dM); + test("C(82)58000000", "" + s_o + f_i); + test("C(82)-55000000", "" + s_o + f_iM); + test("C(82)1460392448", "" + s_o + f_l); + test("C(82)C(70)", "" + s_o + f_o); + test("C(82)\u04511", "" + s_o + sf_strU); + test("C(82)8000", "" + s_o + f_s); + test("C(82)18", "" + s_o + s_str); + test("C(82)-1000000", "" + s_o + s_iM); + test("C(82)1000000", "" + s_o + sf_I); + test("C(82)null", "" + s_o + f_oNtS); + test("C(82)false", "" + s_o + f_bl); + test("C(82)null", "" + s_o + sf_iAN); + test("C(82)-2000000", "" + s_o + sf_iM); + test("C(82)-820130816", "" + s_o + f_lM); + test("C(82)null", "" + s_o + sf_oAN); + test("C(82)25000000", "" + s_o + s_I); + test("null-96.0", "" + sf_oNtS + s_dM); + test("nullnull", "" + sf_oNtS + s_oNtS); + test("null\u045176", "" + sf_oNtS + f_strU); + test("null92", "" + sf_oNtS + sf_strU2); + test("null51", "" + sf_oNtS + sf_strU1); + test("nullnull", "" + sf_oNtS + s_iAN); + test("null-54", "" + sf_oNtS + f_bM); + test("null-87.0", "" + sf_oNtS + f_fM); + test("nullnull", "" + sf_oNtS + s_oAN); + test("null19", "" + sf_oNtS + f_str); + test("null-41", "" + sf_oNtS + sf_bM); + test("nullnull", "" + sf_oNtS + sf_IN); + test("nullT", "" + sf_oNtS + s_c); + test("null-42.0", "" + sf_oNtS + sf_fM); + test("null25", "" + sf_oNtS + s_b); + test("nullnull", "" + sf_oNtS + f_oN); + test("null-1410065408", "" + sf_oNtS + s_lM); + test("null8.0", "" + sf_oNtS + s_d); + test("null55.0", "" + sf_oNtS + s_f); + test("null97000000", "" + sf_oNtS + s_i); + test("null-9900", "" + sf_oNtS + f_sM); + test("null935228928", "" + sf_oNtS + s_l); + test("null-8400", "" + sf_oNtS + sf_sM); + test("nullC(82)", "" + sf_oNtS + s_o); + test("nullnull", "" + sf_oNtS + sf_oNtS); + test("nulltrue", "" + sf_oNtS + s_bl); + test("null3900", "" + sf_oNtS + s_s); + test("nullnull", "" + sf_oNtS + sf_oN); + test("null94000000", "" + sf_oNtS + f_I); + test("nullnull", "" + sf_oNtS + f_IN); + test("nulltrue", "" + sf_oNtS + sf_bl); + test("null5500", "" + sf_oNtS + sf_s); + test("null-2900", "" + sf_oNtS + s_sM); + test("null-194313216", "" + sf_oNtS + sf_l); + test("null12", "" + sf_oNtS + s_strU1); + test("nullC(87)", "" + sf_oNtS + sf_o); + test("null91", "" + sf_oNtS + s_strU2); + test("null21", "" + sf_oNtS + f_strU1); + test("null18", "" + sf_oNtS + f_strU2); + test("nullnull", "" + sf_oNtS + f_iAN); + test("nullnull", "" + sf_oNtS + s_oN); + test("null\u045180", "" + sf_oNtS + s_strU); + test("nullC", "" + sf_oNtS + sf_c); + test("null75", "" + sf_oNtS + sf_str); + test("null-43", "" + sf_oNtS + s_bM); + test("null80", "" + sf_oNtS + sf_b); + test("nullnull", "" + sf_oNtS + s_IN); + test("null-52.0", "" + sf_oNtS + s_fM); + test("null75000000", "" + sf_oNtS + sf_i); + test("null44", "" + sf_oNtS + f_b); + test("null-1705032704", "" + sf_oNtS + sf_lM); + test("nullnull", "" + sf_oNtS + f_oAN); + test("null83.0", "" + sf_oNtS + f_d); + test("nullI", "" + sf_oNtS + f_c); + test("null94.0", "" + sf_oNtS + f_f); + test("null12.0", "" + sf_oNtS + sf_d); + test("null-99.0", "" + sf_oNtS + f_dM); + test("null17.0", "" + sf_oNtS + sf_f); + test("null-84.0", "" + sf_oNtS + sf_dM); + test("null58000000", "" + sf_oNtS + f_i); + test("null-55000000", "" + sf_oNtS + f_iM); + test("null1460392448", "" + sf_oNtS + f_l); + test("nullC(70)", "" + sf_oNtS + f_o); + test("null\u04511", "" + sf_oNtS + sf_strU); + test("null8000", "" + sf_oNtS + f_s); + test("null18", "" + sf_oNtS + s_str); + test("null-1000000", "" + sf_oNtS + s_iM); + test("null1000000", "" + sf_oNtS + sf_I); + test("nullnull", "" + sf_oNtS + f_oNtS); + test("nullfalse", "" + sf_oNtS + f_bl); + test("nullnull", "" + sf_oNtS + sf_iAN); + test("null-2000000", "" + sf_oNtS + sf_iM); + test("null-820130816", "" + sf_oNtS + f_lM); + test("nullnull", "" + sf_oNtS + sf_oAN); + test("null25000000", "" + sf_oNtS + s_I); + test("true-96.0", "" + s_bl + s_dM); + test("truenull", "" + s_bl + s_oNtS); + test("true\u045176", "" + s_bl + f_strU); + test("true92", "" + s_bl + sf_strU2); + test("true51", "" + s_bl + sf_strU1); + test("truenull", "" + s_bl + s_iAN); + test("true-54", "" + s_bl + f_bM); + test("true-87.0", "" + s_bl + f_fM); + test("truenull", "" + s_bl + s_oAN); + test("true19", "" + s_bl + f_str); + test("true-41", "" + s_bl + sf_bM); + test("truenull", "" + s_bl + sf_IN); + test("trueT", "" + s_bl + s_c); + test("true-42.0", "" + s_bl + sf_fM); + test("true25", "" + s_bl + s_b); + test("truenull", "" + s_bl + f_oN); + test("true-1410065408", "" + s_bl + s_lM); + test("true8.0", "" + s_bl + s_d); + test("true55.0", "" + s_bl + s_f); + test("true97000000", "" + s_bl + s_i); + test("true-9900", "" + s_bl + f_sM); + test("true935228928", "" + s_bl + s_l); + test("true-8400", "" + s_bl + sf_sM); + test("trueC(82)", "" + s_bl + s_o); + test("truenull", "" + s_bl + sf_oNtS); + test("truetrue", "" + s_bl + s_bl); + test("true3900", "" + s_bl + s_s); + test("truenull", "" + s_bl + sf_oN); + test("true94000000", "" + s_bl + f_I); + test("truenull", "" + s_bl + f_IN); + test("truetrue", "" + s_bl + sf_bl); + test("true5500", "" + s_bl + sf_s); + test("true-2900", "" + s_bl + s_sM); + test("true-194313216", "" + s_bl + sf_l); + test("true12", "" + s_bl + s_strU1); + test("trueC(87)", "" + s_bl + sf_o); + test("true91", "" + s_bl + s_strU2); + test("true21", "" + s_bl + f_strU1); + test("true18", "" + s_bl + f_strU2); + test("truenull", "" + s_bl + f_iAN); + test("truenull", "" + s_bl + s_oN); + test("true\u045180", "" + s_bl + s_strU); + test("trueC", "" + s_bl + sf_c); + test("true75", "" + s_bl + sf_str); + test("true-43", "" + s_bl + s_bM); + test("true80", "" + s_bl + sf_b); + test("truenull", "" + s_bl + s_IN); + test("true-52.0", "" + s_bl + s_fM); + test("true75000000", "" + s_bl + sf_i); + test("true44", "" + s_bl + f_b); + } + + public void run2() { + test("true-1705032704", "" + s_bl + sf_lM); + test("truenull", "" + s_bl + f_oAN); + test("true83.0", "" + s_bl + f_d); + test("trueI", "" + s_bl + f_c); + test("true94.0", "" + s_bl + f_f); + test("true12.0", "" + s_bl + sf_d); + test("true-99.0", "" + s_bl + f_dM); + test("true17.0", "" + s_bl + sf_f); + test("true-84.0", "" + s_bl + sf_dM); + test("true58000000", "" + s_bl + f_i); + test("true-55000000", "" + s_bl + f_iM); + test("true1460392448", "" + s_bl + f_l); + test("trueC(70)", "" + s_bl + f_o); + test("true\u04511", "" + s_bl + sf_strU); + test("true8000", "" + s_bl + f_s); + test("true18", "" + s_bl + s_str); + test("true-1000000", "" + s_bl + s_iM); + test("true1000000", "" + s_bl + sf_I); + test("truenull", "" + s_bl + f_oNtS); + test("truefalse", "" + s_bl + f_bl); + test("truenull", "" + s_bl + sf_iAN); + test("true-2000000", "" + s_bl + sf_iM); + test("true-820130816", "" + s_bl + f_lM); + test("truenull", "" + s_bl + sf_oAN); + test("true25000000", "" + s_bl + s_I); + test("3900-96.0", "" + s_s + s_dM); + test("3900null", "" + s_s + s_oNtS); + test("3900\u045176", "" + s_s + f_strU); + test("390092", "" + s_s + sf_strU2); + test("390051", "" + s_s + sf_strU1); + test("3900null", "" + s_s + s_iAN); + test("3900-54", "" + s_s + f_bM); + test("3900-87.0", "" + s_s + f_fM); + test("3900null", "" + s_s + s_oAN); + test("390019", "" + s_s + f_str); + test("3900-41", "" + s_s + sf_bM); + test("3900null", "" + s_s + sf_IN); + test("3900T", "" + s_s + s_c); + test("3900-42.0", "" + s_s + sf_fM); + test("390025", "" + s_s + s_b); + test("3900null", "" + s_s + f_oN); + test("3900-1410065408", "" + s_s + s_lM); + test("39008.0", "" + s_s + s_d); + test("390055.0", "" + s_s + s_f); + test("390097000000", "" + s_s + s_i); + test("3900-9900", "" + s_s + f_sM); + test("3900935228928", "" + s_s + s_l); + test("3900-8400", "" + s_s + sf_sM); + test("3900C(82)", "" + s_s + s_o); + test("3900null", "" + s_s + sf_oNtS); + test("3900true", "" + s_s + s_bl); + test("39003900", "" + s_s + s_s); + test("3900null", "" + s_s + sf_oN); + test("390094000000", "" + s_s + f_I); + test("3900null", "" + s_s + f_IN); + test("3900true", "" + s_s + sf_bl); + test("39005500", "" + s_s + sf_s); + test("3900-2900", "" + s_s + s_sM); + test("3900-194313216", "" + s_s + sf_l); + test("390012", "" + s_s + s_strU1); + test("3900C(87)", "" + s_s + sf_o); + test("390091", "" + s_s + s_strU2); + test("390021", "" + s_s + f_strU1); + test("390018", "" + s_s + f_strU2); + test("3900null", "" + s_s + f_iAN); + test("3900null", "" + s_s + s_oN); + test("3900\u045180", "" + s_s + s_strU); + test("3900C", "" + s_s + sf_c); + test("390075", "" + s_s + sf_str); + test("3900-43", "" + s_s + s_bM); + test("390080", "" + s_s + sf_b); + test("3900null", "" + s_s + s_IN); + test("3900-52.0", "" + s_s + s_fM); + test("390075000000", "" + s_s + sf_i); + test("390044", "" + s_s + f_b); + test("3900-1705032704", "" + s_s + sf_lM); + test("3900null", "" + s_s + f_oAN); + test("390083.0", "" + s_s + f_d); + test("3900I", "" + s_s + f_c); + test("390094.0", "" + s_s + f_f); + test("390012.0", "" + s_s + sf_d); + test("3900-99.0", "" + s_s + f_dM); + test("390017.0", "" + s_s + sf_f); + test("3900-84.0", "" + s_s + sf_dM); + test("390058000000", "" + s_s + f_i); + test("3900-55000000", "" + s_s + f_iM); + test("39001460392448", "" + s_s + f_l); + test("3900C(70)", "" + s_s + f_o); + test("3900\u04511", "" + s_s + sf_strU); + test("39008000", "" + s_s + f_s); + test("390018", "" + s_s + s_str); + test("3900-1000000", "" + s_s + s_iM); + test("39001000000", "" + s_s + sf_I); + test("3900null", "" + s_s + f_oNtS); + test("3900false", "" + s_s + f_bl); + test("3900null", "" + s_s + sf_iAN); + test("3900-2000000", "" + s_s + sf_iM); + test("3900-820130816", "" + s_s + f_lM); + test("3900null", "" + s_s + sf_oAN); + test("390025000000", "" + s_s + s_I); + test("null-96.0", "" + sf_oN + s_dM); + test("nullnull", "" + sf_oN + s_oNtS); + test("null\u045176", "" + sf_oN + f_strU); + test("null92", "" + sf_oN + sf_strU2); + test("null51", "" + sf_oN + sf_strU1); + test("nullnull", "" + sf_oN + s_iAN); + test("null-54", "" + sf_oN + f_bM); + test("null-87.0", "" + sf_oN + f_fM); + test("nullnull", "" + sf_oN + s_oAN); + test("null19", "" + sf_oN + f_str); + test("null-41", "" + sf_oN + sf_bM); + test("nullnull", "" + sf_oN + sf_IN); + test("nullT", "" + sf_oN + s_c); + test("null-42.0", "" + sf_oN + sf_fM); + test("null25", "" + sf_oN + s_b); + test("nullnull", "" + sf_oN + f_oN); + test("null-1410065408", "" + sf_oN + s_lM); + test("null8.0", "" + sf_oN + s_d); + test("null55.0", "" + sf_oN + s_f); + test("null97000000", "" + sf_oN + s_i); + test("null-9900", "" + sf_oN + f_sM); + test("null935228928", "" + sf_oN + s_l); + test("null-8400", "" + sf_oN + sf_sM); + test("nullC(82)", "" + sf_oN + s_o); + test("nullnull", "" + sf_oN + sf_oNtS); + test("nulltrue", "" + sf_oN + s_bl); + test("null3900", "" + sf_oN + s_s); + test("nullnull", "" + sf_oN + sf_oN); + test("null94000000", "" + sf_oN + f_I); + test("nullnull", "" + sf_oN + f_IN); + test("nulltrue", "" + sf_oN + sf_bl); + test("null5500", "" + sf_oN + sf_s); + test("null-2900", "" + sf_oN + s_sM); + test("null-194313216", "" + sf_oN + sf_l); + test("null12", "" + sf_oN + s_strU1); + test("nullC(87)", "" + sf_oN + sf_o); + test("null91", "" + sf_oN + s_strU2); + test("null21", "" + sf_oN + f_strU1); + test("null18", "" + sf_oN + f_strU2); + test("nullnull", "" + sf_oN + f_iAN); + test("nullnull", "" + sf_oN + s_oN); + test("null\u045180", "" + sf_oN + s_strU); + test("nullC", "" + sf_oN + sf_c); + test("null75", "" + sf_oN + sf_str); + test("null-43", "" + sf_oN + s_bM); + test("null80", "" + sf_oN + sf_b); + test("nullnull", "" + sf_oN + s_IN); + test("null-52.0", "" + sf_oN + s_fM); + test("null75000000", "" + sf_oN + sf_i); + test("null44", "" + sf_oN + f_b); + test("null-1705032704", "" + sf_oN + sf_lM); + test("nullnull", "" + sf_oN + f_oAN); + test("null83.0", "" + sf_oN + f_d); + test("nullI", "" + sf_oN + f_c); + test("null94.0", "" + sf_oN + f_f); + test("null12.0", "" + sf_oN + sf_d); + test("null-99.0", "" + sf_oN + f_dM); + test("null17.0", "" + sf_oN + sf_f); + test("null-84.0", "" + sf_oN + sf_dM); + test("null58000000", "" + sf_oN + f_i); + test("null-55000000", "" + sf_oN + f_iM); + test("null1460392448", "" + sf_oN + f_l); + test("nullC(70)", "" + sf_oN + f_o); + test("null\u04511", "" + sf_oN + sf_strU); + test("null8000", "" + sf_oN + f_s); + test("null18", "" + sf_oN + s_str); + test("null-1000000", "" + sf_oN + s_iM); + test("null1000000", "" + sf_oN + sf_I); + test("nullnull", "" + sf_oN + f_oNtS); + test("nullfalse", "" + sf_oN + f_bl); + test("nullnull", "" + sf_oN + sf_iAN); + test("null-2000000", "" + sf_oN + sf_iM); + test("null-820130816", "" + sf_oN + f_lM); + test("nullnull", "" + sf_oN + sf_oAN); + test("null25000000", "" + sf_oN + s_I); + test("94000000-96.0", "" + f_I + s_dM); + test("94000000null", "" + f_I + s_oNtS); + test("94000000\u045176", "" + f_I + f_strU); + test("9400000092", "" + f_I + sf_strU2); + test("9400000051", "" + f_I + sf_strU1); + test("94000000null", "" + f_I + s_iAN); + test("94000000-54", "" + f_I + f_bM); + test("94000000-87.0", "" + f_I + f_fM); + test("94000000null", "" + f_I + s_oAN); + test("9400000019", "" + f_I + f_str); + test("94000000-41", "" + f_I + sf_bM); + test("94000000null", "" + f_I + sf_IN); + test("94000000T", "" + f_I + s_c); + test("94000000-42.0", "" + f_I + sf_fM); + test("9400000025", "" + f_I + s_b); + test("94000000null", "" + f_I + f_oN); + test("94000000-1410065408", "" + f_I + s_lM); + test("940000008.0", "" + f_I + s_d); + test("9400000055.0", "" + f_I + s_f); + test("9400000097000000", "" + f_I + s_i); + test("94000000-9900", "" + f_I + f_sM); + test("94000000935228928", "" + f_I + s_l); + test("94000000-8400", "" + f_I + sf_sM); + test("94000000C(82)", "" + f_I + s_o); + test("94000000null", "" + f_I + sf_oNtS); + test("94000000true", "" + f_I + s_bl); + test("940000003900", "" + f_I + s_s); + test("94000000null", "" + f_I + sf_oN); + test("9400000094000000", "" + f_I + f_I); + test("94000000null", "" + f_I + f_IN); + test("94000000true", "" + f_I + sf_bl); + test("940000005500", "" + f_I + sf_s); + test("94000000-2900", "" + f_I + s_sM); + test("94000000-194313216", "" + f_I + sf_l); + test("9400000012", "" + f_I + s_strU1); + test("94000000C(87)", "" + f_I + sf_o); + test("9400000091", "" + f_I + s_strU2); + test("9400000021", "" + f_I + f_strU1); + test("9400000018", "" + f_I + f_strU2); + test("94000000null", "" + f_I + f_iAN); + test("94000000null", "" + f_I + s_oN); + test("94000000\u045180", "" + f_I + s_strU); + test("94000000C", "" + f_I + sf_c); + test("9400000075", "" + f_I + sf_str); + test("94000000-43", "" + f_I + s_bM); + test("9400000080", "" + f_I + sf_b); + test("94000000null", "" + f_I + s_IN); + test("94000000-52.0", "" + f_I + s_fM); + test("9400000075000000", "" + f_I + sf_i); + test("9400000044", "" + f_I + f_b); + test("94000000-1705032704", "" + f_I + sf_lM); + test("94000000null", "" + f_I + f_oAN); + test("9400000083.0", "" + f_I + f_d); + test("94000000I", "" + f_I + f_c); + test("9400000094.0", "" + f_I + f_f); + test("9400000012.0", "" + f_I + sf_d); + test("94000000-99.0", "" + f_I + f_dM); + test("9400000017.0", "" + f_I + sf_f); + test("94000000-84.0", "" + f_I + sf_dM); + test("9400000058000000", "" + f_I + f_i); + test("94000000-55000000", "" + f_I + f_iM); + test("940000001460392448", "" + f_I + f_l); + test("94000000C(70)", "" + f_I + f_o); + test("94000000\u04511", "" + f_I + sf_strU); + test("940000008000", "" + f_I + f_s); + test("9400000018", "" + f_I + s_str); + test("94000000-1000000", "" + f_I + s_iM); + test("940000001000000", "" + f_I + sf_I); + test("94000000null", "" + f_I + f_oNtS); + test("94000000false", "" + f_I + f_bl); + test("94000000null", "" + f_I + sf_iAN); + test("94000000-2000000", "" + f_I + sf_iM); + test("94000000-820130816", "" + f_I + f_lM); + test("94000000null", "" + f_I + sf_oAN); + test("9400000025000000", "" + f_I + s_I); + test("null-96.0", "" + f_IN + s_dM); + test("nullnull", "" + f_IN + s_oNtS); + test("null\u045176", "" + f_IN + f_strU); + test("null92", "" + f_IN + sf_strU2); + test("null51", "" + f_IN + sf_strU1); + test("nullnull", "" + f_IN + s_iAN); + test("null-54", "" + f_IN + f_bM); + test("null-87.0", "" + f_IN + f_fM); + test("nullnull", "" + f_IN + s_oAN); + test("null19", "" + f_IN + f_str); + test("null-41", "" + f_IN + sf_bM); + test("nullnull", "" + f_IN + sf_IN); + test("nullT", "" + f_IN + s_c); + test("null-42.0", "" + f_IN + sf_fM); + test("null25", "" + f_IN + s_b); + test("nullnull", "" + f_IN + f_oN); + test("null-1410065408", "" + f_IN + s_lM); + test("null8.0", "" + f_IN + s_d); + test("null55.0", "" + f_IN + s_f); + test("null97000000", "" + f_IN + s_i); + test("null-9900", "" + f_IN + f_sM); + test("null935228928", "" + f_IN + s_l); + test("null-8400", "" + f_IN + sf_sM); + test("nullC(82)", "" + f_IN + s_o); + test("nullnull", "" + f_IN + sf_oNtS); + test("nulltrue", "" + f_IN + s_bl); + test("null3900", "" + f_IN + s_s); + test("nullnull", "" + f_IN + sf_oN); + test("null94000000", "" + f_IN + f_I); + test("nullnull", "" + f_IN + f_IN); + test("nulltrue", "" + f_IN + sf_bl); + test("null5500", "" + f_IN + sf_s); + test("null-2900", "" + f_IN + s_sM); + test("null-194313216", "" + f_IN + sf_l); + test("null12", "" + f_IN + s_strU1); + test("nullC(87)", "" + f_IN + sf_o); + test("null91", "" + f_IN + s_strU2); + test("null21", "" + f_IN + f_strU1); + test("null18", "" + f_IN + f_strU2); + test("nullnull", "" + f_IN + f_iAN); + test("nullnull", "" + f_IN + s_oN); + test("null\u045180", "" + f_IN + s_strU); + test("nullC", "" + f_IN + sf_c); + test("null75", "" + f_IN + sf_str); + test("null-43", "" + f_IN + s_bM); + test("null80", "" + f_IN + sf_b); + test("nullnull", "" + f_IN + s_IN); + test("null-52.0", "" + f_IN + s_fM); + test("null75000000", "" + f_IN + sf_i); + test("null44", "" + f_IN + f_b); + test("null-1705032704", "" + f_IN + sf_lM); + test("nullnull", "" + f_IN + f_oAN); + test("null83.0", "" + f_IN + f_d); + test("nullI", "" + f_IN + f_c); + test("null94.0", "" + f_IN + f_f); + test("null12.0", "" + f_IN + sf_d); + test("null-99.0", "" + f_IN + f_dM); + test("null17.0", "" + f_IN + sf_f); + test("null-84.0", "" + f_IN + sf_dM); + test("null58000000", "" + f_IN + f_i); + test("null-55000000", "" + f_IN + f_iM); + test("null1460392448", "" + f_IN + f_l); + test("nullC(70)", "" + f_IN + f_o); + test("null\u04511", "" + f_IN + sf_strU); + test("null8000", "" + f_IN + f_s); + test("null18", "" + f_IN + s_str); + test("null-1000000", "" + f_IN + s_iM); + test("null1000000", "" + f_IN + sf_I); + test("nullnull", "" + f_IN + f_oNtS); + test("nullfalse", "" + f_IN + f_bl); + test("nullnull", "" + f_IN + sf_iAN); + test("null-2000000", "" + f_IN + sf_iM); + test("null-820130816", "" + f_IN + f_lM); + test("nullnull", "" + f_IN + sf_oAN); + test("null25000000", "" + f_IN + s_I); + test("true-96.0", "" + sf_bl + s_dM); + test("truenull", "" + sf_bl + s_oNtS); + test("true\u045176", "" + sf_bl + f_strU); + test("true92", "" + sf_bl + sf_strU2); + test("true51", "" + sf_bl + sf_strU1); + test("truenull", "" + sf_bl + s_iAN); + test("true-54", "" + sf_bl + f_bM); + test("true-87.0", "" + sf_bl + f_fM); + test("truenull", "" + sf_bl + s_oAN); + test("true19", "" + sf_bl + f_str); + test("true-41", "" + sf_bl + sf_bM); + test("truenull", "" + sf_bl + sf_IN); + test("trueT", "" + sf_bl + s_c); + test("true-42.0", "" + sf_bl + sf_fM); + test("true25", "" + sf_bl + s_b); + test("truenull", "" + sf_bl + f_oN); + test("true-1410065408", "" + sf_bl + s_lM); + test("true8.0", "" + sf_bl + s_d); + test("true55.0", "" + sf_bl + s_f); + test("true97000000", "" + sf_bl + s_i); + test("true-9900", "" + sf_bl + f_sM); + test("true935228928", "" + sf_bl + s_l); + test("true-8400", "" + sf_bl + sf_sM); + test("trueC(82)", "" + sf_bl + s_o); + test("truenull", "" + sf_bl + sf_oNtS); + test("truetrue", "" + sf_bl + s_bl); + test("true3900", "" + sf_bl + s_s); + test("truenull", "" + sf_bl + sf_oN); + test("true94000000", "" + sf_bl + f_I); + test("truenull", "" + sf_bl + f_IN); + test("truetrue", "" + sf_bl + sf_bl); + test("true5500", "" + sf_bl + sf_s); + test("true-2900", "" + sf_bl + s_sM); + test("true-194313216", "" + sf_bl + sf_l); + test("true12", "" + sf_bl + s_strU1); + test("trueC(87)", "" + sf_bl + sf_o); + test("true91", "" + sf_bl + s_strU2); + test("true21", "" + sf_bl + f_strU1); + test("true18", "" + sf_bl + f_strU2); + test("truenull", "" + sf_bl + f_iAN); + test("truenull", "" + sf_bl + s_oN); + test("true\u045180", "" + sf_bl + s_strU); + test("trueC", "" + sf_bl + sf_c); + test("true75", "" + sf_bl + sf_str); + test("true-43", "" + sf_bl + s_bM); + test("true80", "" + sf_bl + sf_b); + test("truenull", "" + sf_bl + s_IN); + test("true-52.0", "" + sf_bl + s_fM); + test("true75000000", "" + sf_bl + sf_i); + test("true44", "" + sf_bl + f_b); + test("true-1705032704", "" + sf_bl + sf_lM); + test("truenull", "" + sf_bl + f_oAN); + test("true83.0", "" + sf_bl + f_d); + test("trueI", "" + sf_bl + f_c); + test("true94.0", "" + sf_bl + f_f); + test("true12.0", "" + sf_bl + sf_d); + test("true-99.0", "" + sf_bl + f_dM); + test("true17.0", "" + sf_bl + sf_f); + test("true-84.0", "" + sf_bl + sf_dM); + test("true58000000", "" + sf_bl + f_i); + test("true-55000000", "" + sf_bl + f_iM); + test("true1460392448", "" + sf_bl + f_l); + test("trueC(70)", "" + sf_bl + f_o); + test("true\u04511", "" + sf_bl + sf_strU); + test("true8000", "" + sf_bl + f_s); + test("true18", "" + sf_bl + s_str); + test("true-1000000", "" + sf_bl + s_iM); + test("true1000000", "" + sf_bl + sf_I); + test("truenull", "" + sf_bl + f_oNtS); + test("truefalse", "" + sf_bl + f_bl); + test("truenull", "" + sf_bl + sf_iAN); + test("true-2000000", "" + sf_bl + sf_iM); + test("true-820130816", "" + sf_bl + f_lM); + test("truenull", "" + sf_bl + sf_oAN); + test("true25000000", "" + sf_bl + s_I); + test("5500-96.0", "" + sf_s + s_dM); + test("5500null", "" + sf_s + s_oNtS); + test("5500\u045176", "" + sf_s + f_strU); + test("550092", "" + sf_s + sf_strU2); + test("550051", "" + sf_s + sf_strU1); + test("5500null", "" + sf_s + s_iAN); + test("5500-54", "" + sf_s + f_bM); + test("5500-87.0", "" + sf_s + f_fM); + test("5500null", "" + sf_s + s_oAN); + test("550019", "" + sf_s + f_str); + test("5500-41", "" + sf_s + sf_bM); + test("5500null", "" + sf_s + sf_IN); + test("5500T", "" + sf_s + s_c); + test("5500-42.0", "" + sf_s + sf_fM); + test("550025", "" + sf_s + s_b); + test("5500null", "" + sf_s + f_oN); + test("5500-1410065408", "" + sf_s + s_lM); + test("55008.0", "" + sf_s + s_d); + test("550055.0", "" + sf_s + s_f); + test("550097000000", "" + sf_s + s_i); + test("5500-9900", "" + sf_s + f_sM); + test("5500935228928", "" + sf_s + s_l); + test("5500-8400", "" + sf_s + sf_sM); + test("5500C(82)", "" + sf_s + s_o); + test("5500null", "" + sf_s + sf_oNtS); + test("5500true", "" + sf_s + s_bl); + test("55003900", "" + sf_s + s_s); + test("5500null", "" + sf_s + sf_oN); + test("550094000000", "" + sf_s + f_I); + test("5500null", "" + sf_s + f_IN); + test("5500true", "" + sf_s + sf_bl); + test("55005500", "" + sf_s + sf_s); + test("5500-2900", "" + sf_s + s_sM); + test("5500-194313216", "" + sf_s + sf_l); + test("550012", "" + sf_s + s_strU1); + test("5500C(87)", "" + sf_s + sf_o); + test("550091", "" + sf_s + s_strU2); + test("550021", "" + sf_s + f_strU1); + test("550018", "" + sf_s + f_strU2); + test("5500null", "" + sf_s + f_iAN); + test("5500null", "" + sf_s + s_oN); + test("5500\u045180", "" + sf_s + s_strU); + test("5500C", "" + sf_s + sf_c); + test("550075", "" + sf_s + sf_str); + test("5500-43", "" + sf_s + s_bM); + test("550080", "" + sf_s + sf_b); + test("5500null", "" + sf_s + s_IN); + test("5500-52.0", "" + sf_s + s_fM); + test("550075000000", "" + sf_s + sf_i); + test("550044", "" + sf_s + f_b); + test("5500-1705032704", "" + sf_s + sf_lM); + test("5500null", "" + sf_s + f_oAN); + test("550083.0", "" + sf_s + f_d); + test("5500I", "" + sf_s + f_c); + test("550094.0", "" + sf_s + f_f); + test("550012.0", "" + sf_s + sf_d); + test("5500-99.0", "" + sf_s + f_dM); + test("550017.0", "" + sf_s + sf_f); + test("5500-84.0", "" + sf_s + sf_dM); + test("550058000000", "" + sf_s + f_i); + test("5500-55000000", "" + sf_s + f_iM); + test("55001460392448", "" + sf_s + f_l); + test("5500C(70)", "" + sf_s + f_o); + test("5500\u04511", "" + sf_s + sf_strU); + test("55008000", "" + sf_s + f_s); + test("550018", "" + sf_s + s_str); + test("5500-1000000", "" + sf_s + s_iM); + test("55001000000", "" + sf_s + sf_I); + test("5500null", "" + sf_s + f_oNtS); + test("5500false", "" + sf_s + f_bl); + test("5500null", "" + sf_s + sf_iAN); + test("5500-2000000", "" + sf_s + sf_iM); + test("5500-820130816", "" + sf_s + f_lM); + test("5500null", "" + sf_s + sf_oAN); + test("550025000000", "" + sf_s + s_I); + test("-2900-96.0", "" + s_sM + s_dM); + test("-2900null", "" + s_sM + s_oNtS); + test("-2900\u045176", "" + s_sM + f_strU); + test("-290092", "" + s_sM + sf_strU2); + test("-290051", "" + s_sM + sf_strU1); + test("-2900null", "" + s_sM + s_iAN); + test("-2900-54", "" + s_sM + f_bM); + test("-2900-87.0", "" + s_sM + f_fM); + test("-2900null", "" + s_sM + s_oAN); + test("-290019", "" + s_sM + f_str); + test("-2900-41", "" + s_sM + sf_bM); + test("-2900null", "" + s_sM + sf_IN); + test("-2900T", "" + s_sM + s_c); + test("-2900-42.0", "" + s_sM + sf_fM); + test("-290025", "" + s_sM + s_b); + test("-2900null", "" + s_sM + f_oN); + test("-2900-1410065408", "" + s_sM + s_lM); + test("-29008.0", "" + s_sM + s_d); + test("-290055.0", "" + s_sM + s_f); + test("-290097000000", "" + s_sM + s_i); + test("-2900-9900", "" + s_sM + f_sM); + test("-2900935228928", "" + s_sM + s_l); + test("-2900-8400", "" + s_sM + sf_sM); + test("-2900C(82)", "" + s_sM + s_o); + test("-2900null", "" + s_sM + sf_oNtS); + test("-2900true", "" + s_sM + s_bl); + test("-29003900", "" + s_sM + s_s); + test("-2900null", "" + s_sM + sf_oN); + test("-290094000000", "" + s_sM + f_I); + test("-2900null", "" + s_sM + f_IN); + test("-2900true", "" + s_sM + sf_bl); + test("-29005500", "" + s_sM + sf_s); + test("-2900-2900", "" + s_sM + s_sM); + test("-2900-194313216", "" + s_sM + sf_l); + test("-290012", "" + s_sM + s_strU1); + test("-2900C(87)", "" + s_sM + sf_o); + test("-290091", "" + s_sM + s_strU2); + test("-290021", "" + s_sM + f_strU1); + test("-290018", "" + s_sM + f_strU2); + test("-2900null", "" + s_sM + f_iAN); + test("-2900null", "" + s_sM + s_oN); + test("-2900\u045180", "" + s_sM + s_strU); + test("-2900C", "" + s_sM + sf_c); + test("-290075", "" + s_sM + sf_str); + test("-2900-43", "" + s_sM + s_bM); + test("-290080", "" + s_sM + sf_b); + test("-2900null", "" + s_sM + s_IN); + test("-2900-52.0", "" + s_sM + s_fM); + test("-290075000000", "" + s_sM + sf_i); + test("-290044", "" + s_sM + f_b); + test("-2900-1705032704", "" + s_sM + sf_lM); + test("-2900null", "" + s_sM + f_oAN); + test("-290083.0", "" + s_sM + f_d); + test("-2900I", "" + s_sM + f_c); + test("-290094.0", "" + s_sM + f_f); + test("-290012.0", "" + s_sM + sf_d); + test("-2900-99.0", "" + s_sM + f_dM); + test("-290017.0", "" + s_sM + sf_f); + test("-2900-84.0", "" + s_sM + sf_dM); + test("-290058000000", "" + s_sM + f_i); + test("-2900-55000000", "" + s_sM + f_iM); + test("-29001460392448", "" + s_sM + f_l); + test("-2900C(70)", "" + s_sM + f_o); + test("-2900\u04511", "" + s_sM + sf_strU); + test("-29008000", "" + s_sM + f_s); + test("-290018", "" + s_sM + s_str); + test("-2900-1000000", "" + s_sM + s_iM); + test("-29001000000", "" + s_sM + sf_I); + test("-2900null", "" + s_sM + f_oNtS); + test("-2900false", "" + s_sM + f_bl); + test("-2900null", "" + s_sM + sf_iAN); + test("-2900-2000000", "" + s_sM + sf_iM); + test("-2900-820130816", "" + s_sM + f_lM); + test("-2900null", "" + s_sM + sf_oAN); + test("-290025000000", "" + s_sM + s_I); + test("-194313216-96.0", "" + sf_l + s_dM); + test("-194313216null", "" + sf_l + s_oNtS); + test("-194313216\u045176", "" + sf_l + f_strU); + test("-19431321692", "" + sf_l + sf_strU2); + test("-19431321651", "" + sf_l + sf_strU1); + test("-194313216null", "" + sf_l + s_iAN); + test("-194313216-54", "" + sf_l + f_bM); + test("-194313216-87.0", "" + sf_l + f_fM); + test("-194313216null", "" + sf_l + s_oAN); + test("-19431321619", "" + sf_l + f_str); + test("-194313216-41", "" + sf_l + sf_bM); + test("-194313216null", "" + sf_l + sf_IN); + test("-194313216T", "" + sf_l + s_c); + test("-194313216-42.0", "" + sf_l + sf_fM); + test("-19431321625", "" + sf_l + s_b); + test("-194313216null", "" + sf_l + f_oN); + test("-194313216-1410065408", "" + sf_l + s_lM); + test("-1943132168.0", "" + sf_l + s_d); + test("-19431321655.0", "" + sf_l + s_f); + test("-19431321697000000", "" + sf_l + s_i); + test("-194313216-9900", "" + sf_l + f_sM); + test("-194313216935228928", "" + sf_l + s_l); + test("-194313216-8400", "" + sf_l + sf_sM); + test("-194313216C(82)", "" + sf_l + s_o); + test("-194313216null", "" + sf_l + sf_oNtS); + test("-194313216true", "" + sf_l + s_bl); + test("-1943132163900", "" + sf_l + s_s); + test("-194313216null", "" + sf_l + sf_oN); + test("-19431321694000000", "" + sf_l + f_I); + test("-194313216null", "" + sf_l + f_IN); + test("-194313216true", "" + sf_l + sf_bl); + test("-1943132165500", "" + sf_l + sf_s); + test("-194313216-2900", "" + sf_l + s_sM); + test("-194313216-194313216", "" + sf_l + sf_l); + test("-19431321612", "" + sf_l + s_strU1); + test("-194313216C(87)", "" + sf_l + sf_o); + test("-19431321691", "" + sf_l + s_strU2); + test("-19431321621", "" + sf_l + f_strU1); + test("-19431321618", "" + sf_l + f_strU2); + test("-194313216null", "" + sf_l + f_iAN); + test("-194313216null", "" + sf_l + s_oN); + test("-194313216\u045180", "" + sf_l + s_strU); + test("-194313216C", "" + sf_l + sf_c); + test("-19431321675", "" + sf_l + sf_str); + test("-194313216-43", "" + sf_l + s_bM); + test("-19431321680", "" + sf_l + sf_b); + test("-194313216null", "" + sf_l + s_IN); + test("-194313216-52.0", "" + sf_l + s_fM); + test("-19431321675000000", "" + sf_l + sf_i); + test("-19431321644", "" + sf_l + f_b); + test("-194313216-1705032704", "" + sf_l + sf_lM); + test("-194313216null", "" + sf_l + f_oAN); + test("-19431321683.0", "" + sf_l + f_d); + test("-194313216I", "" + sf_l + f_c); + test("-19431321694.0", "" + sf_l + f_f); + test("-19431321612.0", "" + sf_l + sf_d); + test("-194313216-99.0", "" + sf_l + f_dM); + test("-19431321617.0", "" + sf_l + sf_f); + test("-194313216-84.0", "" + sf_l + sf_dM); + test("-19431321658000000", "" + sf_l + f_i); + test("-194313216-55000000", "" + sf_l + f_iM); + test("-1943132161460392448", "" + sf_l + f_l); + test("-194313216C(70)", "" + sf_l + f_o); + test("-194313216\u04511", "" + sf_l + sf_strU); + test("-1943132168000", "" + sf_l + f_s); + test("-19431321618", "" + sf_l + s_str); + test("-194313216-1000000", "" + sf_l + s_iM); + test("-1943132161000000", "" + sf_l + sf_I); + test("-194313216null", "" + sf_l + f_oNtS); + test("-194313216false", "" + sf_l + f_bl); + test("-194313216null", "" + sf_l + sf_iAN); + test("-194313216-2000000", "" + sf_l + sf_iM); + test("-194313216-820130816", "" + sf_l + f_lM); + test("-194313216null", "" + sf_l + sf_oAN); + test("-19431321625000000", "" + sf_l + s_I); + test("12-96.0", "" + s_strU1 + s_dM); + test("12null", "" + s_strU1 + s_oNtS); + test("12\u045176", "" + s_strU1 + f_strU); + test("1292", "" + s_strU1 + sf_strU2); + test("1251", "" + s_strU1 + sf_strU1); + test("12null", "" + s_strU1 + s_iAN); + test("12-54", "" + s_strU1 + f_bM); + test("12-87.0", "" + s_strU1 + f_fM); + test("12null", "" + s_strU1 + s_oAN); + test("1219", "" + s_strU1 + f_str); + test("12-41", "" + s_strU1 + sf_bM); + test("12null", "" + s_strU1 + sf_IN); + test("12T", "" + s_strU1 + s_c); + test("12-42.0", "" + s_strU1 + sf_fM); + test("1225", "" + s_strU1 + s_b); + test("12null", "" + s_strU1 + f_oN); + test("12-1410065408", "" + s_strU1 + s_lM); + test("128.0", "" + s_strU1 + s_d); + test("1255.0", "" + s_strU1 + s_f); + test("1297000000", "" + s_strU1 + s_i); + test("12-9900", "" + s_strU1 + f_sM); + test("12935228928", "" + s_strU1 + s_l); + test("12-8400", "" + s_strU1 + sf_sM); + test("12C(82)", "" + s_strU1 + s_o); + test("12null", "" + s_strU1 + sf_oNtS); + test("12true", "" + s_strU1 + s_bl); + test("123900", "" + s_strU1 + s_s); + test("12null", "" + s_strU1 + sf_oN); + test("1294000000", "" + s_strU1 + f_I); + test("12null", "" + s_strU1 + f_IN); + test("12true", "" + s_strU1 + sf_bl); + test("125500", "" + s_strU1 + sf_s); + test("12-2900", "" + s_strU1 + s_sM); + test("12-194313216", "" + s_strU1 + sf_l); + test("1212", "" + s_strU1 + s_strU1); + test("12C(87)", "" + s_strU1 + sf_o); + test("1291", "" + s_strU1 + s_strU2); + test("1221", "" + s_strU1 + f_strU1); + test("1218", "" + s_strU1 + f_strU2); + test("12null", "" + s_strU1 + f_iAN); + test("12null", "" + s_strU1 + s_oN); + test("12\u045180", "" + s_strU1 + s_strU); + test("12C", "" + s_strU1 + sf_c); + test("1275", "" + s_strU1 + sf_str); + test("12-43", "" + s_strU1 + s_bM); + test("1280", "" + s_strU1 + sf_b); + test("12null", "" + s_strU1 + s_IN); + test("12-52.0", "" + s_strU1 + s_fM); + test("1275000000", "" + s_strU1 + sf_i); + test("1244", "" + s_strU1 + f_b); + test("12-1705032704", "" + s_strU1 + sf_lM); + test("12null", "" + s_strU1 + f_oAN); + test("1283.0", "" + s_strU1 + f_d); + test("12I", "" + s_strU1 + f_c); + test("1294.0", "" + s_strU1 + f_f); + test("1212.0", "" + s_strU1 + sf_d); + test("12-99.0", "" + s_strU1 + f_dM); + test("1217.0", "" + s_strU1 + sf_f); + test("12-84.0", "" + s_strU1 + sf_dM); + test("1258000000", "" + s_strU1 + f_i); + test("12-55000000", "" + s_strU1 + f_iM); + test("121460392448", "" + s_strU1 + f_l); + test("12C(70)", "" + s_strU1 + f_o); + test("12\u04511", "" + s_strU1 + sf_strU); + test("128000", "" + s_strU1 + f_s); + test("1218", "" + s_strU1 + s_str); + test("12-1000000", "" + s_strU1 + s_iM); + test("121000000", "" + s_strU1 + sf_I); + test("12null", "" + s_strU1 + f_oNtS); + test("12false", "" + s_strU1 + f_bl); + test("12null", "" + s_strU1 + sf_iAN); + test("12-2000000", "" + s_strU1 + sf_iM); + test("12-820130816", "" + s_strU1 + f_lM); + test("12null", "" + s_strU1 + sf_oAN); + test("1225000000", "" + s_strU1 + s_I); + test("C(87)-96.0", "" + sf_o + s_dM); + test("C(87)null", "" + sf_o + s_oNtS); + test("C(87)\u045176", "" + sf_o + f_strU); + test("C(87)92", "" + sf_o + sf_strU2); + test("C(87)51", "" + sf_o + sf_strU1); + test("C(87)null", "" + sf_o + s_iAN); + test("C(87)-54", "" + sf_o + f_bM); + test("C(87)-87.0", "" + sf_o + f_fM); + test("C(87)null", "" + sf_o + s_oAN); + test("C(87)19", "" + sf_o + f_str); + test("C(87)-41", "" + sf_o + sf_bM); + test("C(87)null", "" + sf_o + sf_IN); + test("C(87)T", "" + sf_o + s_c); + test("C(87)-42.0", "" + sf_o + sf_fM); + test("C(87)25", "" + sf_o + s_b); + test("C(87)null", "" + sf_o + f_oN); + test("C(87)-1410065408", "" + sf_o + s_lM); + test("C(87)8.0", "" + sf_o + s_d); + test("C(87)55.0", "" + sf_o + s_f); + test("C(87)97000000", "" + sf_o + s_i); + test("C(87)-9900", "" + sf_o + f_sM); + test("C(87)935228928", "" + sf_o + s_l); + test("C(87)-8400", "" + sf_o + sf_sM); + test("C(87)C(82)", "" + sf_o + s_o); + test("C(87)null", "" + sf_o + sf_oNtS); + test("C(87)true", "" + sf_o + s_bl); + test("C(87)3900", "" + sf_o + s_s); + test("C(87)null", "" + sf_o + sf_oN); + test("C(87)94000000", "" + sf_o + f_I); + test("C(87)null", "" + sf_o + f_IN); + test("C(87)true", "" + sf_o + sf_bl); + test("C(87)5500", "" + sf_o + sf_s); + test("C(87)-2900", "" + sf_o + s_sM); + test("C(87)-194313216", "" + sf_o + sf_l); + test("C(87)12", "" + sf_o + s_strU1); + test("C(87)C(87)", "" + sf_o + sf_o); + test("C(87)91", "" + sf_o + s_strU2); + test("C(87)21", "" + sf_o + f_strU1); + test("C(87)18", "" + sf_o + f_strU2); + test("C(87)null", "" + sf_o + f_iAN); + test("C(87)null", "" + sf_o + s_oN); + test("C(87)\u045180", "" + sf_o + s_strU); + test("C(87)C", "" + sf_o + sf_c); + test("C(87)75", "" + sf_o + sf_str); + test("C(87)-43", "" + sf_o + s_bM); + test("C(87)80", "" + sf_o + sf_b); + test("C(87)null", "" + sf_o + s_IN); + test("C(87)-52.0", "" + sf_o + s_fM); + test("C(87)75000000", "" + sf_o + sf_i); + test("C(87)44", "" + sf_o + f_b); + test("C(87)-1705032704", "" + sf_o + sf_lM); + test("C(87)null", "" + sf_o + f_oAN); + test("C(87)83.0", "" + sf_o + f_d); + test("C(87)I", "" + sf_o + f_c); + test("C(87)94.0", "" + sf_o + f_f); + test("C(87)12.0", "" + sf_o + sf_d); + test("C(87)-99.0", "" + sf_o + f_dM); + test("C(87)17.0", "" + sf_o + sf_f); + test("C(87)-84.0", "" + sf_o + sf_dM); + test("C(87)58000000", "" + sf_o + f_i); + test("C(87)-55000000", "" + sf_o + f_iM); + test("C(87)1460392448", "" + sf_o + f_l); + test("C(87)C(70)", "" + sf_o + f_o); + test("C(87)\u04511", "" + sf_o + sf_strU); + test("C(87)8000", "" + sf_o + f_s); + test("C(87)18", "" + sf_o + s_str); + test("C(87)-1000000", "" + sf_o + s_iM); + test("C(87)1000000", "" + sf_o + sf_I); + test("C(87)null", "" + sf_o + f_oNtS); + test("C(87)false", "" + sf_o + f_bl); + test("C(87)null", "" + sf_o + sf_iAN); + test("C(87)-2000000", "" + sf_o + sf_iM); + test("C(87)-820130816", "" + sf_o + f_lM); + test("C(87)null", "" + sf_o + sf_oAN); + test("C(87)25000000", "" + sf_o + s_I); + test("91-96.0", "" + s_strU2 + s_dM); + test("91null", "" + s_strU2 + s_oNtS); + test("91\u045176", "" + s_strU2 + f_strU); + test("9192", "" + s_strU2 + sf_strU2); + test("9151", "" + s_strU2 + sf_strU1); + test("91null", "" + s_strU2 + s_iAN); + test("91-54", "" + s_strU2 + f_bM); + test("91-87.0", "" + s_strU2 + f_fM); + test("91null", "" + s_strU2 + s_oAN); + test("9119", "" + s_strU2 + f_str); + test("91-41", "" + s_strU2 + sf_bM); + test("91null", "" + s_strU2 + sf_IN); + test("91T", "" + s_strU2 + s_c); + test("91-42.0", "" + s_strU2 + sf_fM); + test("9125", "" + s_strU2 + s_b); + test("91null", "" + s_strU2 + f_oN); + test("91-1410065408", "" + s_strU2 + s_lM); + test("918.0", "" + s_strU2 + s_d); + test("9155.0", "" + s_strU2 + s_f); + test("9197000000", "" + s_strU2 + s_i); + test("91-9900", "" + s_strU2 + f_sM); + test("91935228928", "" + s_strU2 + s_l); + test("91-8400", "" + s_strU2 + sf_sM); + test("91C(82)", "" + s_strU2 + s_o); + test("91null", "" + s_strU2 + sf_oNtS); + test("91true", "" + s_strU2 + s_bl); + test("913900", "" + s_strU2 + s_s); + test("91null", "" + s_strU2 + sf_oN); + test("9194000000", "" + s_strU2 + f_I); + test("91null", "" + s_strU2 + f_IN); + test("91true", "" + s_strU2 + sf_bl); + test("915500", "" + s_strU2 + sf_s); + test("91-2900", "" + s_strU2 + s_sM); + test("91-194313216", "" + s_strU2 + sf_l); + test("9112", "" + s_strU2 + s_strU1); + test("91C(87)", "" + s_strU2 + sf_o); + test("9191", "" + s_strU2 + s_strU2); + test("9121", "" + s_strU2 + f_strU1); + test("9118", "" + s_strU2 + f_strU2); + test("91null", "" + s_strU2 + f_iAN); + test("91null", "" + s_strU2 + s_oN); + test("91\u045180", "" + s_strU2 + s_strU); + test("91C", "" + s_strU2 + sf_c); + test("9175", "" + s_strU2 + sf_str); + test("91-43", "" + s_strU2 + s_bM); + test("9180", "" + s_strU2 + sf_b); + test("91null", "" + s_strU2 + s_IN); + test("91-52.0", "" + s_strU2 + s_fM); + test("9175000000", "" + s_strU2 + sf_i); + test("9144", "" + s_strU2 + f_b); + test("91-1705032704", "" + s_strU2 + sf_lM); + test("91null", "" + s_strU2 + f_oAN); + test("9183.0", "" + s_strU2 + f_d); + test("91I", "" + s_strU2 + f_c); + test("9194.0", "" + s_strU2 + f_f); + test("9112.0", "" + s_strU2 + sf_d); + test("91-99.0", "" + s_strU2 + f_dM); + test("9117.0", "" + s_strU2 + sf_f); + test("91-84.0", "" + s_strU2 + sf_dM); + test("9158000000", "" + s_strU2 + f_i); + test("91-55000000", "" + s_strU2 + f_iM); + test("911460392448", "" + s_strU2 + f_l); + test("91C(70)", "" + s_strU2 + f_o); + test("91\u04511", "" + s_strU2 + sf_strU); + test("918000", "" + s_strU2 + f_s); + test("9118", "" + s_strU2 + s_str); + test("91-1000000", "" + s_strU2 + s_iM); + test("911000000", "" + s_strU2 + sf_I); + test("91null", "" + s_strU2 + f_oNtS); + test("91false", "" + s_strU2 + f_bl); + test("91null", "" + s_strU2 + sf_iAN); + test("91-2000000", "" + s_strU2 + sf_iM); + test("91-820130816", "" + s_strU2 + f_lM); + test("91null", "" + s_strU2 + sf_oAN); + test("9125000000", "" + s_strU2 + s_I); + test("21-96.0", "" + f_strU1 + s_dM); + test("21null", "" + f_strU1 + s_oNtS); + test("21\u045176", "" + f_strU1 + f_strU); + test("2192", "" + f_strU1 + sf_strU2); + test("2151", "" + f_strU1 + sf_strU1); + test("21null", "" + f_strU1 + s_iAN); + test("21-54", "" + f_strU1 + f_bM); + test("21-87.0", "" + f_strU1 + f_fM); + test("21null", "" + f_strU1 + s_oAN); + test("2119", "" + f_strU1 + f_str); + test("21-41", "" + f_strU1 + sf_bM); + test("21null", "" + f_strU1 + sf_IN); + test("21T", "" + f_strU1 + s_c); + test("21-42.0", "" + f_strU1 + sf_fM); + test("2125", "" + f_strU1 + s_b); + test("21null", "" + f_strU1 + f_oN); + test("21-1410065408", "" + f_strU1 + s_lM); + test("218.0", "" + f_strU1 + s_d); + test("2155.0", "" + f_strU1 + s_f); + test("2197000000", "" + f_strU1 + s_i); + test("21-9900", "" + f_strU1 + f_sM); + test("21935228928", "" + f_strU1 + s_l); + test("21-8400", "" + f_strU1 + sf_sM); + test("21C(82)", "" + f_strU1 + s_o); + test("21null", "" + f_strU1 + sf_oNtS); + test("21true", "" + f_strU1 + s_bl); + test("213900", "" + f_strU1 + s_s); + test("21null", "" + f_strU1 + sf_oN); + test("2194000000", "" + f_strU1 + f_I); + test("21null", "" + f_strU1 + f_IN); + test("21true", "" + f_strU1 + sf_bl); + test("215500", "" + f_strU1 + sf_s); + test("21-2900", "" + f_strU1 + s_sM); + test("21-194313216", "" + f_strU1 + sf_l); + test("2112", "" + f_strU1 + s_strU1); + test("21C(87)", "" + f_strU1 + sf_o); + test("2191", "" + f_strU1 + s_strU2); + test("2121", "" + f_strU1 + f_strU1); + test("2118", "" + f_strU1 + f_strU2); + test("21null", "" + f_strU1 + f_iAN); + test("21null", "" + f_strU1 + s_oN); + test("21\u045180", "" + f_strU1 + s_strU); + test("21C", "" + f_strU1 + sf_c); + test("2175", "" + f_strU1 + sf_str); + test("21-43", "" + f_strU1 + s_bM); + test("2180", "" + f_strU1 + sf_b); + test("21null", "" + f_strU1 + s_IN); + test("21-52.0", "" + f_strU1 + s_fM); + test("2175000000", "" + f_strU1 + sf_i); + test("2144", "" + f_strU1 + f_b); + test("21-1705032704", "" + f_strU1 + sf_lM); + test("21null", "" + f_strU1 + f_oAN); + test("2183.0", "" + f_strU1 + f_d); + test("21I", "" + f_strU1 + f_c); + test("2194.0", "" + f_strU1 + f_f); + test("2112.0", "" + f_strU1 + sf_d); + test("21-99.0", "" + f_strU1 + f_dM); + test("2117.0", "" + f_strU1 + sf_f); + test("21-84.0", "" + f_strU1 + sf_dM); + test("2158000000", "" + f_strU1 + f_i); + test("21-55000000", "" + f_strU1 + f_iM); + test("211460392448", "" + f_strU1 + f_l); + test("21C(70)", "" + f_strU1 + f_o); + test("21\u04511", "" + f_strU1 + sf_strU); + test("218000", "" + f_strU1 + f_s); + test("2118", "" + f_strU1 + s_str); + test("21-1000000", "" + f_strU1 + s_iM); + test("211000000", "" + f_strU1 + sf_I); + test("21null", "" + f_strU1 + f_oNtS); + test("21false", "" + f_strU1 + f_bl); + test("21null", "" + f_strU1 + sf_iAN); + test("21-2000000", "" + f_strU1 + sf_iM); + test("21-820130816", "" + f_strU1 + f_lM); + test("21null", "" + f_strU1 + sf_oAN); + test("2125000000", "" + f_strU1 + s_I); + test("18-96.0", "" + f_strU2 + s_dM); + test("18null", "" + f_strU2 + s_oNtS); + test("18\u045176", "" + f_strU2 + f_strU); + test("1892", "" + f_strU2 + sf_strU2); + test("1851", "" + f_strU2 + sf_strU1); + test("18null", "" + f_strU2 + s_iAN); + test("18-54", "" + f_strU2 + f_bM); + test("18-87.0", "" + f_strU2 + f_fM); + test("18null", "" + f_strU2 + s_oAN); + test("1819", "" + f_strU2 + f_str); + test("18-41", "" + f_strU2 + sf_bM); + test("18null", "" + f_strU2 + sf_IN); + test("18T", "" + f_strU2 + s_c); + test("18-42.0", "" + f_strU2 + sf_fM); + test("1825", "" + f_strU2 + s_b); + test("18null", "" + f_strU2 + f_oN); + test("18-1410065408", "" + f_strU2 + s_lM); + test("188.0", "" + f_strU2 + s_d); + test("1855.0", "" + f_strU2 + s_f); + test("1897000000", "" + f_strU2 + s_i); + test("18-9900", "" + f_strU2 + f_sM); + test("18935228928", "" + f_strU2 + s_l); + test("18-8400", "" + f_strU2 + sf_sM); + test("18C(82)", "" + f_strU2 + s_o); + test("18null", "" + f_strU2 + sf_oNtS); + test("18true", "" + f_strU2 + s_bl); + test("183900", "" + f_strU2 + s_s); + test("18null", "" + f_strU2 + sf_oN); + test("1894000000", "" + f_strU2 + f_I); + test("18null", "" + f_strU2 + f_IN); + test("18true", "" + f_strU2 + sf_bl); + test("185500", "" + f_strU2 + sf_s); + test("18-2900", "" + f_strU2 + s_sM); + test("18-194313216", "" + f_strU2 + sf_l); + test("1812", "" + f_strU2 + s_strU1); + test("18C(87)", "" + f_strU2 + sf_o); + test("1891", "" + f_strU2 + s_strU2); + test("1821", "" + f_strU2 + f_strU1); + test("1818", "" + f_strU2 + f_strU2); + test("18null", "" + f_strU2 + f_iAN); + test("18null", "" + f_strU2 + s_oN); + test("18\u045180", "" + f_strU2 + s_strU); + test("18C", "" + f_strU2 + sf_c); + test("1875", "" + f_strU2 + sf_str); + test("18-43", "" + f_strU2 + s_bM); + test("1880", "" + f_strU2 + sf_b); + test("18null", "" + f_strU2 + s_IN); + test("18-52.0", "" + f_strU2 + s_fM); + test("1875000000", "" + f_strU2 + sf_i); + test("1844", "" + f_strU2 + f_b); + test("18-1705032704", "" + f_strU2 + sf_lM); + test("18null", "" + f_strU2 + f_oAN); + test("1883.0", "" + f_strU2 + f_d); + test("18I", "" + f_strU2 + f_c); + test("1894.0", "" + f_strU2 + f_f); + test("1812.0", "" + f_strU2 + sf_d); + test("18-99.0", "" + f_strU2 + f_dM); + test("1817.0", "" + f_strU2 + sf_f); + test("18-84.0", "" + f_strU2 + sf_dM); + test("1858000000", "" + f_strU2 + f_i); + test("18-55000000", "" + f_strU2 + f_iM); + test("181460392448", "" + f_strU2 + f_l); + test("18C(70)", "" + f_strU2 + f_o); + test("18\u04511", "" + f_strU2 + sf_strU); + test("188000", "" + f_strU2 + f_s); + test("1818", "" + f_strU2 + s_str); + test("18-1000000", "" + f_strU2 + s_iM); + test("181000000", "" + f_strU2 + sf_I); + test("18null", "" + f_strU2 + f_oNtS); + test("18false", "" + f_strU2 + f_bl); + test("18null", "" + f_strU2 + sf_iAN); + test("18-2000000", "" + f_strU2 + sf_iM); + test("18-820130816", "" + f_strU2 + f_lM); + test("18null", "" + f_strU2 + sf_oAN); + test("1825000000", "" + f_strU2 + s_I); + } + + public void run3() { + test("null-96.0", "" + f_iAN + s_dM); + test("nullnull", "" + f_iAN + s_oNtS); + test("null\u045176", "" + f_iAN + f_strU); + test("null92", "" + f_iAN + sf_strU2); + test("null51", "" + f_iAN + sf_strU1); + test("nullnull", "" + f_iAN + s_iAN); + test("null-54", "" + f_iAN + f_bM); + test("null-87.0", "" + f_iAN + f_fM); + test("nullnull", "" + f_iAN + s_oAN); + test("null19", "" + f_iAN + f_str); + test("null-41", "" + f_iAN + sf_bM); + test("nullnull", "" + f_iAN + sf_IN); + test("nullT", "" + f_iAN + s_c); + test("null-42.0", "" + f_iAN + sf_fM); + test("null25", "" + f_iAN + s_b); + test("nullnull", "" + f_iAN + f_oN); + test("null-1410065408", "" + f_iAN + s_lM); + test("null8.0", "" + f_iAN + s_d); + test("null55.0", "" + f_iAN + s_f); + test("null97000000", "" + f_iAN + s_i); + test("null-9900", "" + f_iAN + f_sM); + test("null935228928", "" + f_iAN + s_l); + test("null-8400", "" + f_iAN + sf_sM); + test("nullC(82)", "" + f_iAN + s_o); + test("nullnull", "" + f_iAN + sf_oNtS); + test("nulltrue", "" + f_iAN + s_bl); + test("null3900", "" + f_iAN + s_s); + test("nullnull", "" + f_iAN + sf_oN); + test("null94000000", "" + f_iAN + f_I); + test("nullnull", "" + f_iAN + f_IN); + test("nulltrue", "" + f_iAN + sf_bl); + test("null5500", "" + f_iAN + sf_s); + test("null-2900", "" + f_iAN + s_sM); + test("null-194313216", "" + f_iAN + sf_l); + test("null12", "" + f_iAN + s_strU1); + test("nullC(87)", "" + f_iAN + sf_o); + test("null91", "" + f_iAN + s_strU2); + test("null21", "" + f_iAN + f_strU1); + test("null18", "" + f_iAN + f_strU2); + test("nullnull", "" + f_iAN + f_iAN); + test("nullnull", "" + f_iAN + s_oN); + test("null\u045180", "" + f_iAN + s_strU); + test("nullC", "" + f_iAN + sf_c); + test("null75", "" + f_iAN + sf_str); + test("null-43", "" + f_iAN + s_bM); + test("null80", "" + f_iAN + sf_b); + test("nullnull", "" + f_iAN + s_IN); + test("null-52.0", "" + f_iAN + s_fM); + test("null75000000", "" + f_iAN + sf_i); + test("null44", "" + f_iAN + f_b); + test("null-1705032704", "" + f_iAN + sf_lM); + test("nullnull", "" + f_iAN + f_oAN); + test("null83.0", "" + f_iAN + f_d); + test("nullI", "" + f_iAN + f_c); + test("null94.0", "" + f_iAN + f_f); + test("null12.0", "" + f_iAN + sf_d); + test("null-99.0", "" + f_iAN + f_dM); + test("null17.0", "" + f_iAN + sf_f); + test("null-84.0", "" + f_iAN + sf_dM); + test("null58000000", "" + f_iAN + f_i); + test("null-55000000", "" + f_iAN + f_iM); + test("null1460392448", "" + f_iAN + f_l); + test("nullC(70)", "" + f_iAN + f_o); + test("null\u04511", "" + f_iAN + sf_strU); + test("null8000", "" + f_iAN + f_s); + test("null18", "" + f_iAN + s_str); + test("null-1000000", "" + f_iAN + s_iM); + test("null1000000", "" + f_iAN + sf_I); + test("nullnull", "" + f_iAN + f_oNtS); + test("nullfalse", "" + f_iAN + f_bl); + test("nullnull", "" + f_iAN + sf_iAN); + test("null-2000000", "" + f_iAN + sf_iM); + test("null-820130816", "" + f_iAN + f_lM); + test("nullnull", "" + f_iAN + sf_oAN); + test("null25000000", "" + f_iAN + s_I); + test("null-96.0", "" + s_oN + s_dM); + test("nullnull", "" + s_oN + s_oNtS); + test("null\u045176", "" + s_oN + f_strU); + test("null92", "" + s_oN + sf_strU2); + test("null51", "" + s_oN + sf_strU1); + test("nullnull", "" + s_oN + s_iAN); + test("null-54", "" + s_oN + f_bM); + test("null-87.0", "" + s_oN + f_fM); + test("nullnull", "" + s_oN + s_oAN); + test("null19", "" + s_oN + f_str); + test("null-41", "" + s_oN + sf_bM); + test("nullnull", "" + s_oN + sf_IN); + test("nullT", "" + s_oN + s_c); + test("null-42.0", "" + s_oN + sf_fM); + test("null25", "" + s_oN + s_b); + test("nullnull", "" + s_oN + f_oN); + test("null-1410065408", "" + s_oN + s_lM); + test("null8.0", "" + s_oN + s_d); + test("null55.0", "" + s_oN + s_f); + test("null97000000", "" + s_oN + s_i); + test("null-9900", "" + s_oN + f_sM); + test("null935228928", "" + s_oN + s_l); + test("null-8400", "" + s_oN + sf_sM); + test("nullC(82)", "" + s_oN + s_o); + test("nullnull", "" + s_oN + sf_oNtS); + test("nulltrue", "" + s_oN + s_bl); + test("null3900", "" + s_oN + s_s); + test("nullnull", "" + s_oN + sf_oN); + test("null94000000", "" + s_oN + f_I); + test("nullnull", "" + s_oN + f_IN); + test("nulltrue", "" + s_oN + sf_bl); + test("null5500", "" + s_oN + sf_s); + test("null-2900", "" + s_oN + s_sM); + test("null-194313216", "" + s_oN + sf_l); + test("null12", "" + s_oN + s_strU1); + test("nullC(87)", "" + s_oN + sf_o); + test("null91", "" + s_oN + s_strU2); + test("null21", "" + s_oN + f_strU1); + test("null18", "" + s_oN + f_strU2); + test("nullnull", "" + s_oN + f_iAN); + test("nullnull", "" + s_oN + s_oN); + test("null\u045180", "" + s_oN + s_strU); + test("nullC", "" + s_oN + sf_c); + test("null75", "" + s_oN + sf_str); + test("null-43", "" + s_oN + s_bM); + test("null80", "" + s_oN + sf_b); + test("nullnull", "" + s_oN + s_IN); + test("null-52.0", "" + s_oN + s_fM); + test("null75000000", "" + s_oN + sf_i); + test("null44", "" + s_oN + f_b); + test("null-1705032704", "" + s_oN + sf_lM); + test("nullnull", "" + s_oN + f_oAN); + test("null83.0", "" + s_oN + f_d); + test("nullI", "" + s_oN + f_c); + test("null94.0", "" + s_oN + f_f); + test("null12.0", "" + s_oN + sf_d); + test("null-99.0", "" + s_oN + f_dM); + test("null17.0", "" + s_oN + sf_f); + test("null-84.0", "" + s_oN + sf_dM); + test("null58000000", "" + s_oN + f_i); + test("null-55000000", "" + s_oN + f_iM); + test("null1460392448", "" + s_oN + f_l); + test("nullC(70)", "" + s_oN + f_o); + test("null\u04511", "" + s_oN + sf_strU); + test("null8000", "" + s_oN + f_s); + test("null18", "" + s_oN + s_str); + test("null-1000000", "" + s_oN + s_iM); + test("null1000000", "" + s_oN + sf_I); + test("nullnull", "" + s_oN + f_oNtS); + test("nullfalse", "" + s_oN + f_bl); + test("nullnull", "" + s_oN + sf_iAN); + test("null-2000000", "" + s_oN + sf_iM); + test("null-820130816", "" + s_oN + f_lM); + test("nullnull", "" + s_oN + sf_oAN); + test("null25000000", "" + s_oN + s_I); + test("\u045180-96.0", "" + s_strU + s_dM); + test("\u045180null", "" + s_strU + s_oNtS); + test("\u045180\u045176", "" + s_strU + f_strU); + test("\u04518092", "" + s_strU + sf_strU2); + test("\u04518051", "" + s_strU + sf_strU1); + test("\u045180null", "" + s_strU + s_iAN); + test("\u045180-54", "" + s_strU + f_bM); + test("\u045180-87.0", "" + s_strU + f_fM); + test("\u045180null", "" + s_strU + s_oAN); + test("\u04518019", "" + s_strU + f_str); + test("\u045180-41", "" + s_strU + sf_bM); + test("\u045180null", "" + s_strU + sf_IN); + test("\u045180T", "" + s_strU + s_c); + test("\u045180-42.0", "" + s_strU + sf_fM); + test("\u04518025", "" + s_strU + s_b); + test("\u045180null", "" + s_strU + f_oN); + test("\u045180-1410065408", "" + s_strU + s_lM); + test("\u0451808.0", "" + s_strU + s_d); + test("\u04518055.0", "" + s_strU + s_f); + test("\u04518097000000", "" + s_strU + s_i); + test("\u045180-9900", "" + s_strU + f_sM); + test("\u045180935228928", "" + s_strU + s_l); + test("\u045180-8400", "" + s_strU + sf_sM); + test("\u045180C(82)", "" + s_strU + s_o); + test("\u045180null", "" + s_strU + sf_oNtS); + test("\u045180true", "" + s_strU + s_bl); + test("\u0451803900", "" + s_strU + s_s); + test("\u045180null", "" + s_strU + sf_oN); + test("\u04518094000000", "" + s_strU + f_I); + test("\u045180null", "" + s_strU + f_IN); + test("\u045180true", "" + s_strU + sf_bl); + test("\u0451805500", "" + s_strU + sf_s); + test("\u045180-2900", "" + s_strU + s_sM); + test("\u045180-194313216", "" + s_strU + sf_l); + test("\u04518012", "" + s_strU + s_strU1); + test("\u045180C(87)", "" + s_strU + sf_o); + test("\u04518091", "" + s_strU + s_strU2); + test("\u04518021", "" + s_strU + f_strU1); + test("\u04518018", "" + s_strU + f_strU2); + test("\u045180null", "" + s_strU + f_iAN); + test("\u045180null", "" + s_strU + s_oN); + test("\u045180\u045180", "" + s_strU + s_strU); + test("\u045180C", "" + s_strU + sf_c); + test("\u04518075", "" + s_strU + sf_str); + test("\u045180-43", "" + s_strU + s_bM); + test("\u04518080", "" + s_strU + sf_b); + test("\u045180null", "" + s_strU + s_IN); + test("\u045180-52.0", "" + s_strU + s_fM); + test("\u04518075000000", "" + s_strU + sf_i); + test("\u04518044", "" + s_strU + f_b); + test("\u045180-1705032704", "" + s_strU + sf_lM); + test("\u045180null", "" + s_strU + f_oAN); + test("\u04518083.0", "" + s_strU + f_d); + test("\u045180I", "" + s_strU + f_c); + test("\u04518094.0", "" + s_strU + f_f); + test("\u04518012.0", "" + s_strU + sf_d); + test("\u045180-99.0", "" + s_strU + f_dM); + test("\u04518017.0", "" + s_strU + sf_f); + test("\u045180-84.0", "" + s_strU + sf_dM); + test("\u04518058000000", "" + s_strU + f_i); + test("\u045180-55000000", "" + s_strU + f_iM); + test("\u0451801460392448", "" + s_strU + f_l); + test("\u045180C(70)", "" + s_strU + f_o); + test("\u045180\u04511", "" + s_strU + sf_strU); + test("\u0451808000", "" + s_strU + f_s); + test("\u04518018", "" + s_strU + s_str); + test("\u045180-1000000", "" + s_strU + s_iM); + test("\u0451801000000", "" + s_strU + sf_I); + test("\u045180null", "" + s_strU + f_oNtS); + test("\u045180false", "" + s_strU + f_bl); + test("\u045180null", "" + s_strU + sf_iAN); + test("\u045180-2000000", "" + s_strU + sf_iM); + test("\u045180-820130816", "" + s_strU + f_lM); + test("\u045180null", "" + s_strU + sf_oAN); + test("\u04518025000000", "" + s_strU + s_I); + test("C-96.0", "" + sf_c + s_dM); + test("Cnull", "" + sf_c + s_oNtS); + test("C\u045176", "" + sf_c + f_strU); + test("C92", "" + sf_c + sf_strU2); + test("C51", "" + sf_c + sf_strU1); + test("Cnull", "" + sf_c + s_iAN); + test("C-54", "" + sf_c + f_bM); + test("C-87.0", "" + sf_c + f_fM); + test("Cnull", "" + sf_c + s_oAN); + test("C19", "" + sf_c + f_str); + test("C-41", "" + sf_c + sf_bM); + test("Cnull", "" + sf_c + sf_IN); + test("CT", "" + sf_c + s_c); + test("C-42.0", "" + sf_c + sf_fM); + test("C25", "" + sf_c + s_b); + test("Cnull", "" + sf_c + f_oN); + test("C-1410065408", "" + sf_c + s_lM); + test("C8.0", "" + sf_c + s_d); + test("C55.0", "" + sf_c + s_f); + test("C97000000", "" + sf_c + s_i); + test("C-9900", "" + sf_c + f_sM); + test("C935228928", "" + sf_c + s_l); + test("C-8400", "" + sf_c + sf_sM); + test("CC(82)", "" + sf_c + s_o); + test("Cnull", "" + sf_c + sf_oNtS); + test("Ctrue", "" + sf_c + s_bl); + test("C3900", "" + sf_c + s_s); + test("Cnull", "" + sf_c + sf_oN); + test("C94000000", "" + sf_c + f_I); + test("Cnull", "" + sf_c + f_IN); + test("Ctrue", "" + sf_c + sf_bl); + test("C5500", "" + sf_c + sf_s); + test("C-2900", "" + sf_c + s_sM); + test("C-194313216", "" + sf_c + sf_l); + test("C12", "" + sf_c + s_strU1); + test("CC(87)", "" + sf_c + sf_o); + test("C91", "" + sf_c + s_strU2); + test("C21", "" + sf_c + f_strU1); + test("C18", "" + sf_c + f_strU2); + test("Cnull", "" + sf_c + f_iAN); + test("Cnull", "" + sf_c + s_oN); + test("C\u045180", "" + sf_c + s_strU); + test("CC", "" + sf_c + sf_c); + test("C75", "" + sf_c + sf_str); + test("C-43", "" + sf_c + s_bM); + test("C80", "" + sf_c + sf_b); + test("Cnull", "" + sf_c + s_IN); + test("C-52.0", "" + sf_c + s_fM); + test("C75000000", "" + sf_c + sf_i); + test("C44", "" + sf_c + f_b); + test("C-1705032704", "" + sf_c + sf_lM); + test("Cnull", "" + sf_c + f_oAN); + test("C83.0", "" + sf_c + f_d); + test("CI", "" + sf_c + f_c); + test("C94.0", "" + sf_c + f_f); + test("C12.0", "" + sf_c + sf_d); + test("C-99.0", "" + sf_c + f_dM); + test("C17.0", "" + sf_c + sf_f); + test("C-84.0", "" + sf_c + sf_dM); + test("C58000000", "" + sf_c + f_i); + test("C-55000000", "" + sf_c + f_iM); + test("C1460392448", "" + sf_c + f_l); + test("CC(70)", "" + sf_c + f_o); + test("C\u04511", "" + sf_c + sf_strU); + test("C8000", "" + sf_c + f_s); + test("C18", "" + sf_c + s_str); + test("C-1000000", "" + sf_c + s_iM); + test("C1000000", "" + sf_c + sf_I); + test("Cnull", "" + sf_c + f_oNtS); + test("Cfalse", "" + sf_c + f_bl); + test("Cnull", "" + sf_c + sf_iAN); + test("C-2000000", "" + sf_c + sf_iM); + test("C-820130816", "" + sf_c + f_lM); + test("Cnull", "" + sf_c + sf_oAN); + test("C25000000", "" + sf_c + s_I); + test("75-96.0", "" + sf_str + s_dM); + test("75null", "" + sf_str + s_oNtS); + test("75\u045176", "" + sf_str + f_strU); + test("7592", "" + sf_str + sf_strU2); + test("7551", "" + sf_str + sf_strU1); + test("75null", "" + sf_str + s_iAN); + test("75-54", "" + sf_str + f_bM); + test("75-87.0", "" + sf_str + f_fM); + test("75null", "" + sf_str + s_oAN); + test("7519", "" + sf_str + f_str); + test("75-41", "" + sf_str + sf_bM); + test("75null", "" + sf_str + sf_IN); + test("75T", "" + sf_str + s_c); + test("75-42.0", "" + sf_str + sf_fM); + test("7525", "" + sf_str + s_b); + test("75null", "" + sf_str + f_oN); + test("75-1410065408", "" + sf_str + s_lM); + test("758.0", "" + sf_str + s_d); + test("7555.0", "" + sf_str + s_f); + test("7597000000", "" + sf_str + s_i); + test("75-9900", "" + sf_str + f_sM); + test("75935228928", "" + sf_str + s_l); + test("75-8400", "" + sf_str + sf_sM); + test("75C(82)", "" + sf_str + s_o); + test("75null", "" + sf_str + sf_oNtS); + test("75true", "" + sf_str + s_bl); + test("753900", "" + sf_str + s_s); + test("75null", "" + sf_str + sf_oN); + test("7594000000", "" + sf_str + f_I); + test("75null", "" + sf_str + f_IN); + test("75true", "" + sf_str + sf_bl); + test("755500", "" + sf_str + sf_s); + test("75-2900", "" + sf_str + s_sM); + test("75-194313216", "" + sf_str + sf_l); + test("7512", "" + sf_str + s_strU1); + test("75C(87)", "" + sf_str + sf_o); + test("7591", "" + sf_str + s_strU2); + test("7521", "" + sf_str + f_strU1); + test("7518", "" + sf_str + f_strU2); + test("75null", "" + sf_str + f_iAN); + test("75null", "" + sf_str + s_oN); + test("75\u045180", "" + sf_str + s_strU); + test("75C", "" + sf_str + sf_c); + test("7575", "" + sf_str + sf_str); + test("75-43", "" + sf_str + s_bM); + test("7580", "" + sf_str + sf_b); + test("75null", "" + sf_str + s_IN); + test("75-52.0", "" + sf_str + s_fM); + test("7575000000", "" + sf_str + sf_i); + test("7544", "" + sf_str + f_b); + test("75-1705032704", "" + sf_str + sf_lM); + test("75null", "" + sf_str + f_oAN); + test("7583.0", "" + sf_str + f_d); + test("75I", "" + sf_str + f_c); + test("7594.0", "" + sf_str + f_f); + test("7512.0", "" + sf_str + sf_d); + test("75-99.0", "" + sf_str + f_dM); + test("7517.0", "" + sf_str + sf_f); + test("75-84.0", "" + sf_str + sf_dM); + test("7558000000", "" + sf_str + f_i); + test("75-55000000", "" + sf_str + f_iM); + test("751460392448", "" + sf_str + f_l); + test("75C(70)", "" + sf_str + f_o); + test("75\u04511", "" + sf_str + sf_strU); + test("758000", "" + sf_str + f_s); + test("7518", "" + sf_str + s_str); + test("75-1000000", "" + sf_str + s_iM); + test("751000000", "" + sf_str + sf_I); + test("75null", "" + sf_str + f_oNtS); + test("75false", "" + sf_str + f_bl); + test("75null", "" + sf_str + sf_iAN); + test("75-2000000", "" + sf_str + sf_iM); + test("75-820130816", "" + sf_str + f_lM); + test("75null", "" + sf_str + sf_oAN); + test("7525000000", "" + sf_str + s_I); + test("-43-96.0", "" + s_bM + s_dM); + test("-43null", "" + s_bM + s_oNtS); + test("-43\u045176", "" + s_bM + f_strU); + test("-4392", "" + s_bM + sf_strU2); + test("-4351", "" + s_bM + sf_strU1); + test("-43null", "" + s_bM + s_iAN); + test("-43-54", "" + s_bM + f_bM); + test("-43-87.0", "" + s_bM + f_fM); + test("-43null", "" + s_bM + s_oAN); + test("-4319", "" + s_bM + f_str); + test("-43-41", "" + s_bM + sf_bM); + test("-43null", "" + s_bM + sf_IN); + test("-43T", "" + s_bM + s_c); + test("-43-42.0", "" + s_bM + sf_fM); + test("-4325", "" + s_bM + s_b); + test("-43null", "" + s_bM + f_oN); + test("-43-1410065408", "" + s_bM + s_lM); + test("-438.0", "" + s_bM + s_d); + test("-4355.0", "" + s_bM + s_f); + test("-4397000000", "" + s_bM + s_i); + test("-43-9900", "" + s_bM + f_sM); + test("-43935228928", "" + s_bM + s_l); + test("-43-8400", "" + s_bM + sf_sM); + test("-43C(82)", "" + s_bM + s_o); + test("-43null", "" + s_bM + sf_oNtS); + test("-43true", "" + s_bM + s_bl); + test("-433900", "" + s_bM + s_s); + test("-43null", "" + s_bM + sf_oN); + test("-4394000000", "" + s_bM + f_I); + test("-43null", "" + s_bM + f_IN); + test("-43true", "" + s_bM + sf_bl); + test("-435500", "" + s_bM + sf_s); + test("-43-2900", "" + s_bM + s_sM); + test("-43-194313216", "" + s_bM + sf_l); + test("-4312", "" + s_bM + s_strU1); + test("-43C(87)", "" + s_bM + sf_o); + test("-4391", "" + s_bM + s_strU2); + test("-4321", "" + s_bM + f_strU1); + test("-4318", "" + s_bM + f_strU2); + test("-43null", "" + s_bM + f_iAN); + test("-43null", "" + s_bM + s_oN); + test("-43\u045180", "" + s_bM + s_strU); + test("-43C", "" + s_bM + sf_c); + test("-4375", "" + s_bM + sf_str); + test("-43-43", "" + s_bM + s_bM); + test("-4380", "" + s_bM + sf_b); + test("-43null", "" + s_bM + s_IN); + test("-43-52.0", "" + s_bM + s_fM); + test("-4375000000", "" + s_bM + sf_i); + test("-4344", "" + s_bM + f_b); + test("-43-1705032704", "" + s_bM + sf_lM); + test("-43null", "" + s_bM + f_oAN); + test("-4383.0", "" + s_bM + f_d); + test("-43I", "" + s_bM + f_c); + test("-4394.0", "" + s_bM + f_f); + test("-4312.0", "" + s_bM + sf_d); + test("-43-99.0", "" + s_bM + f_dM); + test("-4317.0", "" + s_bM + sf_f); + test("-43-84.0", "" + s_bM + sf_dM); + test("-4358000000", "" + s_bM + f_i); + test("-43-55000000", "" + s_bM + f_iM); + test("-431460392448", "" + s_bM + f_l); + test("-43C(70)", "" + s_bM + f_o); + test("-43\u04511", "" + s_bM + sf_strU); + test("-438000", "" + s_bM + f_s); + test("-4318", "" + s_bM + s_str); + test("-43-1000000", "" + s_bM + s_iM); + test("-431000000", "" + s_bM + sf_I); + test("-43null", "" + s_bM + f_oNtS); + test("-43false", "" + s_bM + f_bl); + test("-43null", "" + s_bM + sf_iAN); + test("-43-2000000", "" + s_bM + sf_iM); + test("-43-820130816", "" + s_bM + f_lM); + test("-43null", "" + s_bM + sf_oAN); + test("-4325000000", "" + s_bM + s_I); + test("80-96.0", "" + sf_b + s_dM); + test("80null", "" + sf_b + s_oNtS); + test("80\u045176", "" + sf_b + f_strU); + test("8092", "" + sf_b + sf_strU2); + test("8051", "" + sf_b + sf_strU1); + test("80null", "" + sf_b + s_iAN); + test("80-54", "" + sf_b + f_bM); + test("80-87.0", "" + sf_b + f_fM); + test("80null", "" + sf_b + s_oAN); + test("8019", "" + sf_b + f_str); + test("80-41", "" + sf_b + sf_bM); + test("80null", "" + sf_b + sf_IN); + test("80T", "" + sf_b + s_c); + test("80-42.0", "" + sf_b + sf_fM); + test("8025", "" + sf_b + s_b); + test("80null", "" + sf_b + f_oN); + test("80-1410065408", "" + sf_b + s_lM); + test("808.0", "" + sf_b + s_d); + test("8055.0", "" + sf_b + s_f); + test("8097000000", "" + sf_b + s_i); + test("80-9900", "" + sf_b + f_sM); + test("80935228928", "" + sf_b + s_l); + test("80-8400", "" + sf_b + sf_sM); + test("80C(82)", "" + sf_b + s_o); + test("80null", "" + sf_b + sf_oNtS); + test("80true", "" + sf_b + s_bl); + test("803900", "" + sf_b + s_s); + test("80null", "" + sf_b + sf_oN); + test("8094000000", "" + sf_b + f_I); + test("80null", "" + sf_b + f_IN); + test("80true", "" + sf_b + sf_bl); + test("805500", "" + sf_b + sf_s); + test("80-2900", "" + sf_b + s_sM); + test("80-194313216", "" + sf_b + sf_l); + test("8012", "" + sf_b + s_strU1); + test("80C(87)", "" + sf_b + sf_o); + test("8091", "" + sf_b + s_strU2); + test("8021", "" + sf_b + f_strU1); + test("8018", "" + sf_b + f_strU2); + test("80null", "" + sf_b + f_iAN); + test("80null", "" + sf_b + s_oN); + test("80\u045180", "" + sf_b + s_strU); + test("80C", "" + sf_b + sf_c); + test("8075", "" + sf_b + sf_str); + test("80-43", "" + sf_b + s_bM); + test("8080", "" + sf_b + sf_b); + test("80null", "" + sf_b + s_IN); + test("80-52.0", "" + sf_b + s_fM); + test("8075000000", "" + sf_b + sf_i); + test("8044", "" + sf_b + f_b); + test("80-1705032704", "" + sf_b + sf_lM); + test("80null", "" + sf_b + f_oAN); + test("8083.0", "" + sf_b + f_d); + test("80I", "" + sf_b + f_c); + test("8094.0", "" + sf_b + f_f); + test("8012.0", "" + sf_b + sf_d); + test("80-99.0", "" + sf_b + f_dM); + test("8017.0", "" + sf_b + sf_f); + test("80-84.0", "" + sf_b + sf_dM); + test("8058000000", "" + sf_b + f_i); + test("80-55000000", "" + sf_b + f_iM); + test("801460392448", "" + sf_b + f_l); + test("80C(70)", "" + sf_b + f_o); + test("80\u04511", "" + sf_b + sf_strU); + test("808000", "" + sf_b + f_s); + test("8018", "" + sf_b + s_str); + test("80-1000000", "" + sf_b + s_iM); + test("801000000", "" + sf_b + sf_I); + test("80null", "" + sf_b + f_oNtS); + test("80false", "" + sf_b + f_bl); + test("80null", "" + sf_b + sf_iAN); + test("80-2000000", "" + sf_b + sf_iM); + test("80-820130816", "" + sf_b + f_lM); + test("80null", "" + sf_b + sf_oAN); + test("8025000000", "" + sf_b + s_I); + test("null-96.0", "" + s_IN + s_dM); + test("nullnull", "" + s_IN + s_oNtS); + test("null\u045176", "" + s_IN + f_strU); + test("null92", "" + s_IN + sf_strU2); + test("null51", "" + s_IN + sf_strU1); + test("nullnull", "" + s_IN + s_iAN); + test("null-54", "" + s_IN + f_bM); + test("null-87.0", "" + s_IN + f_fM); + test("nullnull", "" + s_IN + s_oAN); + test("null19", "" + s_IN + f_str); + test("null-41", "" + s_IN + sf_bM); + test("nullnull", "" + s_IN + sf_IN); + test("nullT", "" + s_IN + s_c); + test("null-42.0", "" + s_IN + sf_fM); + test("null25", "" + s_IN + s_b); + test("nullnull", "" + s_IN + f_oN); + test("null-1410065408", "" + s_IN + s_lM); + test("null8.0", "" + s_IN + s_d); + test("null55.0", "" + s_IN + s_f); + test("null97000000", "" + s_IN + s_i); + test("null-9900", "" + s_IN + f_sM); + test("null935228928", "" + s_IN + s_l); + test("null-8400", "" + s_IN + sf_sM); + test("nullC(82)", "" + s_IN + s_o); + test("nullnull", "" + s_IN + sf_oNtS); + test("nulltrue", "" + s_IN + s_bl); + test("null3900", "" + s_IN + s_s); + test("nullnull", "" + s_IN + sf_oN); + test("null94000000", "" + s_IN + f_I); + test("nullnull", "" + s_IN + f_IN); + test("nulltrue", "" + s_IN + sf_bl); + test("null5500", "" + s_IN + sf_s); + test("null-2900", "" + s_IN + s_sM); + test("null-194313216", "" + s_IN + sf_l); + test("null12", "" + s_IN + s_strU1); + test("nullC(87)", "" + s_IN + sf_o); + test("null91", "" + s_IN + s_strU2); + test("null21", "" + s_IN + f_strU1); + test("null18", "" + s_IN + f_strU2); + test("nullnull", "" + s_IN + f_iAN); + test("nullnull", "" + s_IN + s_oN); + test("null\u045180", "" + s_IN + s_strU); + test("nullC", "" + s_IN + sf_c); + test("null75", "" + s_IN + sf_str); + test("null-43", "" + s_IN + s_bM); + test("null80", "" + s_IN + sf_b); + test("nullnull", "" + s_IN + s_IN); + test("null-52.0", "" + s_IN + s_fM); + test("null75000000", "" + s_IN + sf_i); + test("null44", "" + s_IN + f_b); + test("null-1705032704", "" + s_IN + sf_lM); + test("nullnull", "" + s_IN + f_oAN); + test("null83.0", "" + s_IN + f_d); + test("nullI", "" + s_IN + f_c); + test("null94.0", "" + s_IN + f_f); + test("null12.0", "" + s_IN + sf_d); + test("null-99.0", "" + s_IN + f_dM); + test("null17.0", "" + s_IN + sf_f); + test("null-84.0", "" + s_IN + sf_dM); + test("null58000000", "" + s_IN + f_i); + test("null-55000000", "" + s_IN + f_iM); + test("null1460392448", "" + s_IN + f_l); + test("nullC(70)", "" + s_IN + f_o); + test("null\u04511", "" + s_IN + sf_strU); + test("null8000", "" + s_IN + f_s); + test("null18", "" + s_IN + s_str); + test("null-1000000", "" + s_IN + s_iM); + test("null1000000", "" + s_IN + sf_I); + test("nullnull", "" + s_IN + f_oNtS); + test("nullfalse", "" + s_IN + f_bl); + test("nullnull", "" + s_IN + sf_iAN); + test("null-2000000", "" + s_IN + sf_iM); + test("null-820130816", "" + s_IN + f_lM); + test("nullnull", "" + s_IN + sf_oAN); + test("null25000000", "" + s_IN + s_I); + test("-52.0-96.0", "" + s_fM + s_dM); + test("-52.0null", "" + s_fM + s_oNtS); + test("-52.0\u045176", "" + s_fM + f_strU); + test("-52.092", "" + s_fM + sf_strU2); + test("-52.051", "" + s_fM + sf_strU1); + test("-52.0null", "" + s_fM + s_iAN); + test("-52.0-54", "" + s_fM + f_bM); + test("-52.0-87.0", "" + s_fM + f_fM); + test("-52.0null", "" + s_fM + s_oAN); + test("-52.019", "" + s_fM + f_str); + test("-52.0-41", "" + s_fM + sf_bM); + test("-52.0null", "" + s_fM + sf_IN); + test("-52.0T", "" + s_fM + s_c); + test("-52.0-42.0", "" + s_fM + sf_fM); + test("-52.025", "" + s_fM + s_b); + test("-52.0null", "" + s_fM + f_oN); + test("-52.0-1410065408", "" + s_fM + s_lM); + test("-52.08.0", "" + s_fM + s_d); + test("-52.055.0", "" + s_fM + s_f); + test("-52.097000000", "" + s_fM + s_i); + test("-52.0-9900", "" + s_fM + f_sM); + test("-52.0935228928", "" + s_fM + s_l); + test("-52.0-8400", "" + s_fM + sf_sM); + test("-52.0C(82)", "" + s_fM + s_o); + test("-52.0null", "" + s_fM + sf_oNtS); + test("-52.0true", "" + s_fM + s_bl); + test("-52.03900", "" + s_fM + s_s); + test("-52.0null", "" + s_fM + sf_oN); + test("-52.094000000", "" + s_fM + f_I); + test("-52.0null", "" + s_fM + f_IN); + test("-52.0true", "" + s_fM + sf_bl); + test("-52.05500", "" + s_fM + sf_s); + test("-52.0-2900", "" + s_fM + s_sM); + test("-52.0-194313216", "" + s_fM + sf_l); + test("-52.012", "" + s_fM + s_strU1); + test("-52.0C(87)", "" + s_fM + sf_o); + test("-52.091", "" + s_fM + s_strU2); + test("-52.021", "" + s_fM + f_strU1); + test("-52.018", "" + s_fM + f_strU2); + test("-52.0null", "" + s_fM + f_iAN); + test("-52.0null", "" + s_fM + s_oN); + test("-52.0\u045180", "" + s_fM + s_strU); + test("-52.0C", "" + s_fM + sf_c); + test("-52.075", "" + s_fM + sf_str); + test("-52.0-43", "" + s_fM + s_bM); + test("-52.080", "" + s_fM + sf_b); + test("-52.0null", "" + s_fM + s_IN); + test("-52.0-52.0", "" + s_fM + s_fM); + test("-52.075000000", "" + s_fM + sf_i); + test("-52.044", "" + s_fM + f_b); + test("-52.0-1705032704", "" + s_fM + sf_lM); + test("-52.0null", "" + s_fM + f_oAN); + test("-52.083.0", "" + s_fM + f_d); + test("-52.0I", "" + s_fM + f_c); + test("-52.094.0", "" + s_fM + f_f); + test("-52.012.0", "" + s_fM + sf_d); + test("-52.0-99.0", "" + s_fM + f_dM); + test("-52.017.0", "" + s_fM + sf_f); + test("-52.0-84.0", "" + s_fM + sf_dM); + test("-52.058000000", "" + s_fM + f_i); + test("-52.0-55000000", "" + s_fM + f_iM); + test("-52.01460392448", "" + s_fM + f_l); + test("-52.0C(70)", "" + s_fM + f_o); + test("-52.0\u04511", "" + s_fM + sf_strU); + test("-52.08000", "" + s_fM + f_s); + test("-52.018", "" + s_fM + s_str); + test("-52.0-1000000", "" + s_fM + s_iM); + test("-52.01000000", "" + s_fM + sf_I); + test("-52.0null", "" + s_fM + f_oNtS); + test("-52.0false", "" + s_fM + f_bl); + test("-52.0null", "" + s_fM + sf_iAN); + test("-52.0-2000000", "" + s_fM + sf_iM); + test("-52.0-820130816", "" + s_fM + f_lM); + test("-52.0null", "" + s_fM + sf_oAN); + test("-52.025000000", "" + s_fM + s_I); + test("75000000-96.0", "" + sf_i + s_dM); + test("75000000null", "" + sf_i + s_oNtS); + test("75000000\u045176", "" + sf_i + f_strU); + test("7500000092", "" + sf_i + sf_strU2); + test("7500000051", "" + sf_i + sf_strU1); + test("75000000null", "" + sf_i + s_iAN); + test("75000000-54", "" + sf_i + f_bM); + test("75000000-87.0", "" + sf_i + f_fM); + test("75000000null", "" + sf_i + s_oAN); + test("7500000019", "" + sf_i + f_str); + test("75000000-41", "" + sf_i + sf_bM); + test("75000000null", "" + sf_i + sf_IN); + test("75000000T", "" + sf_i + s_c); + test("75000000-42.0", "" + sf_i + sf_fM); + test("7500000025", "" + sf_i + s_b); + test("75000000null", "" + sf_i + f_oN); + test("75000000-1410065408", "" + sf_i + s_lM); + test("750000008.0", "" + sf_i + s_d); + test("7500000055.0", "" + sf_i + s_f); + test("7500000097000000", "" + sf_i + s_i); + test("75000000-9900", "" + sf_i + f_sM); + test("75000000935228928", "" + sf_i + s_l); + test("75000000-8400", "" + sf_i + sf_sM); + test("75000000C(82)", "" + sf_i + s_o); + test("75000000null", "" + sf_i + sf_oNtS); + test("75000000true", "" + sf_i + s_bl); + test("750000003900", "" + sf_i + s_s); + test("75000000null", "" + sf_i + sf_oN); + test("7500000094000000", "" + sf_i + f_I); + test("75000000null", "" + sf_i + f_IN); + test("75000000true", "" + sf_i + sf_bl); + test("750000005500", "" + sf_i + sf_s); + test("75000000-2900", "" + sf_i + s_sM); + test("75000000-194313216", "" + sf_i + sf_l); + test("7500000012", "" + sf_i + s_strU1); + test("75000000C(87)", "" + sf_i + sf_o); + test("7500000091", "" + sf_i + s_strU2); + test("7500000021", "" + sf_i + f_strU1); + test("7500000018", "" + sf_i + f_strU2); + test("75000000null", "" + sf_i + f_iAN); + test("75000000null", "" + sf_i + s_oN); + test("75000000\u045180", "" + sf_i + s_strU); + test("75000000C", "" + sf_i + sf_c); + test("7500000075", "" + sf_i + sf_str); + test("75000000-43", "" + sf_i + s_bM); + test("7500000080", "" + sf_i + sf_b); + test("75000000null", "" + sf_i + s_IN); + test("75000000-52.0", "" + sf_i + s_fM); + test("7500000075000000", "" + sf_i + sf_i); + test("7500000044", "" + sf_i + f_b); + test("75000000-1705032704", "" + sf_i + sf_lM); + test("75000000null", "" + sf_i + f_oAN); + test("7500000083.0", "" + sf_i + f_d); + test("75000000I", "" + sf_i + f_c); + test("7500000094.0", "" + sf_i + f_f); + test("7500000012.0", "" + sf_i + sf_d); + test("75000000-99.0", "" + sf_i + f_dM); + test("7500000017.0", "" + sf_i + sf_f); + test("75000000-84.0", "" + sf_i + sf_dM); + test("7500000058000000", "" + sf_i + f_i); + test("75000000-55000000", "" + sf_i + f_iM); + test("750000001460392448", "" + sf_i + f_l); + test("75000000C(70)", "" + sf_i + f_o); + test("75000000\u04511", "" + sf_i + sf_strU); + test("750000008000", "" + sf_i + f_s); + test("7500000018", "" + sf_i + s_str); + test("75000000-1000000", "" + sf_i + s_iM); + test("750000001000000", "" + sf_i + sf_I); + test("75000000null", "" + sf_i + f_oNtS); + test("75000000false", "" + sf_i + f_bl); + test("75000000null", "" + sf_i + sf_iAN); + test("75000000-2000000", "" + sf_i + sf_iM); + test("75000000-820130816", "" + sf_i + f_lM); + test("75000000null", "" + sf_i + sf_oAN); + test("7500000025000000", "" + sf_i + s_I); + test("44-96.0", "" + f_b + s_dM); + test("44null", "" + f_b + s_oNtS); + test("44\u045176", "" + f_b + f_strU); + test("4492", "" + f_b + sf_strU2); + test("4451", "" + f_b + sf_strU1); + test("44null", "" + f_b + s_iAN); + test("44-54", "" + f_b + f_bM); + test("44-87.0", "" + f_b + f_fM); + test("44null", "" + f_b + s_oAN); + test("4419", "" + f_b + f_str); + test("44-41", "" + f_b + sf_bM); + test("44null", "" + f_b + sf_IN); + test("44T", "" + f_b + s_c); + test("44-42.0", "" + f_b + sf_fM); + test("4425", "" + f_b + s_b); + test("44null", "" + f_b + f_oN); + test("44-1410065408", "" + f_b + s_lM); + test("448.0", "" + f_b + s_d); + test("4455.0", "" + f_b + s_f); + test("4497000000", "" + f_b + s_i); + test("44-9900", "" + f_b + f_sM); + test("44935228928", "" + f_b + s_l); + test("44-8400", "" + f_b + sf_sM); + test("44C(82)", "" + f_b + s_o); + test("44null", "" + f_b + sf_oNtS); + test("44true", "" + f_b + s_bl); + test("443900", "" + f_b + s_s); + test("44null", "" + f_b + sf_oN); + test("4494000000", "" + f_b + f_I); + test("44null", "" + f_b + f_IN); + test("44true", "" + f_b + sf_bl); + test("445500", "" + f_b + sf_s); + test("44-2900", "" + f_b + s_sM); + test("44-194313216", "" + f_b + sf_l); + test("4412", "" + f_b + s_strU1); + test("44C(87)", "" + f_b + sf_o); + test("4491", "" + f_b + s_strU2); + test("4421", "" + f_b + f_strU1); + test("4418", "" + f_b + f_strU2); + test("44null", "" + f_b + f_iAN); + test("44null", "" + f_b + s_oN); + test("44\u045180", "" + f_b + s_strU); + test("44C", "" + f_b + sf_c); + test("4475", "" + f_b + sf_str); + test("44-43", "" + f_b + s_bM); + test("4480", "" + f_b + sf_b); + test("44null", "" + f_b + s_IN); + test("44-52.0", "" + f_b + s_fM); + test("4475000000", "" + f_b + sf_i); + test("4444", "" + f_b + f_b); + test("44-1705032704", "" + f_b + sf_lM); + test("44null", "" + f_b + f_oAN); + test("4483.0", "" + f_b + f_d); + test("44I", "" + f_b + f_c); + test("4494.0", "" + f_b + f_f); + test("4412.0", "" + f_b + sf_d); + test("44-99.0", "" + f_b + f_dM); + test("4417.0", "" + f_b + sf_f); + test("44-84.0", "" + f_b + sf_dM); + test("4458000000", "" + f_b + f_i); + test("44-55000000", "" + f_b + f_iM); + test("441460392448", "" + f_b + f_l); + test("44C(70)", "" + f_b + f_o); + test("44\u04511", "" + f_b + sf_strU); + test("448000", "" + f_b + f_s); + test("4418", "" + f_b + s_str); + test("44-1000000", "" + f_b + s_iM); + test("441000000", "" + f_b + sf_I); + test("44null", "" + f_b + f_oNtS); + test("44false", "" + f_b + f_bl); + test("44null", "" + f_b + sf_iAN); + test("44-2000000", "" + f_b + sf_iM); + test("44-820130816", "" + f_b + f_lM); + test("44null", "" + f_b + sf_oAN); + test("4425000000", "" + f_b + s_I); + test("-1705032704-96.0", "" + sf_lM + s_dM); + test("-1705032704null", "" + sf_lM + s_oNtS); + test("-1705032704\u045176", "" + sf_lM + f_strU); + test("-170503270492", "" + sf_lM + sf_strU2); + test("-170503270451", "" + sf_lM + sf_strU1); + test("-1705032704null", "" + sf_lM + s_iAN); + test("-1705032704-54", "" + sf_lM + f_bM); + test("-1705032704-87.0", "" + sf_lM + f_fM); + test("-1705032704null", "" + sf_lM + s_oAN); + test("-170503270419", "" + sf_lM + f_str); + test("-1705032704-41", "" + sf_lM + sf_bM); + test("-1705032704null", "" + sf_lM + sf_IN); + test("-1705032704T", "" + sf_lM + s_c); + test("-1705032704-42.0", "" + sf_lM + sf_fM); + test("-170503270425", "" + sf_lM + s_b); + test("-1705032704null", "" + sf_lM + f_oN); + test("-1705032704-1410065408", "" + sf_lM + s_lM); + test("-17050327048.0", "" + sf_lM + s_d); + test("-170503270455.0", "" + sf_lM + s_f); + test("-170503270497000000", "" + sf_lM + s_i); + test("-1705032704-9900", "" + sf_lM + f_sM); + test("-1705032704935228928", "" + sf_lM + s_l); + test("-1705032704-8400", "" + sf_lM + sf_sM); + test("-1705032704C(82)", "" + sf_lM + s_o); + test("-1705032704null", "" + sf_lM + sf_oNtS); + test("-1705032704true", "" + sf_lM + s_bl); + test("-17050327043900", "" + sf_lM + s_s); + test("-1705032704null", "" + sf_lM + sf_oN); + test("-170503270494000000", "" + sf_lM + f_I); + test("-1705032704null", "" + sf_lM + f_IN); + test("-1705032704true", "" + sf_lM + sf_bl); + test("-17050327045500", "" + sf_lM + sf_s); + test("-1705032704-2900", "" + sf_lM + s_sM); + test("-1705032704-194313216", "" + sf_lM + sf_l); + test("-170503270412", "" + sf_lM + s_strU1); + test("-1705032704C(87)", "" + sf_lM + sf_o); + test("-170503270491", "" + sf_lM + s_strU2); + test("-170503270421", "" + sf_lM + f_strU1); + test("-170503270418", "" + sf_lM + f_strU2); + test("-1705032704null", "" + sf_lM + f_iAN); + test("-1705032704null", "" + sf_lM + s_oN); + test("-1705032704\u045180", "" + sf_lM + s_strU); + test("-1705032704C", "" + sf_lM + sf_c); + test("-170503270475", "" + sf_lM + sf_str); + test("-1705032704-43", "" + sf_lM + s_bM); + test("-170503270480", "" + sf_lM + sf_b); + test("-1705032704null", "" + sf_lM + s_IN); + test("-1705032704-52.0", "" + sf_lM + s_fM); + test("-170503270475000000", "" + sf_lM + sf_i); + test("-170503270444", "" + sf_lM + f_b); + test("-1705032704-1705032704", "" + sf_lM + sf_lM); + test("-1705032704null", "" + sf_lM + f_oAN); + test("-170503270483.0", "" + sf_lM + f_d); + test("-1705032704I", "" + sf_lM + f_c); + test("-170503270494.0", "" + sf_lM + f_f); + test("-170503270412.0", "" + sf_lM + sf_d); + test("-1705032704-99.0", "" + sf_lM + f_dM); + test("-170503270417.0", "" + sf_lM + sf_f); + test("-1705032704-84.0", "" + sf_lM + sf_dM); + test("-170503270458000000", "" + sf_lM + f_i); + test("-1705032704-55000000", "" + sf_lM + f_iM); + test("-17050327041460392448", "" + sf_lM + f_l); + test("-1705032704C(70)", "" + sf_lM + f_o); + test("-1705032704\u04511", "" + sf_lM + sf_strU); + test("-17050327048000", "" + sf_lM + f_s); + test("-170503270418", "" + sf_lM + s_str); + test("-1705032704-1000000", "" + sf_lM + s_iM); + test("-17050327041000000", "" + sf_lM + sf_I); + test("-1705032704null", "" + sf_lM + f_oNtS); + test("-1705032704false", "" + sf_lM + f_bl); + test("-1705032704null", "" + sf_lM + sf_iAN); + test("-1705032704-2000000", "" + sf_lM + sf_iM); + test("-1705032704-820130816", "" + sf_lM + f_lM); + test("-1705032704null", "" + sf_lM + sf_oAN); + test("-170503270425000000", "" + sf_lM + s_I); + test("null-96.0", "" + f_oAN + s_dM); + test("nullnull", "" + f_oAN + s_oNtS); + test("null\u045176", "" + f_oAN + f_strU); + test("null92", "" + f_oAN + sf_strU2); + test("null51", "" + f_oAN + sf_strU1); + test("nullnull", "" + f_oAN + s_iAN); + test("null-54", "" + f_oAN + f_bM); + test("null-87.0", "" + f_oAN + f_fM); + test("nullnull", "" + f_oAN + s_oAN); + test("null19", "" + f_oAN + f_str); + test("null-41", "" + f_oAN + sf_bM); + test("nullnull", "" + f_oAN + sf_IN); + test("nullT", "" + f_oAN + s_c); + test("null-42.0", "" + f_oAN + sf_fM); + test("null25", "" + f_oAN + s_b); + test("nullnull", "" + f_oAN + f_oN); + test("null-1410065408", "" + f_oAN + s_lM); + test("null8.0", "" + f_oAN + s_d); + test("null55.0", "" + f_oAN + s_f); + test("null97000000", "" + f_oAN + s_i); + test("null-9900", "" + f_oAN + f_sM); + test("null935228928", "" + f_oAN + s_l); + test("null-8400", "" + f_oAN + sf_sM); + test("nullC(82)", "" + f_oAN + s_o); + test("nullnull", "" + f_oAN + sf_oNtS); + test("nulltrue", "" + f_oAN + s_bl); + test("null3900", "" + f_oAN + s_s); + test("nullnull", "" + f_oAN + sf_oN); + test("null94000000", "" + f_oAN + f_I); + test("nullnull", "" + f_oAN + f_IN); + test("nulltrue", "" + f_oAN + sf_bl); + test("null5500", "" + f_oAN + sf_s); + test("null-2900", "" + f_oAN + s_sM); + test("null-194313216", "" + f_oAN + sf_l); + test("null12", "" + f_oAN + s_strU1); + test("nullC(87)", "" + f_oAN + sf_o); + test("null91", "" + f_oAN + s_strU2); + test("null21", "" + f_oAN + f_strU1); + test("null18", "" + f_oAN + f_strU2); + test("nullnull", "" + f_oAN + f_iAN); + test("nullnull", "" + f_oAN + s_oN); + test("null\u045180", "" + f_oAN + s_strU); + test("nullC", "" + f_oAN + sf_c); + test("null75", "" + f_oAN + sf_str); + test("null-43", "" + f_oAN + s_bM); + test("null80", "" + f_oAN + sf_b); + test("nullnull", "" + f_oAN + s_IN); + test("null-52.0", "" + f_oAN + s_fM); + test("null75000000", "" + f_oAN + sf_i); + test("null44", "" + f_oAN + f_b); + test("null-1705032704", "" + f_oAN + sf_lM); + test("nullnull", "" + f_oAN + f_oAN); + test("null83.0", "" + f_oAN + f_d); + test("nullI", "" + f_oAN + f_c); + test("null94.0", "" + f_oAN + f_f); + test("null12.0", "" + f_oAN + sf_d); + test("null-99.0", "" + f_oAN + f_dM); + test("null17.0", "" + f_oAN + sf_f); + test("null-84.0", "" + f_oAN + sf_dM); + test("null58000000", "" + f_oAN + f_i); + test("null-55000000", "" + f_oAN + f_iM); + test("null1460392448", "" + f_oAN + f_l); + test("nullC(70)", "" + f_oAN + f_o); + test("null\u04511", "" + f_oAN + sf_strU); + test("null8000", "" + f_oAN + f_s); + test("null18", "" + f_oAN + s_str); + test("null-1000000", "" + f_oAN + s_iM); + test("null1000000", "" + f_oAN + sf_I); + test("nullnull", "" + f_oAN + f_oNtS); + test("nullfalse", "" + f_oAN + f_bl); + test("nullnull", "" + f_oAN + sf_iAN); + test("null-2000000", "" + f_oAN + sf_iM); + test("null-820130816", "" + f_oAN + f_lM); + test("nullnull", "" + f_oAN + sf_oAN); + test("null25000000", "" + f_oAN + s_I); + test("83.0-96.0", "" + f_d + s_dM); + test("83.0null", "" + f_d + s_oNtS); + test("83.0\u045176", "" + f_d + f_strU); + test("83.092", "" + f_d + sf_strU2); + test("83.051", "" + f_d + sf_strU1); + test("83.0null", "" + f_d + s_iAN); + test("83.0-54", "" + f_d + f_bM); + test("83.0-87.0", "" + f_d + f_fM); + test("83.0null", "" + f_d + s_oAN); + test("83.019", "" + f_d + f_str); + test("83.0-41", "" + f_d + sf_bM); + test("83.0null", "" + f_d + sf_IN); + test("83.0T", "" + f_d + s_c); + test("83.0-42.0", "" + f_d + sf_fM); + test("83.025", "" + f_d + s_b); + test("83.0null", "" + f_d + f_oN); + test("83.0-1410065408", "" + f_d + s_lM); + test("83.08.0", "" + f_d + s_d); + test("83.055.0", "" + f_d + s_f); + test("83.097000000", "" + f_d + s_i); + test("83.0-9900", "" + f_d + f_sM); + test("83.0935228928", "" + f_d + s_l); + test("83.0-8400", "" + f_d + sf_sM); + test("83.0C(82)", "" + f_d + s_o); + test("83.0null", "" + f_d + sf_oNtS); + } + + public void run4() { + test("83.0true", "" + f_d + s_bl); + test("83.03900", "" + f_d + s_s); + test("83.0null", "" + f_d + sf_oN); + test("83.094000000", "" + f_d + f_I); + test("83.0null", "" + f_d + f_IN); + test("83.0true", "" + f_d + sf_bl); + test("83.05500", "" + f_d + sf_s); + test("83.0-2900", "" + f_d + s_sM); + test("83.0-194313216", "" + f_d + sf_l); + test("83.012", "" + f_d + s_strU1); + test("83.0C(87)", "" + f_d + sf_o); + test("83.091", "" + f_d + s_strU2); + test("83.021", "" + f_d + f_strU1); + test("83.018", "" + f_d + f_strU2); + test("83.0null", "" + f_d + f_iAN); + test("83.0null", "" + f_d + s_oN); + test("83.0\u045180", "" + f_d + s_strU); + test("83.0C", "" + f_d + sf_c); + test("83.075", "" + f_d + sf_str); + test("83.0-43", "" + f_d + s_bM); + test("83.080", "" + f_d + sf_b); + test("83.0null", "" + f_d + s_IN); + test("83.0-52.0", "" + f_d + s_fM); + test("83.075000000", "" + f_d + sf_i); + test("83.044", "" + f_d + f_b); + test("83.0-1705032704", "" + f_d + sf_lM); + test("83.0null", "" + f_d + f_oAN); + test("83.083.0", "" + f_d + f_d); + test("83.0I", "" + f_d + f_c); + test("83.094.0", "" + f_d + f_f); + test("83.012.0", "" + f_d + sf_d); + test("83.0-99.0", "" + f_d + f_dM); + test("83.017.0", "" + f_d + sf_f); + test("83.0-84.0", "" + f_d + sf_dM); + test("83.058000000", "" + f_d + f_i); + test("83.0-55000000", "" + f_d + f_iM); + test("83.01460392448", "" + f_d + f_l); + test("83.0C(70)", "" + f_d + f_o); + test("83.0\u04511", "" + f_d + sf_strU); + test("83.08000", "" + f_d + f_s); + test("83.018", "" + f_d + s_str); + test("83.0-1000000", "" + f_d + s_iM); + test("83.01000000", "" + f_d + sf_I); + test("83.0null", "" + f_d + f_oNtS); + test("83.0false", "" + f_d + f_bl); + test("83.0null", "" + f_d + sf_iAN); + test("83.0-2000000", "" + f_d + sf_iM); + test("83.0-820130816", "" + f_d + f_lM); + test("83.0null", "" + f_d + sf_oAN); + test("83.025000000", "" + f_d + s_I); + test("I-96.0", "" + f_c + s_dM); + test("Inull", "" + f_c + s_oNtS); + test("I\u045176", "" + f_c + f_strU); + test("I92", "" + f_c + sf_strU2); + test("I51", "" + f_c + sf_strU1); + test("Inull", "" + f_c + s_iAN); + test("I-54", "" + f_c + f_bM); + test("I-87.0", "" + f_c + f_fM); + test("Inull", "" + f_c + s_oAN); + test("I19", "" + f_c + f_str); + test("I-41", "" + f_c + sf_bM); + test("Inull", "" + f_c + sf_IN); + test("IT", "" + f_c + s_c); + test("I-42.0", "" + f_c + sf_fM); + test("I25", "" + f_c + s_b); + test("Inull", "" + f_c + f_oN); + test("I-1410065408", "" + f_c + s_lM); + test("I8.0", "" + f_c + s_d); + test("I55.0", "" + f_c + s_f); + test("I97000000", "" + f_c + s_i); + test("I-9900", "" + f_c + f_sM); + test("I935228928", "" + f_c + s_l); + test("I-8400", "" + f_c + sf_sM); + test("IC(82)", "" + f_c + s_o); + test("Inull", "" + f_c + sf_oNtS); + test("Itrue", "" + f_c + s_bl); + test("I3900", "" + f_c + s_s); + test("Inull", "" + f_c + sf_oN); + test("I94000000", "" + f_c + f_I); + test("Inull", "" + f_c + f_IN); + test("Itrue", "" + f_c + sf_bl); + test("I5500", "" + f_c + sf_s); + test("I-2900", "" + f_c + s_sM); + test("I-194313216", "" + f_c + sf_l); + test("I12", "" + f_c + s_strU1); + test("IC(87)", "" + f_c + sf_o); + test("I91", "" + f_c + s_strU2); + test("I21", "" + f_c + f_strU1); + test("I18", "" + f_c + f_strU2); + test("Inull", "" + f_c + f_iAN); + test("Inull", "" + f_c + s_oN); + test("I\u045180", "" + f_c + s_strU); + test("IC", "" + f_c + sf_c); + test("I75", "" + f_c + sf_str); + test("I-43", "" + f_c + s_bM); + test("I80", "" + f_c + sf_b); + test("Inull", "" + f_c + s_IN); + test("I-52.0", "" + f_c + s_fM); + test("I75000000", "" + f_c + sf_i); + test("I44", "" + f_c + f_b); + test("I-1705032704", "" + f_c + sf_lM); + test("Inull", "" + f_c + f_oAN); + test("I83.0", "" + f_c + f_d); + test("II", "" + f_c + f_c); + test("I94.0", "" + f_c + f_f); + test("I12.0", "" + f_c + sf_d); + test("I-99.0", "" + f_c + f_dM); + test("I17.0", "" + f_c + sf_f); + test("I-84.0", "" + f_c + sf_dM); + test("I58000000", "" + f_c + f_i); + test("I-55000000", "" + f_c + f_iM); + test("I1460392448", "" + f_c + f_l); + test("IC(70)", "" + f_c + f_o); + test("I\u04511", "" + f_c + sf_strU); + test("I8000", "" + f_c + f_s); + test("I18", "" + f_c + s_str); + test("I-1000000", "" + f_c + s_iM); + test("I1000000", "" + f_c + sf_I); + test("Inull", "" + f_c + f_oNtS); + test("Ifalse", "" + f_c + f_bl); + test("Inull", "" + f_c + sf_iAN); + test("I-2000000", "" + f_c + sf_iM); + test("I-820130816", "" + f_c + f_lM); + test("Inull", "" + f_c + sf_oAN); + test("I25000000", "" + f_c + s_I); + test("94.0-96.0", "" + f_f + s_dM); + test("94.0null", "" + f_f + s_oNtS); + test("94.0\u045176", "" + f_f + f_strU); + test("94.092", "" + f_f + sf_strU2); + test("94.051", "" + f_f + sf_strU1); + test("94.0null", "" + f_f + s_iAN); + test("94.0-54", "" + f_f + f_bM); + test("94.0-87.0", "" + f_f + f_fM); + test("94.0null", "" + f_f + s_oAN); + test("94.019", "" + f_f + f_str); + test("94.0-41", "" + f_f + sf_bM); + test("94.0null", "" + f_f + sf_IN); + test("94.0T", "" + f_f + s_c); + test("94.0-42.0", "" + f_f + sf_fM); + test("94.025", "" + f_f + s_b); + test("94.0null", "" + f_f + f_oN); + test("94.0-1410065408", "" + f_f + s_lM); + test("94.08.0", "" + f_f + s_d); + test("94.055.0", "" + f_f + s_f); + test("94.097000000", "" + f_f + s_i); + test("94.0-9900", "" + f_f + f_sM); + test("94.0935228928", "" + f_f + s_l); + test("94.0-8400", "" + f_f + sf_sM); + test("94.0C(82)", "" + f_f + s_o); + test("94.0null", "" + f_f + sf_oNtS); + test("94.0true", "" + f_f + s_bl); + test("94.03900", "" + f_f + s_s); + test("94.0null", "" + f_f + sf_oN); + test("94.094000000", "" + f_f + f_I); + test("94.0null", "" + f_f + f_IN); + test("94.0true", "" + f_f + sf_bl); + test("94.05500", "" + f_f + sf_s); + test("94.0-2900", "" + f_f + s_sM); + test("94.0-194313216", "" + f_f + sf_l); + test("94.012", "" + f_f + s_strU1); + test("94.0C(87)", "" + f_f + sf_o); + test("94.091", "" + f_f + s_strU2); + test("94.021", "" + f_f + f_strU1); + test("94.018", "" + f_f + f_strU2); + test("94.0null", "" + f_f + f_iAN); + test("94.0null", "" + f_f + s_oN); + test("94.0\u045180", "" + f_f + s_strU); + test("94.0C", "" + f_f + sf_c); + test("94.075", "" + f_f + sf_str); + test("94.0-43", "" + f_f + s_bM); + test("94.080", "" + f_f + sf_b); + test("94.0null", "" + f_f + s_IN); + test("94.0-52.0", "" + f_f + s_fM); + test("94.075000000", "" + f_f + sf_i); + test("94.044", "" + f_f + f_b); + test("94.0-1705032704", "" + f_f + sf_lM); + test("94.0null", "" + f_f + f_oAN); + test("94.083.0", "" + f_f + f_d); + test("94.0I", "" + f_f + f_c); + test("94.094.0", "" + f_f + f_f); + test("94.012.0", "" + f_f + sf_d); + test("94.0-99.0", "" + f_f + f_dM); + test("94.017.0", "" + f_f + sf_f); + test("94.0-84.0", "" + f_f + sf_dM); + test("94.058000000", "" + f_f + f_i); + test("94.0-55000000", "" + f_f + f_iM); + test("94.01460392448", "" + f_f + f_l); + test("94.0C(70)", "" + f_f + f_o); + test("94.0\u04511", "" + f_f + sf_strU); + test("94.08000", "" + f_f + f_s); + test("94.018", "" + f_f + s_str); + test("94.0-1000000", "" + f_f + s_iM); + test("94.01000000", "" + f_f + sf_I); + test("94.0null", "" + f_f + f_oNtS); + test("94.0false", "" + f_f + f_bl); + test("94.0null", "" + f_f + sf_iAN); + test("94.0-2000000", "" + f_f + sf_iM); + test("94.0-820130816", "" + f_f + f_lM); + test("94.0null", "" + f_f + sf_oAN); + test("94.025000000", "" + f_f + s_I); + test("12.0-96.0", "" + sf_d + s_dM); + test("12.0null", "" + sf_d + s_oNtS); + test("12.0\u045176", "" + sf_d + f_strU); + test("12.092", "" + sf_d + sf_strU2); + test("12.051", "" + sf_d + sf_strU1); + test("12.0null", "" + sf_d + s_iAN); + test("12.0-54", "" + sf_d + f_bM); + test("12.0-87.0", "" + sf_d + f_fM); + test("12.0null", "" + sf_d + s_oAN); + test("12.019", "" + sf_d + f_str); + test("12.0-41", "" + sf_d + sf_bM); + test("12.0null", "" + sf_d + sf_IN); + test("12.0T", "" + sf_d + s_c); + test("12.0-42.0", "" + sf_d + sf_fM); + test("12.025", "" + sf_d + s_b); + test("12.0null", "" + sf_d + f_oN); + test("12.0-1410065408", "" + sf_d + s_lM); + test("12.08.0", "" + sf_d + s_d); + test("12.055.0", "" + sf_d + s_f); + test("12.097000000", "" + sf_d + s_i); + test("12.0-9900", "" + sf_d + f_sM); + test("12.0935228928", "" + sf_d + s_l); + test("12.0-8400", "" + sf_d + sf_sM); + test("12.0C(82)", "" + sf_d + s_o); + test("12.0null", "" + sf_d + sf_oNtS); + test("12.0true", "" + sf_d + s_bl); + test("12.03900", "" + sf_d + s_s); + test("12.0null", "" + sf_d + sf_oN); + test("12.094000000", "" + sf_d + f_I); + test("12.0null", "" + sf_d + f_IN); + test("12.0true", "" + sf_d + sf_bl); + test("12.05500", "" + sf_d + sf_s); + test("12.0-2900", "" + sf_d + s_sM); + test("12.0-194313216", "" + sf_d + sf_l); + test("12.012", "" + sf_d + s_strU1); + test("12.0C(87)", "" + sf_d + sf_o); + test("12.091", "" + sf_d + s_strU2); + test("12.021", "" + sf_d + f_strU1); + test("12.018", "" + sf_d + f_strU2); + test("12.0null", "" + sf_d + f_iAN); + test("12.0null", "" + sf_d + s_oN); + test("12.0\u045180", "" + sf_d + s_strU); + test("12.0C", "" + sf_d + sf_c); + test("12.075", "" + sf_d + sf_str); + test("12.0-43", "" + sf_d + s_bM); + test("12.080", "" + sf_d + sf_b); + test("12.0null", "" + sf_d + s_IN); + test("12.0-52.0", "" + sf_d + s_fM); + test("12.075000000", "" + sf_d + sf_i); + test("12.044", "" + sf_d + f_b); + test("12.0-1705032704", "" + sf_d + sf_lM); + test("12.0null", "" + sf_d + f_oAN); + test("12.083.0", "" + sf_d + f_d); + test("12.0I", "" + sf_d + f_c); + test("12.094.0", "" + sf_d + f_f); + test("12.012.0", "" + sf_d + sf_d); + test("12.0-99.0", "" + sf_d + f_dM); + test("12.017.0", "" + sf_d + sf_f); + test("12.0-84.0", "" + sf_d + sf_dM); + test("12.058000000", "" + sf_d + f_i); + test("12.0-55000000", "" + sf_d + f_iM); + test("12.01460392448", "" + sf_d + f_l); + test("12.0C(70)", "" + sf_d + f_o); + test("12.0\u04511", "" + sf_d + sf_strU); + test("12.08000", "" + sf_d + f_s); + test("12.018", "" + sf_d + s_str); + test("12.0-1000000", "" + sf_d + s_iM); + test("12.01000000", "" + sf_d + sf_I); + test("12.0null", "" + sf_d + f_oNtS); + test("12.0false", "" + sf_d + f_bl); + test("12.0null", "" + sf_d + sf_iAN); + test("12.0-2000000", "" + sf_d + sf_iM); + test("12.0-820130816", "" + sf_d + f_lM); + test("12.0null", "" + sf_d + sf_oAN); + test("12.025000000", "" + sf_d + s_I); + test("-99.0-96.0", "" + f_dM + s_dM); + test("-99.0null", "" + f_dM + s_oNtS); + test("-99.0\u045176", "" + f_dM + f_strU); + test("-99.092", "" + f_dM + sf_strU2); + test("-99.051", "" + f_dM + sf_strU1); + test("-99.0null", "" + f_dM + s_iAN); + test("-99.0-54", "" + f_dM + f_bM); + test("-99.0-87.0", "" + f_dM + f_fM); + test("-99.0null", "" + f_dM + s_oAN); + test("-99.019", "" + f_dM + f_str); + test("-99.0-41", "" + f_dM + sf_bM); + test("-99.0null", "" + f_dM + sf_IN); + test("-99.0T", "" + f_dM + s_c); + test("-99.0-42.0", "" + f_dM + sf_fM); + test("-99.025", "" + f_dM + s_b); + test("-99.0null", "" + f_dM + f_oN); + test("-99.0-1410065408", "" + f_dM + s_lM); + test("-99.08.0", "" + f_dM + s_d); + test("-99.055.0", "" + f_dM + s_f); + test("-99.097000000", "" + f_dM + s_i); + test("-99.0-9900", "" + f_dM + f_sM); + test("-99.0935228928", "" + f_dM + s_l); + test("-99.0-8400", "" + f_dM + sf_sM); + test("-99.0C(82)", "" + f_dM + s_o); + test("-99.0null", "" + f_dM + sf_oNtS); + test("-99.0true", "" + f_dM + s_bl); + test("-99.03900", "" + f_dM + s_s); + test("-99.0null", "" + f_dM + sf_oN); + test("-99.094000000", "" + f_dM + f_I); + test("-99.0null", "" + f_dM + f_IN); + test("-99.0true", "" + f_dM + sf_bl); + test("-99.05500", "" + f_dM + sf_s); + test("-99.0-2900", "" + f_dM + s_sM); + test("-99.0-194313216", "" + f_dM + sf_l); + test("-99.012", "" + f_dM + s_strU1); + test("-99.0C(87)", "" + f_dM + sf_o); + test("-99.091", "" + f_dM + s_strU2); + test("-99.021", "" + f_dM + f_strU1); + test("-99.018", "" + f_dM + f_strU2); + test("-99.0null", "" + f_dM + f_iAN); + test("-99.0null", "" + f_dM + s_oN); + test("-99.0\u045180", "" + f_dM + s_strU); + test("-99.0C", "" + f_dM + sf_c); + test("-99.075", "" + f_dM + sf_str); + test("-99.0-43", "" + f_dM + s_bM); + test("-99.080", "" + f_dM + sf_b); + test("-99.0null", "" + f_dM + s_IN); + test("-99.0-52.0", "" + f_dM + s_fM); + test("-99.075000000", "" + f_dM + sf_i); + test("-99.044", "" + f_dM + f_b); + test("-99.0-1705032704", "" + f_dM + sf_lM); + test("-99.0null", "" + f_dM + f_oAN); + test("-99.083.0", "" + f_dM + f_d); + test("-99.0I", "" + f_dM + f_c); + test("-99.094.0", "" + f_dM + f_f); + test("-99.012.0", "" + f_dM + sf_d); + test("-99.0-99.0", "" + f_dM + f_dM); + test("-99.017.0", "" + f_dM + sf_f); + test("-99.0-84.0", "" + f_dM + sf_dM); + test("-99.058000000", "" + f_dM + f_i); + test("-99.0-55000000", "" + f_dM + f_iM); + test("-99.01460392448", "" + f_dM + f_l); + test("-99.0C(70)", "" + f_dM + f_o); + test("-99.0\u04511", "" + f_dM + sf_strU); + test("-99.08000", "" + f_dM + f_s); + test("-99.018", "" + f_dM + s_str); + test("-99.0-1000000", "" + f_dM + s_iM); + test("-99.01000000", "" + f_dM + sf_I); + test("-99.0null", "" + f_dM + f_oNtS); + test("-99.0false", "" + f_dM + f_bl); + test("-99.0null", "" + f_dM + sf_iAN); + test("-99.0-2000000", "" + f_dM + sf_iM); + test("-99.0-820130816", "" + f_dM + f_lM); + test("-99.0null", "" + f_dM + sf_oAN); + test("-99.025000000", "" + f_dM + s_I); + test("17.0-96.0", "" + sf_f + s_dM); + test("17.0null", "" + sf_f + s_oNtS); + test("17.0\u045176", "" + sf_f + f_strU); + test("17.092", "" + sf_f + sf_strU2); + test("17.051", "" + sf_f + sf_strU1); + test("17.0null", "" + sf_f + s_iAN); + test("17.0-54", "" + sf_f + f_bM); + test("17.0-87.0", "" + sf_f + f_fM); + test("17.0null", "" + sf_f + s_oAN); + test("17.019", "" + sf_f + f_str); + test("17.0-41", "" + sf_f + sf_bM); + test("17.0null", "" + sf_f + sf_IN); + test("17.0T", "" + sf_f + s_c); + test("17.0-42.0", "" + sf_f + sf_fM); + test("17.025", "" + sf_f + s_b); + test("17.0null", "" + sf_f + f_oN); + test("17.0-1410065408", "" + sf_f + s_lM); + test("17.08.0", "" + sf_f + s_d); + test("17.055.0", "" + sf_f + s_f); + test("17.097000000", "" + sf_f + s_i); + test("17.0-9900", "" + sf_f + f_sM); + test("17.0935228928", "" + sf_f + s_l); + test("17.0-8400", "" + sf_f + sf_sM); + test("17.0C(82)", "" + sf_f + s_o); + test("17.0null", "" + sf_f + sf_oNtS); + test("17.0true", "" + sf_f + s_bl); + test("17.03900", "" + sf_f + s_s); + test("17.0null", "" + sf_f + sf_oN); + test("17.094000000", "" + sf_f + f_I); + test("17.0null", "" + sf_f + f_IN); + test("17.0true", "" + sf_f + sf_bl); + test("17.05500", "" + sf_f + sf_s); + test("17.0-2900", "" + sf_f + s_sM); + test("17.0-194313216", "" + sf_f + sf_l); + test("17.012", "" + sf_f + s_strU1); + test("17.0C(87)", "" + sf_f + sf_o); + test("17.091", "" + sf_f + s_strU2); + test("17.021", "" + sf_f + f_strU1); + test("17.018", "" + sf_f + f_strU2); + test("17.0null", "" + sf_f + f_iAN); + test("17.0null", "" + sf_f + s_oN); + test("17.0\u045180", "" + sf_f + s_strU); + test("17.0C", "" + sf_f + sf_c); + test("17.075", "" + sf_f + sf_str); + test("17.0-43", "" + sf_f + s_bM); + test("17.080", "" + sf_f + sf_b); + test("17.0null", "" + sf_f + s_IN); + test("17.0-52.0", "" + sf_f + s_fM); + test("17.075000000", "" + sf_f + sf_i); + test("17.044", "" + sf_f + f_b); + test("17.0-1705032704", "" + sf_f + sf_lM); + test("17.0null", "" + sf_f + f_oAN); + test("17.083.0", "" + sf_f + f_d); + test("17.0I", "" + sf_f + f_c); + test("17.094.0", "" + sf_f + f_f); + test("17.012.0", "" + sf_f + sf_d); + test("17.0-99.0", "" + sf_f + f_dM); + test("17.017.0", "" + sf_f + sf_f); + test("17.0-84.0", "" + sf_f + sf_dM); + test("17.058000000", "" + sf_f + f_i); + test("17.0-55000000", "" + sf_f + f_iM); + test("17.01460392448", "" + sf_f + f_l); + test("17.0C(70)", "" + sf_f + f_o); + test("17.0\u04511", "" + sf_f + sf_strU); + test("17.08000", "" + sf_f + f_s); + test("17.018", "" + sf_f + s_str); + test("17.0-1000000", "" + sf_f + s_iM); + test("17.01000000", "" + sf_f + sf_I); + test("17.0null", "" + sf_f + f_oNtS); + test("17.0false", "" + sf_f + f_bl); + test("17.0null", "" + sf_f + sf_iAN); + test("17.0-2000000", "" + sf_f + sf_iM); + test("17.0-820130816", "" + sf_f + f_lM); + test("17.0null", "" + sf_f + sf_oAN); + test("17.025000000", "" + sf_f + s_I); + test("-84.0-96.0", "" + sf_dM + s_dM); + test("-84.0null", "" + sf_dM + s_oNtS); + test("-84.0\u045176", "" + sf_dM + f_strU); + test("-84.092", "" + sf_dM + sf_strU2); + test("-84.051", "" + sf_dM + sf_strU1); + test("-84.0null", "" + sf_dM + s_iAN); + test("-84.0-54", "" + sf_dM + f_bM); + test("-84.0-87.0", "" + sf_dM + f_fM); + test("-84.0null", "" + sf_dM + s_oAN); + test("-84.019", "" + sf_dM + f_str); + test("-84.0-41", "" + sf_dM + sf_bM); + test("-84.0null", "" + sf_dM + sf_IN); + test("-84.0T", "" + sf_dM + s_c); + test("-84.0-42.0", "" + sf_dM + sf_fM); + test("-84.025", "" + sf_dM + s_b); + test("-84.0null", "" + sf_dM + f_oN); + test("-84.0-1410065408", "" + sf_dM + s_lM); + test("-84.08.0", "" + sf_dM + s_d); + test("-84.055.0", "" + sf_dM + s_f); + test("-84.097000000", "" + sf_dM + s_i); + test("-84.0-9900", "" + sf_dM + f_sM); + test("-84.0935228928", "" + sf_dM + s_l); + test("-84.0-8400", "" + sf_dM + sf_sM); + test("-84.0C(82)", "" + sf_dM + s_o); + test("-84.0null", "" + sf_dM + sf_oNtS); + test("-84.0true", "" + sf_dM + s_bl); + test("-84.03900", "" + sf_dM + s_s); + test("-84.0null", "" + sf_dM + sf_oN); + test("-84.094000000", "" + sf_dM + f_I); + test("-84.0null", "" + sf_dM + f_IN); + test("-84.0true", "" + sf_dM + sf_bl); + test("-84.05500", "" + sf_dM + sf_s); + test("-84.0-2900", "" + sf_dM + s_sM); + test("-84.0-194313216", "" + sf_dM + sf_l); + test("-84.012", "" + sf_dM + s_strU1); + test("-84.0C(87)", "" + sf_dM + sf_o); + test("-84.091", "" + sf_dM + s_strU2); + test("-84.021", "" + sf_dM + f_strU1); + test("-84.018", "" + sf_dM + f_strU2); + test("-84.0null", "" + sf_dM + f_iAN); + test("-84.0null", "" + sf_dM + s_oN); + test("-84.0\u045180", "" + sf_dM + s_strU); + test("-84.0C", "" + sf_dM + sf_c); + test("-84.075", "" + sf_dM + sf_str); + test("-84.0-43", "" + sf_dM + s_bM); + test("-84.080", "" + sf_dM + sf_b); + test("-84.0null", "" + sf_dM + s_IN); + test("-84.0-52.0", "" + sf_dM + s_fM); + test("-84.075000000", "" + sf_dM + sf_i); + test("-84.044", "" + sf_dM + f_b); + test("-84.0-1705032704", "" + sf_dM + sf_lM); + test("-84.0null", "" + sf_dM + f_oAN); + test("-84.083.0", "" + sf_dM + f_d); + test("-84.0I", "" + sf_dM + f_c); + test("-84.094.0", "" + sf_dM + f_f); + test("-84.012.0", "" + sf_dM + sf_d); + test("-84.0-99.0", "" + sf_dM + f_dM); + test("-84.017.0", "" + sf_dM + sf_f); + test("-84.0-84.0", "" + sf_dM + sf_dM); + test("-84.058000000", "" + sf_dM + f_i); + test("-84.0-55000000", "" + sf_dM + f_iM); + test("-84.01460392448", "" + sf_dM + f_l); + test("-84.0C(70)", "" + sf_dM + f_o); + test("-84.0\u04511", "" + sf_dM + sf_strU); + test("-84.08000", "" + sf_dM + f_s); + test("-84.018", "" + sf_dM + s_str); + test("-84.0-1000000", "" + sf_dM + s_iM); + test("-84.01000000", "" + sf_dM + sf_I); + test("-84.0null", "" + sf_dM + f_oNtS); + test("-84.0false", "" + sf_dM + f_bl); + test("-84.0null", "" + sf_dM + sf_iAN); + test("-84.0-2000000", "" + sf_dM + sf_iM); + test("-84.0-820130816", "" + sf_dM + f_lM); + test("-84.0null", "" + sf_dM + sf_oAN); + test("-84.025000000", "" + sf_dM + s_I); + test("58000000-96.0", "" + f_i + s_dM); + test("58000000null", "" + f_i + s_oNtS); + test("58000000\u045176", "" + f_i + f_strU); + test("5800000092", "" + f_i + sf_strU2); + test("5800000051", "" + f_i + sf_strU1); + test("58000000null", "" + f_i + s_iAN); + test("58000000-54", "" + f_i + f_bM); + test("58000000-87.0", "" + f_i + f_fM); + test("58000000null", "" + f_i + s_oAN); + test("5800000019", "" + f_i + f_str); + test("58000000-41", "" + f_i + sf_bM); + test("58000000null", "" + f_i + sf_IN); + test("58000000T", "" + f_i + s_c); + test("58000000-42.0", "" + f_i + sf_fM); + test("5800000025", "" + f_i + s_b); + test("58000000null", "" + f_i + f_oN); + test("58000000-1410065408", "" + f_i + s_lM); + test("580000008.0", "" + f_i + s_d); + test("5800000055.0", "" + f_i + s_f); + test("5800000097000000", "" + f_i + s_i); + test("58000000-9900", "" + f_i + f_sM); + test("58000000935228928", "" + f_i + s_l); + test("58000000-8400", "" + f_i + sf_sM); + test("58000000C(82)", "" + f_i + s_o); + test("58000000null", "" + f_i + sf_oNtS); + test("58000000true", "" + f_i + s_bl); + test("580000003900", "" + f_i + s_s); + test("58000000null", "" + f_i + sf_oN); + test("5800000094000000", "" + f_i + f_I); + test("58000000null", "" + f_i + f_IN); + test("58000000true", "" + f_i + sf_bl); + test("580000005500", "" + f_i + sf_s); + test("58000000-2900", "" + f_i + s_sM); + test("58000000-194313216", "" + f_i + sf_l); + test("5800000012", "" + f_i + s_strU1); + test("58000000C(87)", "" + f_i + sf_o); + test("5800000091", "" + f_i + s_strU2); + test("5800000021", "" + f_i + f_strU1); + test("5800000018", "" + f_i + f_strU2); + test("58000000null", "" + f_i + f_iAN); + test("58000000null", "" + f_i + s_oN); + test("58000000\u045180", "" + f_i + s_strU); + test("58000000C", "" + f_i + sf_c); + test("5800000075", "" + f_i + sf_str); + test("58000000-43", "" + f_i + s_bM); + test("5800000080", "" + f_i + sf_b); + test("58000000null", "" + f_i + s_IN); + test("58000000-52.0", "" + f_i + s_fM); + test("5800000075000000", "" + f_i + sf_i); + test("5800000044", "" + f_i + f_b); + test("58000000-1705032704", "" + f_i + sf_lM); + test("58000000null", "" + f_i + f_oAN); + test("5800000083.0", "" + f_i + f_d); + test("58000000I", "" + f_i + f_c); + test("5800000094.0", "" + f_i + f_f); + test("5800000012.0", "" + f_i + sf_d); + test("58000000-99.0", "" + f_i + f_dM); + test("5800000017.0", "" + f_i + sf_f); + test("58000000-84.0", "" + f_i + sf_dM); + test("5800000058000000", "" + f_i + f_i); + test("58000000-55000000", "" + f_i + f_iM); + test("580000001460392448", "" + f_i + f_l); + test("58000000C(70)", "" + f_i + f_o); + test("58000000\u04511", "" + f_i + sf_strU); + test("580000008000", "" + f_i + f_s); + test("5800000018", "" + f_i + s_str); + test("58000000-1000000", "" + f_i + s_iM); + test("580000001000000", "" + f_i + sf_I); + test("58000000null", "" + f_i + f_oNtS); + test("58000000false", "" + f_i + f_bl); + test("58000000null", "" + f_i + sf_iAN); + test("58000000-2000000", "" + f_i + sf_iM); + test("58000000-820130816", "" + f_i + f_lM); + test("58000000null", "" + f_i + sf_oAN); + test("5800000025000000", "" + f_i + s_I); + test("-55000000-96.0", "" + f_iM + s_dM); + test("-55000000null", "" + f_iM + s_oNtS); + test("-55000000\u045176", "" + f_iM + f_strU); + test("-5500000092", "" + f_iM + sf_strU2); + test("-5500000051", "" + f_iM + sf_strU1); + test("-55000000null", "" + f_iM + s_iAN); + test("-55000000-54", "" + f_iM + f_bM); + test("-55000000-87.0", "" + f_iM + f_fM); + test("-55000000null", "" + f_iM + s_oAN); + test("-5500000019", "" + f_iM + f_str); + test("-55000000-41", "" + f_iM + sf_bM); + test("-55000000null", "" + f_iM + sf_IN); + test("-55000000T", "" + f_iM + s_c); + test("-55000000-42.0", "" + f_iM + sf_fM); + test("-5500000025", "" + f_iM + s_b); + test("-55000000null", "" + f_iM + f_oN); + test("-55000000-1410065408", "" + f_iM + s_lM); + test("-550000008.0", "" + f_iM + s_d); + test("-5500000055.0", "" + f_iM + s_f); + test("-5500000097000000", "" + f_iM + s_i); + test("-55000000-9900", "" + f_iM + f_sM); + test("-55000000935228928", "" + f_iM + s_l); + test("-55000000-8400", "" + f_iM + sf_sM); + test("-55000000C(82)", "" + f_iM + s_o); + test("-55000000null", "" + f_iM + sf_oNtS); + test("-55000000true", "" + f_iM + s_bl); + test("-550000003900", "" + f_iM + s_s); + test("-55000000null", "" + f_iM + sf_oN); + test("-5500000094000000", "" + f_iM + f_I); + test("-55000000null", "" + f_iM + f_IN); + test("-55000000true", "" + f_iM + sf_bl); + test("-550000005500", "" + f_iM + sf_s); + test("-55000000-2900", "" + f_iM + s_sM); + test("-55000000-194313216", "" + f_iM + sf_l); + test("-5500000012", "" + f_iM + s_strU1); + test("-55000000C(87)", "" + f_iM + sf_o); + test("-5500000091", "" + f_iM + s_strU2); + test("-5500000021", "" + f_iM + f_strU1); + test("-5500000018", "" + f_iM + f_strU2); + test("-55000000null", "" + f_iM + f_iAN); + test("-55000000null", "" + f_iM + s_oN); + test("-55000000\u045180", "" + f_iM + s_strU); + test("-55000000C", "" + f_iM + sf_c); + test("-5500000075", "" + f_iM + sf_str); + test("-55000000-43", "" + f_iM + s_bM); + test("-5500000080", "" + f_iM + sf_b); + test("-55000000null", "" + f_iM + s_IN); + test("-55000000-52.0", "" + f_iM + s_fM); + test("-5500000075000000", "" + f_iM + sf_i); + test("-5500000044", "" + f_iM + f_b); + test("-55000000-1705032704", "" + f_iM + sf_lM); + test("-55000000null", "" + f_iM + f_oAN); + test("-5500000083.0", "" + f_iM + f_d); + test("-55000000I", "" + f_iM + f_c); + test("-5500000094.0", "" + f_iM + f_f); + test("-5500000012.0", "" + f_iM + sf_d); + test("-55000000-99.0", "" + f_iM + f_dM); + test("-5500000017.0", "" + f_iM + sf_f); + test("-55000000-84.0", "" + f_iM + sf_dM); + test("-5500000058000000", "" + f_iM + f_i); + test("-55000000-55000000", "" + f_iM + f_iM); + test("-550000001460392448", "" + f_iM + f_l); + test("-55000000C(70)", "" + f_iM + f_o); + test("-55000000\u04511", "" + f_iM + sf_strU); + test("-550000008000", "" + f_iM + f_s); + test("-5500000018", "" + f_iM + s_str); + test("-55000000-1000000", "" + f_iM + s_iM); + test("-550000001000000", "" + f_iM + sf_I); + test("-55000000null", "" + f_iM + f_oNtS); + test("-55000000false", "" + f_iM + f_bl); + test("-55000000null", "" + f_iM + sf_iAN); + test("-55000000-2000000", "" + f_iM + sf_iM); + test("-55000000-820130816", "" + f_iM + f_lM); + test("-55000000null", "" + f_iM + sf_oAN); + test("-5500000025000000", "" + f_iM + s_I); + test("1460392448-96.0", "" + f_l + s_dM); + test("1460392448null", "" + f_l + s_oNtS); + test("1460392448\u045176", "" + f_l + f_strU); + test("146039244892", "" + f_l + sf_strU2); + test("146039244851", "" + f_l + sf_strU1); + test("1460392448null", "" + f_l + s_iAN); + test("1460392448-54", "" + f_l + f_bM); + test("1460392448-87.0", "" + f_l + f_fM); + test("1460392448null", "" + f_l + s_oAN); + test("146039244819", "" + f_l + f_str); + test("1460392448-41", "" + f_l + sf_bM); + test("1460392448null", "" + f_l + sf_IN); + test("1460392448T", "" + f_l + s_c); + test("1460392448-42.0", "" + f_l + sf_fM); + test("146039244825", "" + f_l + s_b); + test("1460392448null", "" + f_l + f_oN); + test("1460392448-1410065408", "" + f_l + s_lM); + test("14603924488.0", "" + f_l + s_d); + test("146039244855.0", "" + f_l + s_f); + test("146039244897000000", "" + f_l + s_i); + test("1460392448-9900", "" + f_l + f_sM); + test("1460392448935228928", "" + f_l + s_l); + test("1460392448-8400", "" + f_l + sf_sM); + test("1460392448C(82)", "" + f_l + s_o); + test("1460392448null", "" + f_l + sf_oNtS); + test("1460392448true", "" + f_l + s_bl); + test("14603924483900", "" + f_l + s_s); + test("1460392448null", "" + f_l + sf_oN); + test("146039244894000000", "" + f_l + f_I); + test("1460392448null", "" + f_l + f_IN); + test("1460392448true", "" + f_l + sf_bl); + test("14603924485500", "" + f_l + sf_s); + test("1460392448-2900", "" + f_l + s_sM); + test("1460392448-194313216", "" + f_l + sf_l); + test("146039244812", "" + f_l + s_strU1); + test("1460392448C(87)", "" + f_l + sf_o); + test("146039244891", "" + f_l + s_strU2); + test("146039244821", "" + f_l + f_strU1); + test("146039244818", "" + f_l + f_strU2); + test("1460392448null", "" + f_l + f_iAN); + test("1460392448null", "" + f_l + s_oN); + test("1460392448\u045180", "" + f_l + s_strU); + test("1460392448C", "" + f_l + sf_c); + test("146039244875", "" + f_l + sf_str); + test("1460392448-43", "" + f_l + s_bM); + test("146039244880", "" + f_l + sf_b); + test("1460392448null", "" + f_l + s_IN); + test("1460392448-52.0", "" + f_l + s_fM); + test("146039244875000000", "" + f_l + sf_i); + test("146039244844", "" + f_l + f_b); + test("1460392448-1705032704", "" + f_l + sf_lM); + test("1460392448null", "" + f_l + f_oAN); + test("146039244883.0", "" + f_l + f_d); + test("1460392448I", "" + f_l + f_c); + test("146039244894.0", "" + f_l + f_f); + test("146039244812.0", "" + f_l + sf_d); + test("1460392448-99.0", "" + f_l + f_dM); + test("146039244817.0", "" + f_l + sf_f); + test("1460392448-84.0", "" + f_l + sf_dM); + test("146039244858000000", "" + f_l + f_i); + test("1460392448-55000000", "" + f_l + f_iM); + test("14603924481460392448", "" + f_l + f_l); + test("1460392448C(70)", "" + f_l + f_o); + test("1460392448\u04511", "" + f_l + sf_strU); + test("14603924488000", "" + f_l + f_s); + test("146039244818", "" + f_l + s_str); + test("1460392448-1000000", "" + f_l + s_iM); + test("14603924481000000", "" + f_l + sf_I); + test("1460392448null", "" + f_l + f_oNtS); + test("1460392448false", "" + f_l + f_bl); + test("1460392448null", "" + f_l + sf_iAN); + test("1460392448-2000000", "" + f_l + sf_iM); + test("1460392448-820130816", "" + f_l + f_lM); + test("1460392448null", "" + f_l + sf_oAN); + test("146039244825000000", "" + f_l + s_I); + test("C(70)-96.0", "" + f_o + s_dM); + test("C(70)null", "" + f_o + s_oNtS); + test("C(70)\u045176", "" + f_o + f_strU); + test("C(70)92", "" + f_o + sf_strU2); + test("C(70)51", "" + f_o + sf_strU1); + test("C(70)null", "" + f_o + s_iAN); + test("C(70)-54", "" + f_o + f_bM); + test("C(70)-87.0", "" + f_o + f_fM); + test("C(70)null", "" + f_o + s_oAN); + test("C(70)19", "" + f_o + f_str); + test("C(70)-41", "" + f_o + sf_bM); + test("C(70)null", "" + f_o + sf_IN); + test("C(70)T", "" + f_o + s_c); + test("C(70)-42.0", "" + f_o + sf_fM); + test("C(70)25", "" + f_o + s_b); + test("C(70)null", "" + f_o + f_oN); + test("C(70)-1410065408", "" + f_o + s_lM); + test("C(70)8.0", "" + f_o + s_d); + test("C(70)55.0", "" + f_o + s_f); + test("C(70)97000000", "" + f_o + s_i); + test("C(70)-9900", "" + f_o + f_sM); + test("C(70)935228928", "" + f_o + s_l); + test("C(70)-8400", "" + f_o + sf_sM); + test("C(70)C(82)", "" + f_o + s_o); + test("C(70)null", "" + f_o + sf_oNtS); + test("C(70)true", "" + f_o + s_bl); + test("C(70)3900", "" + f_o + s_s); + test("C(70)null", "" + f_o + sf_oN); + test("C(70)94000000", "" + f_o + f_I); + test("C(70)null", "" + f_o + f_IN); + test("C(70)true", "" + f_o + sf_bl); + test("C(70)5500", "" + f_o + sf_s); + test("C(70)-2900", "" + f_o + s_sM); + test("C(70)-194313216", "" + f_o + sf_l); + test("C(70)12", "" + f_o + s_strU1); + test("C(70)C(87)", "" + f_o + sf_o); + test("C(70)91", "" + f_o + s_strU2); + test("C(70)21", "" + f_o + f_strU1); + test("C(70)18", "" + f_o + f_strU2); + test("C(70)null", "" + f_o + f_iAN); + test("C(70)null", "" + f_o + s_oN); + test("C(70)\u045180", "" + f_o + s_strU); + test("C(70)C", "" + f_o + sf_c); + test("C(70)75", "" + f_o + sf_str); + test("C(70)-43", "" + f_o + s_bM); + test("C(70)80", "" + f_o + sf_b); + test("C(70)null", "" + f_o + s_IN); + test("C(70)-52.0", "" + f_o + s_fM); + test("C(70)75000000", "" + f_o + sf_i); + test("C(70)44", "" + f_o + f_b); + test("C(70)-1705032704", "" + f_o + sf_lM); + test("C(70)null", "" + f_o + f_oAN); + test("C(70)83.0", "" + f_o + f_d); + test("C(70)I", "" + f_o + f_c); + test("C(70)94.0", "" + f_o + f_f); + test("C(70)12.0", "" + f_o + sf_d); + test("C(70)-99.0", "" + f_o + f_dM); + test("C(70)17.0", "" + f_o + sf_f); + test("C(70)-84.0", "" + f_o + sf_dM); + test("C(70)58000000", "" + f_o + f_i); + test("C(70)-55000000", "" + f_o + f_iM); + test("C(70)1460392448", "" + f_o + f_l); + test("C(70)C(70)", "" + f_o + f_o); + test("C(70)\u04511", "" + f_o + sf_strU); + test("C(70)8000", "" + f_o + f_s); + test("C(70)18", "" + f_o + s_str); + test("C(70)-1000000", "" + f_o + s_iM); + test("C(70)1000000", "" + f_o + sf_I); + test("C(70)null", "" + f_o + f_oNtS); + test("C(70)false", "" + f_o + f_bl); + test("C(70)null", "" + f_o + sf_iAN); + test("C(70)-2000000", "" + f_o + sf_iM); + test("C(70)-820130816", "" + f_o + f_lM); + test("C(70)null", "" + f_o + sf_oAN); + test("C(70)25000000", "" + f_o + s_I); + test("\u04511-96.0", "" + sf_strU + s_dM); + test("\u04511null", "" + sf_strU + s_oNtS); + test("\u04511\u045176", "" + sf_strU + f_strU); + test("\u0451192", "" + sf_strU + sf_strU2); + test("\u0451151", "" + sf_strU + sf_strU1); + test("\u04511null", "" + sf_strU + s_iAN); + test("\u04511-54", "" + sf_strU + f_bM); + test("\u04511-87.0", "" + sf_strU + f_fM); + test("\u04511null", "" + sf_strU + s_oAN); + test("\u0451119", "" + sf_strU + f_str); + test("\u04511-41", "" + sf_strU + sf_bM); + test("\u04511null", "" + sf_strU + sf_IN); + test("\u04511T", "" + sf_strU + s_c); + test("\u04511-42.0", "" + sf_strU + sf_fM); + test("\u0451125", "" + sf_strU + s_b); + test("\u04511null", "" + sf_strU + f_oN); + test("\u04511-1410065408", "" + sf_strU + s_lM); + test("\u045118.0", "" + sf_strU + s_d); + test("\u0451155.0", "" + sf_strU + s_f); + test("\u0451197000000", "" + sf_strU + s_i); + test("\u04511-9900", "" + sf_strU + f_sM); + test("\u04511935228928", "" + sf_strU + s_l); + test("\u04511-8400", "" + sf_strU + sf_sM); + test("\u04511C(82)", "" + sf_strU + s_o); + test("\u04511null", "" + sf_strU + sf_oNtS); + test("\u04511true", "" + sf_strU + s_bl); + test("\u045113900", "" + sf_strU + s_s); + test("\u04511null", "" + sf_strU + sf_oN); + test("\u0451194000000", "" + sf_strU + f_I); + test("\u04511null", "" + sf_strU + f_IN); + test("\u04511true", "" + sf_strU + sf_bl); + test("\u045115500", "" + sf_strU + sf_s); + test("\u04511-2900", "" + sf_strU + s_sM); + test("\u04511-194313216", "" + sf_strU + sf_l); + test("\u0451112", "" + sf_strU + s_strU1); + test("\u04511C(87)", "" + sf_strU + sf_o); + test("\u0451191", "" + sf_strU + s_strU2); + test("\u0451121", "" + sf_strU + f_strU1); + test("\u0451118", "" + sf_strU + f_strU2); + test("\u04511null", "" + sf_strU + f_iAN); + test("\u04511null", "" + sf_strU + s_oN); + test("\u04511\u045180", "" + sf_strU + s_strU); + test("\u04511C", "" + sf_strU + sf_c); + test("\u0451175", "" + sf_strU + sf_str); + test("\u04511-43", "" + sf_strU + s_bM); + test("\u0451180", "" + sf_strU + sf_b); + test("\u04511null", "" + sf_strU + s_IN); + test("\u04511-52.0", "" + sf_strU + s_fM); + test("\u0451175000000", "" + sf_strU + sf_i); + test("\u0451144", "" + sf_strU + f_b); + test("\u04511-1705032704", "" + sf_strU + sf_lM); + test("\u04511null", "" + sf_strU + f_oAN); + test("\u0451183.0", "" + sf_strU + f_d); + test("\u04511I", "" + sf_strU + f_c); + test("\u0451194.0", "" + sf_strU + f_f); + test("\u0451112.0", "" + sf_strU + sf_d); + test("\u04511-99.0", "" + sf_strU + f_dM); + test("\u0451117.0", "" + sf_strU + sf_f); + test("\u04511-84.0", "" + sf_strU + sf_dM); + test("\u0451158000000", "" + sf_strU + f_i); + test("\u04511-55000000", "" + sf_strU + f_iM); + test("\u045111460392448", "" + sf_strU + f_l); + test("\u04511C(70)", "" + sf_strU + f_o); + test("\u04511\u04511", "" + sf_strU + sf_strU); + test("\u045118000", "" + sf_strU + f_s); + test("\u0451118", "" + sf_strU + s_str); + test("\u04511-1000000", "" + sf_strU + s_iM); + test("\u045111000000", "" + sf_strU + sf_I); + test("\u04511null", "" + sf_strU + f_oNtS); + test("\u04511false", "" + sf_strU + f_bl); + test("\u04511null", "" + sf_strU + sf_iAN); + test("\u04511-2000000", "" + sf_strU + sf_iM); + test("\u04511-820130816", "" + sf_strU + f_lM); + test("\u04511null", "" + sf_strU + sf_oAN); + test("\u0451125000000", "" + sf_strU + s_I); + test("8000-96.0", "" + f_s + s_dM); + test("8000null", "" + f_s + s_oNtS); + test("8000\u045176", "" + f_s + f_strU); + test("800092", "" + f_s + sf_strU2); + test("800051", "" + f_s + sf_strU1); + test("8000null", "" + f_s + s_iAN); + test("8000-54", "" + f_s + f_bM); + test("8000-87.0", "" + f_s + f_fM); + test("8000null", "" + f_s + s_oAN); + test("800019", "" + f_s + f_str); + test("8000-41", "" + f_s + sf_bM); + test("8000null", "" + f_s + sf_IN); + test("8000T", "" + f_s + s_c); + test("8000-42.0", "" + f_s + sf_fM); + test("800025", "" + f_s + s_b); + test("8000null", "" + f_s + f_oN); + test("8000-1410065408", "" + f_s + s_lM); + test("80008.0", "" + f_s + s_d); + test("800055.0", "" + f_s + s_f); + test("800097000000", "" + f_s + s_i); + test("8000-9900", "" + f_s + f_sM); + test("8000935228928", "" + f_s + s_l); + test("8000-8400", "" + f_s + sf_sM); + test("8000C(82)", "" + f_s + s_o); + test("8000null", "" + f_s + sf_oNtS); + test("8000true", "" + f_s + s_bl); + test("80003900", "" + f_s + s_s); + test("8000null", "" + f_s + sf_oN); + test("800094000000", "" + f_s + f_I); + test("8000null", "" + f_s + f_IN); + test("8000true", "" + f_s + sf_bl); + test("80005500", "" + f_s + sf_s); + test("8000-2900", "" + f_s + s_sM); + test("8000-194313216", "" + f_s + sf_l); + test("800012", "" + f_s + s_strU1); + test("8000C(87)", "" + f_s + sf_o); + test("800091", "" + f_s + s_strU2); + test("800021", "" + f_s + f_strU1); + test("800018", "" + f_s + f_strU2); + test("8000null", "" + f_s + f_iAN); + test("8000null", "" + f_s + s_oN); + test("8000\u045180", "" + f_s + s_strU); + test("8000C", "" + f_s + sf_c); + test("800075", "" + f_s + sf_str); + test("8000-43", "" + f_s + s_bM); + test("800080", "" + f_s + sf_b); + test("8000null", "" + f_s + s_IN); + test("8000-52.0", "" + f_s + s_fM); + test("800075000000", "" + f_s + sf_i); + test("800044", "" + f_s + f_b); + test("8000-1705032704", "" + f_s + sf_lM); + test("8000null", "" + f_s + f_oAN); + test("800083.0", "" + f_s + f_d); + test("8000I", "" + f_s + f_c); + test("800094.0", "" + f_s + f_f); + test("800012.0", "" + f_s + sf_d); + test("8000-99.0", "" + f_s + f_dM); + test("800017.0", "" + f_s + sf_f); + test("8000-84.0", "" + f_s + sf_dM); + test("800058000000", "" + f_s + f_i); + test("8000-55000000", "" + f_s + f_iM); + test("80001460392448", "" + f_s + f_l); + test("8000C(70)", "" + f_s + f_o); + test("8000\u04511", "" + f_s + sf_strU); + test("80008000", "" + f_s + f_s); + test("800018", "" + f_s + s_str); + test("8000-1000000", "" + f_s + s_iM); + test("80001000000", "" + f_s + sf_I); + test("8000null", "" + f_s + f_oNtS); + test("8000false", "" + f_s + f_bl); + test("8000null", "" + f_s + sf_iAN); + test("8000-2000000", "" + f_s + sf_iM); + test("8000-820130816", "" + f_s + f_lM); + test("8000null", "" + f_s + sf_oAN); + test("800025000000", "" + f_s + s_I); + test("18-96.0", "" + s_str + s_dM); + test("18null", "" + s_str + s_oNtS); + test("18\u045176", "" + s_str + f_strU); + test("1892", "" + s_str + sf_strU2); + test("1851", "" + s_str + sf_strU1); + test("18null", "" + s_str + s_iAN); + test("18-54", "" + s_str + f_bM); + test("18-87.0", "" + s_str + f_fM); + test("18null", "" + s_str + s_oAN); + test("1819", "" + s_str + f_str); + test("18-41", "" + s_str + sf_bM); + test("18null", "" + s_str + sf_IN); + test("18T", "" + s_str + s_c); + test("18-42.0", "" + s_str + sf_fM); + test("1825", "" + s_str + s_b); + test("18null", "" + s_str + f_oN); + test("18-1410065408", "" + s_str + s_lM); + test("188.0", "" + s_str + s_d); + test("1855.0", "" + s_str + s_f); + test("1897000000", "" + s_str + s_i); + test("18-9900", "" + s_str + f_sM); + test("18935228928", "" + s_str + s_l); + test("18-8400", "" + s_str + sf_sM); + test("18C(82)", "" + s_str + s_o); + test("18null", "" + s_str + sf_oNtS); + test("18true", "" + s_str + s_bl); + test("183900", "" + s_str + s_s); + test("18null", "" + s_str + sf_oN); + test("1894000000", "" + s_str + f_I); + test("18null", "" + s_str + f_IN); + test("18true", "" + s_str + sf_bl); + test("185500", "" + s_str + sf_s); + test("18-2900", "" + s_str + s_sM); + test("18-194313216", "" + s_str + sf_l); + test("1812", "" + s_str + s_strU1); + test("18C(87)", "" + s_str + sf_o); + test("1891", "" + s_str + s_strU2); + test("1821", "" + s_str + f_strU1); + test("1818", "" + s_str + f_strU2); + test("18null", "" + s_str + f_iAN); + test("18null", "" + s_str + s_oN); + test("18\u045180", "" + s_str + s_strU); + test("18C", "" + s_str + sf_c); + test("1875", "" + s_str + sf_str); + test("18-43", "" + s_str + s_bM); + test("1880", "" + s_str + sf_b); + test("18null", "" + s_str + s_IN); + test("18-52.0", "" + s_str + s_fM); + test("1875000000", "" + s_str + sf_i); + test("1844", "" + s_str + f_b); + } + + public void run5() { + test("18-1705032704", "" + s_str + sf_lM); + test("18null", "" + s_str + f_oAN); + test("1883.0", "" + s_str + f_d); + test("18I", "" + s_str + f_c); + test("1894.0", "" + s_str + f_f); + test("1812.0", "" + s_str + sf_d); + test("18-99.0", "" + s_str + f_dM); + test("1817.0", "" + s_str + sf_f); + test("18-84.0", "" + s_str + sf_dM); + test("1858000000", "" + s_str + f_i); + test("18-55000000", "" + s_str + f_iM); + test("181460392448", "" + s_str + f_l); + test("18C(70)", "" + s_str + f_o); + test("18\u04511", "" + s_str + sf_strU); + test("188000", "" + s_str + f_s); + test("1818", "" + s_str + s_str); + test("18-1000000", "" + s_str + s_iM); + test("181000000", "" + s_str + sf_I); + test("18null", "" + s_str + f_oNtS); + test("18false", "" + s_str + f_bl); + test("18null", "" + s_str + sf_iAN); + test("18-2000000", "" + s_str + sf_iM); + test("18-820130816", "" + s_str + f_lM); + test("18null", "" + s_str + sf_oAN); + test("1825000000", "" + s_str + s_I); + test("-1000000-96.0", "" + s_iM + s_dM); + test("-1000000null", "" + s_iM + s_oNtS); + test("-1000000\u045176", "" + s_iM + f_strU); + test("-100000092", "" + s_iM + sf_strU2); + test("-100000051", "" + s_iM + sf_strU1); + test("-1000000null", "" + s_iM + s_iAN); + test("-1000000-54", "" + s_iM + f_bM); + test("-1000000-87.0", "" + s_iM + f_fM); + test("-1000000null", "" + s_iM + s_oAN); + test("-100000019", "" + s_iM + f_str); + test("-1000000-41", "" + s_iM + sf_bM); + test("-1000000null", "" + s_iM + sf_IN); + test("-1000000T", "" + s_iM + s_c); + test("-1000000-42.0", "" + s_iM + sf_fM); + test("-100000025", "" + s_iM + s_b); + test("-1000000null", "" + s_iM + f_oN); + test("-1000000-1410065408", "" + s_iM + s_lM); + test("-10000008.0", "" + s_iM + s_d); + test("-100000055.0", "" + s_iM + s_f); + test("-100000097000000", "" + s_iM + s_i); + test("-1000000-9900", "" + s_iM + f_sM); + test("-1000000935228928", "" + s_iM + s_l); + test("-1000000-8400", "" + s_iM + sf_sM); + test("-1000000C(82)", "" + s_iM + s_o); + test("-1000000null", "" + s_iM + sf_oNtS); + test("-1000000true", "" + s_iM + s_bl); + test("-10000003900", "" + s_iM + s_s); + test("-1000000null", "" + s_iM + sf_oN); + test("-100000094000000", "" + s_iM + f_I); + test("-1000000null", "" + s_iM + f_IN); + test("-1000000true", "" + s_iM + sf_bl); + test("-10000005500", "" + s_iM + sf_s); + test("-1000000-2900", "" + s_iM + s_sM); + test("-1000000-194313216", "" + s_iM + sf_l); + test("-100000012", "" + s_iM + s_strU1); + test("-1000000C(87)", "" + s_iM + sf_o); + test("-100000091", "" + s_iM + s_strU2); + test("-100000021", "" + s_iM + f_strU1); + test("-100000018", "" + s_iM + f_strU2); + test("-1000000null", "" + s_iM + f_iAN); + test("-1000000null", "" + s_iM + s_oN); + test("-1000000\u045180", "" + s_iM + s_strU); + test("-1000000C", "" + s_iM + sf_c); + test("-100000075", "" + s_iM + sf_str); + test("-1000000-43", "" + s_iM + s_bM); + test("-100000080", "" + s_iM + sf_b); + test("-1000000null", "" + s_iM + s_IN); + test("-1000000-52.0", "" + s_iM + s_fM); + test("-100000075000000", "" + s_iM + sf_i); + test("-100000044", "" + s_iM + f_b); + test("-1000000-1705032704", "" + s_iM + sf_lM); + test("-1000000null", "" + s_iM + f_oAN); + test("-100000083.0", "" + s_iM + f_d); + test("-1000000I", "" + s_iM + f_c); + test("-100000094.0", "" + s_iM + f_f); + test("-100000012.0", "" + s_iM + sf_d); + test("-1000000-99.0", "" + s_iM + f_dM); + test("-100000017.0", "" + s_iM + sf_f); + test("-1000000-84.0", "" + s_iM + sf_dM); + test("-100000058000000", "" + s_iM + f_i); + test("-1000000-55000000", "" + s_iM + f_iM); + test("-10000001460392448", "" + s_iM + f_l); + test("-1000000C(70)", "" + s_iM + f_o); + test("-1000000\u04511", "" + s_iM + sf_strU); + test("-10000008000", "" + s_iM + f_s); + test("-100000018", "" + s_iM + s_str); + test("-1000000-1000000", "" + s_iM + s_iM); + test("-10000001000000", "" + s_iM + sf_I); + test("-1000000null", "" + s_iM + f_oNtS); + test("-1000000false", "" + s_iM + f_bl); + test("-1000000null", "" + s_iM + sf_iAN); + test("-1000000-2000000", "" + s_iM + sf_iM); + test("-1000000-820130816", "" + s_iM + f_lM); + test("-1000000null", "" + s_iM + sf_oAN); + test("-100000025000000", "" + s_iM + s_I); + test("1000000-96.0", "" + sf_I + s_dM); + test("1000000null", "" + sf_I + s_oNtS); + test("1000000\u045176", "" + sf_I + f_strU); + test("100000092", "" + sf_I + sf_strU2); + test("100000051", "" + sf_I + sf_strU1); + test("1000000null", "" + sf_I + s_iAN); + test("1000000-54", "" + sf_I + f_bM); + test("1000000-87.0", "" + sf_I + f_fM); + test("1000000null", "" + sf_I + s_oAN); + test("100000019", "" + sf_I + f_str); + test("1000000-41", "" + sf_I + sf_bM); + test("1000000null", "" + sf_I + sf_IN); + test("1000000T", "" + sf_I + s_c); + test("1000000-42.0", "" + sf_I + sf_fM); + test("100000025", "" + sf_I + s_b); + test("1000000null", "" + sf_I + f_oN); + test("1000000-1410065408", "" + sf_I + s_lM); + test("10000008.0", "" + sf_I + s_d); + test("100000055.0", "" + sf_I + s_f); + test("100000097000000", "" + sf_I + s_i); + test("1000000-9900", "" + sf_I + f_sM); + test("1000000935228928", "" + sf_I + s_l); + test("1000000-8400", "" + sf_I + sf_sM); + test("1000000C(82)", "" + sf_I + s_o); + test("1000000null", "" + sf_I + sf_oNtS); + test("1000000true", "" + sf_I + s_bl); + test("10000003900", "" + sf_I + s_s); + test("1000000null", "" + sf_I + sf_oN); + test("100000094000000", "" + sf_I + f_I); + test("1000000null", "" + sf_I + f_IN); + test("1000000true", "" + sf_I + sf_bl); + test("10000005500", "" + sf_I + sf_s); + test("1000000-2900", "" + sf_I + s_sM); + test("1000000-194313216", "" + sf_I + sf_l); + test("100000012", "" + sf_I + s_strU1); + test("1000000C(87)", "" + sf_I + sf_o); + test("100000091", "" + sf_I + s_strU2); + test("100000021", "" + sf_I + f_strU1); + test("100000018", "" + sf_I + f_strU2); + test("1000000null", "" + sf_I + f_iAN); + test("1000000null", "" + sf_I + s_oN); + test("1000000\u045180", "" + sf_I + s_strU); + test("1000000C", "" + sf_I + sf_c); + test("100000075", "" + sf_I + sf_str); + test("1000000-43", "" + sf_I + s_bM); + test("100000080", "" + sf_I + sf_b); + test("1000000null", "" + sf_I + s_IN); + test("1000000-52.0", "" + sf_I + s_fM); + test("100000075000000", "" + sf_I + sf_i); + test("100000044", "" + sf_I + f_b); + test("1000000-1705032704", "" + sf_I + sf_lM); + test("1000000null", "" + sf_I + f_oAN); + test("100000083.0", "" + sf_I + f_d); + test("1000000I", "" + sf_I + f_c); + test("100000094.0", "" + sf_I + f_f); + test("100000012.0", "" + sf_I + sf_d); + test("1000000-99.0", "" + sf_I + f_dM); + test("100000017.0", "" + sf_I + sf_f); + test("1000000-84.0", "" + sf_I + sf_dM); + test("100000058000000", "" + sf_I + f_i); + test("1000000-55000000", "" + sf_I + f_iM); + test("10000001460392448", "" + sf_I + f_l); + test("1000000C(70)", "" + sf_I + f_o); + test("1000000\u04511", "" + sf_I + sf_strU); + test("10000008000", "" + sf_I + f_s); + test("100000018", "" + sf_I + s_str); + test("1000000-1000000", "" + sf_I + s_iM); + test("10000001000000", "" + sf_I + sf_I); + test("1000000null", "" + sf_I + f_oNtS); + test("1000000false", "" + sf_I + f_bl); + test("1000000null", "" + sf_I + sf_iAN); + test("1000000-2000000", "" + sf_I + sf_iM); + test("1000000-820130816", "" + sf_I + f_lM); + test("1000000null", "" + sf_I + sf_oAN); + test("100000025000000", "" + sf_I + s_I); + test("null-96.0", "" + f_oNtS + s_dM); + test("nullnull", "" + f_oNtS + s_oNtS); + test("null\u045176", "" + f_oNtS + f_strU); + test("null92", "" + f_oNtS + sf_strU2); + test("null51", "" + f_oNtS + sf_strU1); + test("nullnull", "" + f_oNtS + s_iAN); + test("null-54", "" + f_oNtS + f_bM); + test("null-87.0", "" + f_oNtS + f_fM); + test("nullnull", "" + f_oNtS + s_oAN); + test("null19", "" + f_oNtS + f_str); + test("null-41", "" + f_oNtS + sf_bM); + test("nullnull", "" + f_oNtS + sf_IN); + test("nullT", "" + f_oNtS + s_c); + test("null-42.0", "" + f_oNtS + sf_fM); + test("null25", "" + f_oNtS + s_b); + test("nullnull", "" + f_oNtS + f_oN); + test("null-1410065408", "" + f_oNtS + s_lM); + test("null8.0", "" + f_oNtS + s_d); + test("null55.0", "" + f_oNtS + s_f); + test("null97000000", "" + f_oNtS + s_i); + test("null-9900", "" + f_oNtS + f_sM); + test("null935228928", "" + f_oNtS + s_l); + test("null-8400", "" + f_oNtS + sf_sM); + test("nullC(82)", "" + f_oNtS + s_o); + test("nullnull", "" + f_oNtS + sf_oNtS); + test("nulltrue", "" + f_oNtS + s_bl); + test("null3900", "" + f_oNtS + s_s); + test("nullnull", "" + f_oNtS + sf_oN); + test("null94000000", "" + f_oNtS + f_I); + test("nullnull", "" + f_oNtS + f_IN); + test("nulltrue", "" + f_oNtS + sf_bl); + test("null5500", "" + f_oNtS + sf_s); + test("null-2900", "" + f_oNtS + s_sM); + test("null-194313216", "" + f_oNtS + sf_l); + test("null12", "" + f_oNtS + s_strU1); + test("nullC(87)", "" + f_oNtS + sf_o); + test("null91", "" + f_oNtS + s_strU2); + test("null21", "" + f_oNtS + f_strU1); + test("null18", "" + f_oNtS + f_strU2); + test("nullnull", "" + f_oNtS + f_iAN); + test("nullnull", "" + f_oNtS + s_oN); + test("null\u045180", "" + f_oNtS + s_strU); + test("nullC", "" + f_oNtS + sf_c); + test("null75", "" + f_oNtS + sf_str); + test("null-43", "" + f_oNtS + s_bM); + test("null80", "" + f_oNtS + sf_b); + test("nullnull", "" + f_oNtS + s_IN); + test("null-52.0", "" + f_oNtS + s_fM); + test("null75000000", "" + f_oNtS + sf_i); + test("null44", "" + f_oNtS + f_b); + test("null-1705032704", "" + f_oNtS + sf_lM); + test("nullnull", "" + f_oNtS + f_oAN); + test("null83.0", "" + f_oNtS + f_d); + test("nullI", "" + f_oNtS + f_c); + test("null94.0", "" + f_oNtS + f_f); + test("null12.0", "" + f_oNtS + sf_d); + test("null-99.0", "" + f_oNtS + f_dM); + test("null17.0", "" + f_oNtS + sf_f); + test("null-84.0", "" + f_oNtS + sf_dM); + test("null58000000", "" + f_oNtS + f_i); + test("null-55000000", "" + f_oNtS + f_iM); + test("null1460392448", "" + f_oNtS + f_l); + test("nullC(70)", "" + f_oNtS + f_o); + test("null\u04511", "" + f_oNtS + sf_strU); + test("null8000", "" + f_oNtS + f_s); + test("null18", "" + f_oNtS + s_str); + test("null-1000000", "" + f_oNtS + s_iM); + test("null1000000", "" + f_oNtS + sf_I); + test("nullnull", "" + f_oNtS + f_oNtS); + test("nullfalse", "" + f_oNtS + f_bl); + test("nullnull", "" + f_oNtS + sf_iAN); + test("null-2000000", "" + f_oNtS + sf_iM); + test("null-820130816", "" + f_oNtS + f_lM); + test("nullnull", "" + f_oNtS + sf_oAN); + test("null25000000", "" + f_oNtS + s_I); + test("false-96.0", "" + f_bl + s_dM); + test("falsenull", "" + f_bl + s_oNtS); + test("false\u045176", "" + f_bl + f_strU); + test("false92", "" + f_bl + sf_strU2); + test("false51", "" + f_bl + sf_strU1); + test("falsenull", "" + f_bl + s_iAN); + test("false-54", "" + f_bl + f_bM); + test("false-87.0", "" + f_bl + f_fM); + test("falsenull", "" + f_bl + s_oAN); + test("false19", "" + f_bl + f_str); + test("false-41", "" + f_bl + sf_bM); + test("falsenull", "" + f_bl + sf_IN); + test("falseT", "" + f_bl + s_c); + test("false-42.0", "" + f_bl + sf_fM); + test("false25", "" + f_bl + s_b); + test("falsenull", "" + f_bl + f_oN); + test("false-1410065408", "" + f_bl + s_lM); + test("false8.0", "" + f_bl + s_d); + test("false55.0", "" + f_bl + s_f); + test("false97000000", "" + f_bl + s_i); + test("false-9900", "" + f_bl + f_sM); + test("false935228928", "" + f_bl + s_l); + test("false-8400", "" + f_bl + sf_sM); + test("falseC(82)", "" + f_bl + s_o); + test("falsenull", "" + f_bl + sf_oNtS); + test("falsetrue", "" + f_bl + s_bl); + test("false3900", "" + f_bl + s_s); + test("falsenull", "" + f_bl + sf_oN); + test("false94000000", "" + f_bl + f_I); + test("falsenull", "" + f_bl + f_IN); + test("falsetrue", "" + f_bl + sf_bl); + test("false5500", "" + f_bl + sf_s); + test("false-2900", "" + f_bl + s_sM); + test("false-194313216", "" + f_bl + sf_l); + test("false12", "" + f_bl + s_strU1); + test("falseC(87)", "" + f_bl + sf_o); + test("false91", "" + f_bl + s_strU2); + test("false21", "" + f_bl + f_strU1); + test("false18", "" + f_bl + f_strU2); + test("falsenull", "" + f_bl + f_iAN); + test("falsenull", "" + f_bl + s_oN); + test("false\u045180", "" + f_bl + s_strU); + test("falseC", "" + f_bl + sf_c); + test("false75", "" + f_bl + sf_str); + test("false-43", "" + f_bl + s_bM); + test("false80", "" + f_bl + sf_b); + test("falsenull", "" + f_bl + s_IN); + test("false-52.0", "" + f_bl + s_fM); + test("false75000000", "" + f_bl + sf_i); + test("false44", "" + f_bl + f_b); + test("false-1705032704", "" + f_bl + sf_lM); + test("falsenull", "" + f_bl + f_oAN); + test("false83.0", "" + f_bl + f_d); + test("falseI", "" + f_bl + f_c); + test("false94.0", "" + f_bl + f_f); + test("false12.0", "" + f_bl + sf_d); + test("false-99.0", "" + f_bl + f_dM); + test("false17.0", "" + f_bl + sf_f); + test("false-84.0", "" + f_bl + sf_dM); + test("false58000000", "" + f_bl + f_i); + test("false-55000000", "" + f_bl + f_iM); + test("false1460392448", "" + f_bl + f_l); + test("falseC(70)", "" + f_bl + f_o); + test("false\u04511", "" + f_bl + sf_strU); + test("false8000", "" + f_bl + f_s); + test("false18", "" + f_bl + s_str); + test("false-1000000", "" + f_bl + s_iM); + test("false1000000", "" + f_bl + sf_I); + test("falsenull", "" + f_bl + f_oNtS); + test("falsefalse", "" + f_bl + f_bl); + test("falsenull", "" + f_bl + sf_iAN); + test("false-2000000", "" + f_bl + sf_iM); + test("false-820130816", "" + f_bl + f_lM); + test("falsenull", "" + f_bl + sf_oAN); + test("false25000000", "" + f_bl + s_I); + test("null-96.0", "" + sf_iAN + s_dM); + test("nullnull", "" + sf_iAN + s_oNtS); + test("null\u045176", "" + sf_iAN + f_strU); + test("null92", "" + sf_iAN + sf_strU2); + test("null51", "" + sf_iAN + sf_strU1); + test("nullnull", "" + sf_iAN + s_iAN); + test("null-54", "" + sf_iAN + f_bM); + test("null-87.0", "" + sf_iAN + f_fM); + test("nullnull", "" + sf_iAN + s_oAN); + test("null19", "" + sf_iAN + f_str); + test("null-41", "" + sf_iAN + sf_bM); + test("nullnull", "" + sf_iAN + sf_IN); + test("nullT", "" + sf_iAN + s_c); + test("null-42.0", "" + sf_iAN + sf_fM); + test("null25", "" + sf_iAN + s_b); + test("nullnull", "" + sf_iAN + f_oN); + test("null-1410065408", "" + sf_iAN + s_lM); + test("null8.0", "" + sf_iAN + s_d); + test("null55.0", "" + sf_iAN + s_f); + test("null97000000", "" + sf_iAN + s_i); + test("null-9900", "" + sf_iAN + f_sM); + test("null935228928", "" + sf_iAN + s_l); + test("null-8400", "" + sf_iAN + sf_sM); + test("nullC(82)", "" + sf_iAN + s_o); + test("nullnull", "" + sf_iAN + sf_oNtS); + test("nulltrue", "" + sf_iAN + s_bl); + test("null3900", "" + sf_iAN + s_s); + test("nullnull", "" + sf_iAN + sf_oN); + test("null94000000", "" + sf_iAN + f_I); + test("nullnull", "" + sf_iAN + f_IN); + test("nulltrue", "" + sf_iAN + sf_bl); + test("null5500", "" + sf_iAN + sf_s); + test("null-2900", "" + sf_iAN + s_sM); + test("null-194313216", "" + sf_iAN + sf_l); + test("null12", "" + sf_iAN + s_strU1); + test("nullC(87)", "" + sf_iAN + sf_o); + test("null91", "" + sf_iAN + s_strU2); + test("null21", "" + sf_iAN + f_strU1); + test("null18", "" + sf_iAN + f_strU2); + test("nullnull", "" + sf_iAN + f_iAN); + test("nullnull", "" + sf_iAN + s_oN); + test("null\u045180", "" + sf_iAN + s_strU); + test("nullC", "" + sf_iAN + sf_c); + test("null75", "" + sf_iAN + sf_str); + test("null-43", "" + sf_iAN + s_bM); + test("null80", "" + sf_iAN + sf_b); + test("nullnull", "" + sf_iAN + s_IN); + test("null-52.0", "" + sf_iAN + s_fM); + test("null75000000", "" + sf_iAN + sf_i); + test("null44", "" + sf_iAN + f_b); + test("null-1705032704", "" + sf_iAN + sf_lM); + test("nullnull", "" + sf_iAN + f_oAN); + test("null83.0", "" + sf_iAN + f_d); + test("nullI", "" + sf_iAN + f_c); + test("null94.0", "" + sf_iAN + f_f); + test("null12.0", "" + sf_iAN + sf_d); + test("null-99.0", "" + sf_iAN + f_dM); + test("null17.0", "" + sf_iAN + sf_f); + test("null-84.0", "" + sf_iAN + sf_dM); + test("null58000000", "" + sf_iAN + f_i); + test("null-55000000", "" + sf_iAN + f_iM); + test("null1460392448", "" + sf_iAN + f_l); + test("nullC(70)", "" + sf_iAN + f_o); + test("null\u04511", "" + sf_iAN + sf_strU); + test("null8000", "" + sf_iAN + f_s); + test("null18", "" + sf_iAN + s_str); + test("null-1000000", "" + sf_iAN + s_iM); + test("null1000000", "" + sf_iAN + sf_I); + test("nullnull", "" + sf_iAN + f_oNtS); + test("nullfalse", "" + sf_iAN + f_bl); + test("nullnull", "" + sf_iAN + sf_iAN); + test("null-2000000", "" + sf_iAN + sf_iM); + test("null-820130816", "" + sf_iAN + f_lM); + test("nullnull", "" + sf_iAN + sf_oAN); + test("null25000000", "" + sf_iAN + s_I); + test("-2000000-96.0", "" + sf_iM + s_dM); + test("-2000000null", "" + sf_iM + s_oNtS); + test("-2000000\u045176", "" + sf_iM + f_strU); + test("-200000092", "" + sf_iM + sf_strU2); + test("-200000051", "" + sf_iM + sf_strU1); + test("-2000000null", "" + sf_iM + s_iAN); + test("-2000000-54", "" + sf_iM + f_bM); + test("-2000000-87.0", "" + sf_iM + f_fM); + test("-2000000null", "" + sf_iM + s_oAN); + test("-200000019", "" + sf_iM + f_str); + test("-2000000-41", "" + sf_iM + sf_bM); + test("-2000000null", "" + sf_iM + sf_IN); + test("-2000000T", "" + sf_iM + s_c); + test("-2000000-42.0", "" + sf_iM + sf_fM); + test("-200000025", "" + sf_iM + s_b); + test("-2000000null", "" + sf_iM + f_oN); + test("-2000000-1410065408", "" + sf_iM + s_lM); + test("-20000008.0", "" + sf_iM + s_d); + test("-200000055.0", "" + sf_iM + s_f); + test("-200000097000000", "" + sf_iM + s_i); + test("-2000000-9900", "" + sf_iM + f_sM); + test("-2000000935228928", "" + sf_iM + s_l); + test("-2000000-8400", "" + sf_iM + sf_sM); + test("-2000000C(82)", "" + sf_iM + s_o); + test("-2000000null", "" + sf_iM + sf_oNtS); + test("-2000000true", "" + sf_iM + s_bl); + test("-20000003900", "" + sf_iM + s_s); + test("-2000000null", "" + sf_iM + sf_oN); + test("-200000094000000", "" + sf_iM + f_I); + test("-2000000null", "" + sf_iM + f_IN); + test("-2000000true", "" + sf_iM + sf_bl); + test("-20000005500", "" + sf_iM + sf_s); + test("-2000000-2900", "" + sf_iM + s_sM); + test("-2000000-194313216", "" + sf_iM + sf_l); + test("-200000012", "" + sf_iM + s_strU1); + test("-2000000C(87)", "" + sf_iM + sf_o); + test("-200000091", "" + sf_iM + s_strU2); + test("-200000021", "" + sf_iM + f_strU1); + test("-200000018", "" + sf_iM + f_strU2); + test("-2000000null", "" + sf_iM + f_iAN); + test("-2000000null", "" + sf_iM + s_oN); + test("-2000000\u045180", "" + sf_iM + s_strU); + test("-2000000C", "" + sf_iM + sf_c); + test("-200000075", "" + sf_iM + sf_str); + test("-2000000-43", "" + sf_iM + s_bM); + test("-200000080", "" + sf_iM + sf_b); + test("-2000000null", "" + sf_iM + s_IN); + test("-2000000-52.0", "" + sf_iM + s_fM); + test("-200000075000000", "" + sf_iM + sf_i); + test("-200000044", "" + sf_iM + f_b); + test("-2000000-1705032704", "" + sf_iM + sf_lM); + test("-2000000null", "" + sf_iM + f_oAN); + test("-200000083.0", "" + sf_iM + f_d); + test("-2000000I", "" + sf_iM + f_c); + test("-200000094.0", "" + sf_iM + f_f); + test("-200000012.0", "" + sf_iM + sf_d); + test("-2000000-99.0", "" + sf_iM + f_dM); + test("-200000017.0", "" + sf_iM + sf_f); + test("-2000000-84.0", "" + sf_iM + sf_dM); + test("-200000058000000", "" + sf_iM + f_i); + test("-2000000-55000000", "" + sf_iM + f_iM); + test("-20000001460392448", "" + sf_iM + f_l); + test("-2000000C(70)", "" + sf_iM + f_o); + test("-2000000\u04511", "" + sf_iM + sf_strU); + test("-20000008000", "" + sf_iM + f_s); + test("-200000018", "" + sf_iM + s_str); + test("-2000000-1000000", "" + sf_iM + s_iM); + test("-20000001000000", "" + sf_iM + sf_I); + test("-2000000null", "" + sf_iM + f_oNtS); + test("-2000000false", "" + sf_iM + f_bl); + test("-2000000null", "" + sf_iM + sf_iAN); + test("-2000000-2000000", "" + sf_iM + sf_iM); + test("-2000000-820130816", "" + sf_iM + f_lM); + test("-2000000null", "" + sf_iM + sf_oAN); + test("-200000025000000", "" + sf_iM + s_I); + test("-820130816-96.0", "" + f_lM + s_dM); + test("-820130816null", "" + f_lM + s_oNtS); + test("-820130816\u045176", "" + f_lM + f_strU); + test("-82013081692", "" + f_lM + sf_strU2); + test("-82013081651", "" + f_lM + sf_strU1); + test("-820130816null", "" + f_lM + s_iAN); + test("-820130816-54", "" + f_lM + f_bM); + test("-820130816-87.0", "" + f_lM + f_fM); + test("-820130816null", "" + f_lM + s_oAN); + test("-82013081619", "" + f_lM + f_str); + test("-820130816-41", "" + f_lM + sf_bM); + test("-820130816null", "" + f_lM + sf_IN); + test("-820130816T", "" + f_lM + s_c); + test("-820130816-42.0", "" + f_lM + sf_fM); + test("-82013081625", "" + f_lM + s_b); + test("-820130816null", "" + f_lM + f_oN); + test("-820130816-1410065408", "" + f_lM + s_lM); + test("-8201308168.0", "" + f_lM + s_d); + test("-82013081655.0", "" + f_lM + s_f); + test("-82013081697000000", "" + f_lM + s_i); + test("-820130816-9900", "" + f_lM + f_sM); + test("-820130816935228928", "" + f_lM + s_l); + test("-820130816-8400", "" + f_lM + sf_sM); + test("-820130816C(82)", "" + f_lM + s_o); + test("-820130816null", "" + f_lM + sf_oNtS); + test("-820130816true", "" + f_lM + s_bl); + test("-8201308163900", "" + f_lM + s_s); + test("-820130816null", "" + f_lM + sf_oN); + test("-82013081694000000", "" + f_lM + f_I); + test("-820130816null", "" + f_lM + f_IN); + test("-820130816true", "" + f_lM + sf_bl); + test("-8201308165500", "" + f_lM + sf_s); + test("-820130816-2900", "" + f_lM + s_sM); + test("-820130816-194313216", "" + f_lM + sf_l); + test("-82013081612", "" + f_lM + s_strU1); + test("-820130816C(87)", "" + f_lM + sf_o); + test("-82013081691", "" + f_lM + s_strU2); + test("-82013081621", "" + f_lM + f_strU1); + test("-82013081618", "" + f_lM + f_strU2); + test("-820130816null", "" + f_lM + f_iAN); + test("-820130816null", "" + f_lM + s_oN); + test("-820130816\u045180", "" + f_lM + s_strU); + test("-820130816C", "" + f_lM + sf_c); + test("-82013081675", "" + f_lM + sf_str); + test("-820130816-43", "" + f_lM + s_bM); + test("-82013081680", "" + f_lM + sf_b); + test("-820130816null", "" + f_lM + s_IN); + test("-820130816-52.0", "" + f_lM + s_fM); + test("-82013081675000000", "" + f_lM + sf_i); + test("-82013081644", "" + f_lM + f_b); + test("-820130816-1705032704", "" + f_lM + sf_lM); + test("-820130816null", "" + f_lM + f_oAN); + test("-82013081683.0", "" + f_lM + f_d); + test("-820130816I", "" + f_lM + f_c); + test("-82013081694.0", "" + f_lM + f_f); + test("-82013081612.0", "" + f_lM + sf_d); + test("-820130816-99.0", "" + f_lM + f_dM); + test("-82013081617.0", "" + f_lM + sf_f); + test("-820130816-84.0", "" + f_lM + sf_dM); + test("-82013081658000000", "" + f_lM + f_i); + test("-820130816-55000000", "" + f_lM + f_iM); + test("-8201308161460392448", "" + f_lM + f_l); + test("-820130816C(70)", "" + f_lM + f_o); + test("-820130816\u04511", "" + f_lM + sf_strU); + test("-8201308168000", "" + f_lM + f_s); + test("-82013081618", "" + f_lM + s_str); + test("-820130816-1000000", "" + f_lM + s_iM); + test("-8201308161000000", "" + f_lM + sf_I); + test("-820130816null", "" + f_lM + f_oNtS); + test("-820130816false", "" + f_lM + f_bl); + test("-820130816null", "" + f_lM + sf_iAN); + test("-820130816-2000000", "" + f_lM + sf_iM); + test("-820130816-820130816", "" + f_lM + f_lM); + test("-820130816null", "" + f_lM + sf_oAN); + test("-82013081625000000", "" + f_lM + s_I); + test("null-96.0", "" + sf_oAN + s_dM); + test("nullnull", "" + sf_oAN + s_oNtS); + test("null\u045176", "" + sf_oAN + f_strU); + test("null92", "" + sf_oAN + sf_strU2); + test("null51", "" + sf_oAN + sf_strU1); + test("nullnull", "" + sf_oAN + s_iAN); + test("null-54", "" + sf_oAN + f_bM); + test("null-87.0", "" + sf_oAN + f_fM); + test("nullnull", "" + sf_oAN + s_oAN); + test("null19", "" + sf_oAN + f_str); + test("null-41", "" + sf_oAN + sf_bM); + test("nullnull", "" + sf_oAN + sf_IN); + test("nullT", "" + sf_oAN + s_c); + test("null-42.0", "" + sf_oAN + sf_fM); + test("null25", "" + sf_oAN + s_b); + test("nullnull", "" + sf_oAN + f_oN); + test("null-1410065408", "" + sf_oAN + s_lM); + test("null8.0", "" + sf_oAN + s_d); + test("null55.0", "" + sf_oAN + s_f); + test("null97000000", "" + sf_oAN + s_i); + test("null-9900", "" + sf_oAN + f_sM); + test("null935228928", "" + sf_oAN + s_l); + test("null-8400", "" + sf_oAN + sf_sM); + test("nullC(82)", "" + sf_oAN + s_o); + test("nullnull", "" + sf_oAN + sf_oNtS); + test("nulltrue", "" + sf_oAN + s_bl); + test("null3900", "" + sf_oAN + s_s); + test("nullnull", "" + sf_oAN + sf_oN); + test("null94000000", "" + sf_oAN + f_I); + test("nullnull", "" + sf_oAN + f_IN); + test("nulltrue", "" + sf_oAN + sf_bl); + test("null5500", "" + sf_oAN + sf_s); + test("null-2900", "" + sf_oAN + s_sM); + test("null-194313216", "" + sf_oAN + sf_l); + test("null12", "" + sf_oAN + s_strU1); + test("nullC(87)", "" + sf_oAN + sf_o); + test("null91", "" + sf_oAN + s_strU2); + test("null21", "" + sf_oAN + f_strU1); + test("null18", "" + sf_oAN + f_strU2); + test("nullnull", "" + sf_oAN + f_iAN); + test("nullnull", "" + sf_oAN + s_oN); + test("null\u045180", "" + sf_oAN + s_strU); + test("nullC", "" + sf_oAN + sf_c); + test("null75", "" + sf_oAN + sf_str); + test("null-43", "" + sf_oAN + s_bM); + test("null80", "" + sf_oAN + sf_b); + test("nullnull", "" + sf_oAN + s_IN); + test("null-52.0", "" + sf_oAN + s_fM); + test("null75000000", "" + sf_oAN + sf_i); + test("null44", "" + sf_oAN + f_b); + test("null-1705032704", "" + sf_oAN + sf_lM); + test("nullnull", "" + sf_oAN + f_oAN); + test("null83.0", "" + sf_oAN + f_d); + test("nullI", "" + sf_oAN + f_c); + test("null94.0", "" + sf_oAN + f_f); + test("null12.0", "" + sf_oAN + sf_d); + test("null-99.0", "" + sf_oAN + f_dM); + test("null17.0", "" + sf_oAN + sf_f); + test("null-84.0", "" + sf_oAN + sf_dM); + test("null58000000", "" + sf_oAN + f_i); + test("null-55000000", "" + sf_oAN + f_iM); + test("null1460392448", "" + sf_oAN + f_l); + test("nullC(70)", "" + sf_oAN + f_o); + test("null\u04511", "" + sf_oAN + sf_strU); + test("null8000", "" + sf_oAN + f_s); + test("null18", "" + sf_oAN + s_str); + test("null-1000000", "" + sf_oAN + s_iM); + test("null1000000", "" + sf_oAN + sf_I); + test("nullnull", "" + sf_oAN + f_oNtS); + test("nullfalse", "" + sf_oAN + f_bl); + test("nullnull", "" + sf_oAN + sf_iAN); + test("null-2000000", "" + sf_oAN + sf_iM); + test("null-820130816", "" + sf_oAN + f_lM); + test("nullnull", "" + sf_oAN + sf_oAN); + test("null25000000", "" + sf_oAN + s_I); + test("25000000-96.0", "" + s_I + s_dM); + test("25000000null", "" + s_I + s_oNtS); + test("25000000\u045176", "" + s_I + f_strU); + test("2500000092", "" + s_I + sf_strU2); + test("2500000051", "" + s_I + sf_strU1); + test("25000000null", "" + s_I + s_iAN); + test("25000000-54", "" + s_I + f_bM); + test("25000000-87.0", "" + s_I + f_fM); + test("25000000null", "" + s_I + s_oAN); + test("2500000019", "" + s_I + f_str); + test("25000000-41", "" + s_I + sf_bM); + test("25000000null", "" + s_I + sf_IN); + test("25000000T", "" + s_I + s_c); + test("25000000-42.0", "" + s_I + sf_fM); + test("2500000025", "" + s_I + s_b); + test("25000000null", "" + s_I + f_oN); + test("25000000-1410065408", "" + s_I + s_lM); + test("250000008.0", "" + s_I + s_d); + test("2500000055.0", "" + s_I + s_f); + test("2500000097000000", "" + s_I + s_i); + test("25000000-9900", "" + s_I + f_sM); + test("25000000935228928", "" + s_I + s_l); + test("25000000-8400", "" + s_I + sf_sM); + test("25000000C(82)", "" + s_I + s_o); + test("25000000null", "" + s_I + sf_oNtS); + test("25000000true", "" + s_I + s_bl); + test("250000003900", "" + s_I + s_s); + test("25000000null", "" + s_I + sf_oN); + test("2500000094000000", "" + s_I + f_I); + test("25000000null", "" + s_I + f_IN); + test("25000000true", "" + s_I + sf_bl); + test("250000005500", "" + s_I + sf_s); + test("25000000-2900", "" + s_I + s_sM); + test("25000000-194313216", "" + s_I + sf_l); + test("2500000012", "" + s_I + s_strU1); + test("25000000C(87)", "" + s_I + sf_o); + test("2500000091", "" + s_I + s_strU2); + test("2500000021", "" + s_I + f_strU1); + test("2500000018", "" + s_I + f_strU2); + test("25000000null", "" + s_I + f_iAN); + test("25000000null", "" + s_I + s_oN); + test("25000000\u045180", "" + s_I + s_strU); + test("25000000C", "" + s_I + sf_c); + test("2500000075", "" + s_I + sf_str); + test("25000000-43", "" + s_I + s_bM); + test("2500000080", "" + s_I + sf_b); + test("25000000null", "" + s_I + s_IN); + test("25000000-52.0", "" + s_I + s_fM); + test("2500000075000000", "" + s_I + sf_i); + test("2500000044", "" + s_I + f_b); + test("25000000-1705032704", "" + s_I + sf_lM); + test("25000000null", "" + s_I + f_oAN); + test("2500000083.0", "" + s_I + f_d); + test("25000000I", "" + s_I + f_c); + test("2500000094.0", "" + s_I + f_f); + test("2500000012.0", "" + s_I + sf_d); + test("25000000-99.0", "" + s_I + f_dM); + test("2500000017.0", "" + s_I + sf_f); + test("25000000-84.0", "" + s_I + sf_dM); + test("2500000058000000", "" + s_I + f_i); + test("25000000-55000000", "" + s_I + f_iM); + test("250000001460392448", "" + s_I + f_l); + test("25000000C(70)", "" + s_I + f_o); + test("25000000\u04511", "" + s_I + sf_strU); + test("250000008000", "" + s_I + f_s); + test("2500000018", "" + s_I + s_str); + test("25000000-1000000", "" + s_I + s_iM); + test("250000001000000", "" + s_I + sf_I); + test("25000000null", "" + s_I + f_oNtS); + test("25000000false", "" + s_I + f_bl); + test("25000000null", "" + s_I + sf_iAN); + test("25000000-2000000", "" + s_I + sf_iM); + test("25000000-820130816", "" + s_I + f_lM); + test("25000000null", "" + s_I + sf_oAN); + test("2500000025000000", "" + s_I + s_I); + } + +} --- /dev/null 2015-11-23 01:27:16.425045507 +0300 +++ new/test/java/lang/String/concat/ImplicitStringConcatShapesTestGen.java 2015-11-26 01:38:44.785607870 +0300 @@ -0,0 +1,290 @@ +import java.io.IOException; +import java.io.PrintWriter; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.*; + +public class ImplicitStringConcatShapesTestGen { + public static String escapeToUnicode(String str) { + StringBuilder b = new StringBuilder(); + for (char c : str.toCharArray()) { + if (c < 128) { + b.append(c); + } else { + b.append("\\u").append(String.format("%04X", (int) c)); + } + } + return b.toString(); + } + + public static void main(String... args) throws IOException { + PrintWriter pw = new PrintWriter(System.out); + + String[] types = { + "boolean", + "byte", + "byteMinus", + "char", + "short", + "shortMinus", + "int", + "intMinus", + "integer", + "integerNull", + "float", + "floatMinus", + "long", + "longMinus", + "double", + "doubleMinus", + "object", + "objectNull", + "objectNullToString", + "String", + "StringUTF16", + "StringU1", + "StringU2", + "intArrayNull", + "objectArrayNull", + }; + + for (String t : Files.readAllLines(Paths.get("ImplicitStringConcatShapes-head.template"))) { + pw.println(t); + } + + Map values = new HashMap<>(); + + Random current = new Random(12345); + for (int mode = 0; mode <= 2; mode++) { + for (String type : types) { + int i = current.nextInt(100); + boolean isStatic = (mode | 1) == 1; + boolean isFinal = (mode | 2) == 2; + String fieldName = (isStatic ? "s" : "") + (isFinal ? "f" : "") + "_" + typeSig(type); + String value = initValue(type, i); + String stringValue = stringValue(type, i); + values.put(fieldName, stringValue); + pw.printf(" %s %s %s %s = %s;%n", isStatic ? "static" : "", isFinal ? "final" : "", typeValue(type, i), fieldName, value); + } + } + + pw.println(); + + List lines = new ArrayList<>(); + List l = new ArrayList<>(values.keySet()); + + for (String l1 : l) { + lines.add(String.format("test(\"%s\", \"\" + %s);", + escapeToUnicode(values.get(l1)), + l1 + )); + } + + for (String l1 : l) { + for (String l2 : l) { + lines.add(String.format("test(\"%s\", \"\" + %s + %s);", + escapeToUnicode(values.get(l1) + values.get(l2)), + l1, l2 + )); + } + } + + final int STRIDE = 1000; + int strides = lines.size() / STRIDE + 1; + + pw.println(" public void run() {"); + for (int c = 0; c < strides; c++) { + pw.println(" run" + c + "();"); + } + pw.println(" }"); + pw.println(); + + for (int c = 0; c < strides; c++) { + pw.println(" public void run" + c + "() {"); + for (String line : lines.subList(c * STRIDE, Math.min(lines.size(), (c+1) * STRIDE))) { + pw.println(" " + line); + } + pw.println(" }"); + pw.println(); + } + + pw.println("}"); + + pw.flush(); + pw.close(); + } + + private static String typeSig(String type) { + switch (type) { + case "boolean": return "bl"; + case "byte": return "b"; + case "byteMinus": return "bM"; + case "short": return "s"; + case "shortMinus": return "sM"; + case "char": return "c"; + case "int": return "i"; + case "intMinus": return "iM"; + case "integer": return "I"; + case "integerNull": return "IN"; + case "float": return "f"; + case "floatMinus": return "fM"; + case "long": return "l"; + case "longMinus": return "lM"; + case "double": return "d"; + case "doubleMinus": return "dM"; + case "String": return "str"; + case "StringUTF16": return "strU"; + case "StringU1": return "strU1"; + case "StringU2": return "strU2"; + case "object": return "o"; + case "objectNull": return "oN"; + case "objectNullToString": return "oNtS"; + case "intArrayNull": return "iAN"; + case "objectArrayNull": return "oAN"; + default: + throw new IllegalStateException(); + } + } + + private static String typeValue(String type, int i) { + switch (type) { + case "boolean": + case "byte": + case "byteMinus": + case "char": + case "short": + case "shortMinus": + case "int": + case "intMinus": + case "float": + case "floatMinus": + case "long": + case "longMinus": + case "double": + case "doubleMinus": + return type.replace("Minus", ""); + case "String": + case "StringUTF16": + case "StringU1": + case "StringU2": + return "String"; + case "object": + case "objectNull": + case "objectNullToString": + return "Object"; + case "integer": + case "integerNull": + return "Integer"; + case "intArrayNull": + return "int[]"; + case "objectArrayNull": + return "Object[]"; + default: + throw new IllegalStateException(); + } + } + + private static String initValue(String type, int i) { + switch (type) { + case "boolean": + return String.valueOf((i & 1) == 1); + case "byte": + return String.valueOf(i); + case "byteMinus": + return String.valueOf(-i); + case "short": + return String.valueOf(i*100); + case "shortMinus": + return String.valueOf(-i*100); + case "intMinus": + return String.valueOf(-i*1_000_000); + case "int": + case "integer": + return String.valueOf(i*1_000_000); + case "long": + return String.valueOf(i*1_000_000_000) + "L"; + case "longMinus": + return String.valueOf(-i*1_000_000_000) + "L"; + case "char": + return "'" + (char)(i % 26 + 65) + "'"; + case "double": + return String.valueOf(i) + ".0d"; + case "doubleMinus": + return "-" + String.valueOf(i) + ".0d"; + case "float": + return String.valueOf(i) + ".0f"; + case "floatMinus": + return "-" + String.valueOf(i) + ".0f"; + case "object": + return "new MyClass(" + i + ")"; + case "objectNullToString": + return "new MyClassNullToString()"; + case "integerNull": + case "objectNull": + case "intArrayNull": + case "objectArrayNull": + return "null"; + case "String": + return "\"" + i + "\""; + case "StringUTF16": + return "\"\\u0451" + i + "\""; + case "StringU1": + return "\"\\u0001" + i + "\""; + case "StringU2": + return "\"\\u0002" + i + "\""; + default: + throw new IllegalStateException(); + } + } + + private static String stringValue(String type, int i) { + switch (type) { + case "boolean": + return String.valueOf((i & 1) == 1); + case "byte": + return String.valueOf(i); + case "byteMinus": + return String.valueOf(-i); + case "short": + return String.valueOf(i*100); + case "shortMinus": + return String.valueOf(-i*100); + case "intMinus": + return String.valueOf(-i*1_000_000); + case "int": + case "integer": + return String.valueOf(i*1_000_000); + case "long": + return String.valueOf(i*1_000_000_000); + case "longMinus": + return String.valueOf(-i*1_000_000_000); + case "char": + return String.valueOf((char) (i % 26 + 65)); + case "double": + case "float": + return String.valueOf(i) + ".0"; + case "doubleMinus": + case "floatMinus": + return "-" + String.valueOf(i) + ".0"; + case "object": + return "C(" + i + ")"; + case "integerNull": + case "objectNull": + case "objectNullToString": + case "intArrayNull": + case "objectArrayNull": + return "null"; + case "String": + return "" + i; + case "StringUTF16": + return "\u0451" + i; + case "StringU1": + return "\u0001" + i; + case "StringU2": + return "\u0002" + i; + default: + throw new IllegalStateException(); + } + } + +} \ No newline at end of file --- /dev/null 2015-11-23 01:27:16.425045507 +0300 +++ new/test/java/lang/String/concat/StringConcatFactoryInvariants.java 2015-11-26 01:38:45.225605696 +0300 @@ -0,0 +1,293 @@ +/* + * Copyright (c) 2015, 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +import java.io.Serializable; +import java.lang.invoke.*; +import java.util.concurrent.Callable; + +/** + * @test + * @summary Test input invariants for StringConcatFactory + * + * @compile StringConcatFactoryInvariants.java + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT StringConcatFactoryInvariants + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true StringConcatFactoryInvariants + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.cache=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.cache=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.cache=true StringConcatFactoryInvariants + * + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=BC_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_SB_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true StringConcatFactoryInvariants + * @run main/othervm -Djava.lang.invoke.stringConcat=MH_INLINE_SIZED_EXACT -Djava.lang.invoke.stringConcat.debug=true -Djava.lang.invoke.stringConcat.cache=true StringConcatFactoryInvariants + * +*/ +public class StringConcatFactoryInvariants { + + private static final char TAG_ARG = '\u0001'; + private static final char TAG_CONST = '\u0002'; + + public static void main(String[] args) throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.publicLookup(); + String methodName = "foo"; + MethodType mt = MethodType.methodType(String.class, String.class, int.class); + String recipe = "" + TAG_ARG + TAG_ARG + TAG_CONST; + String[] constants = new String[]{"bar"}; + + final int LIMIT = 200; + + // Simple factory: check for dynamic arguments overflow + Class[] underThreshold = new Class[LIMIT - 1]; + Class[] threshold = new Class[LIMIT]; + Class[] overThreshold = new Class[LIMIT + 1]; + + StringBuilder sbUnderThreshold = new StringBuilder(); + sbUnderThreshold.append(TAG_CONST); + for (int c = 0; c < LIMIT - 1; c++) { + underThreshold[c] = int.class; + threshold[c] = int.class; + overThreshold[c] = int.class; + sbUnderThreshold.append(TAG_ARG); + } + threshold[LIMIT - 1] = int.class; + overThreshold[LIMIT - 1] = int.class; + overThreshold[LIMIT] = int.class; + + String recipeEmpty = ""; + String recipeUnderThreshold = sbUnderThreshold.toString(); + String recipeThreshold = sbUnderThreshold.append(TAG_ARG).toString(); + String recipeOverThreshold = sbUnderThreshold.append(TAG_ARG).toString(); + + MethodType mtEmpty = MethodType.methodType(String.class); + MethodType mtUnderThreshold = MethodType.methodType(String.class, underThreshold); + MethodType mtThreshold = MethodType.methodType(String.class, threshold); + MethodType mtOverThreshold = MethodType.methodType(String.class, overThreshold); + + + // Check the basic functionality is working + { + CallSite cs = StringConcatFactory.makeConcat(lookup, methodName, mt); + test("foo42", (String) cs.getTarget().invokeExact("foo", 42)); + } + + { + CallSite cs = StringConcatFactory.makeConcatWithConstants(lookup, methodName, mt, recipe, constants); + test("foo42bar", (String) cs.getTarget().invokeExact("foo", 42)); + } + + // Simple factory, check for nulls: + failNPE("Lookup is null", + () -> StringConcatFactory.makeConcat(null, methodName, mt)); + + failNPE("Method name is null", + () -> StringConcatFactory.makeConcat(lookup, null, mt)); + + failNPE("MethodType is null", + () -> StringConcatFactory.makeConcat(lookup, methodName, null)); + + // Advanced factory, check for nulls: + failNPE("Lookup is null", + () -> StringConcatFactory.makeConcatWithConstants(null, methodName, mt, recipe, constants)); + + failNPE("Method name is null", + () -> StringConcatFactory.makeConcatWithConstants(lookup, null, mt, recipe, constants)); + + failNPE("MethodType is null", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, null, recipe, constants)); + + failNPE("Recipe is null", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, mt, null, constants)); + + failNPE("Constants vararg is null", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, mt, recipe, null)); + + // Simple factory, check for return type + fail("Return type: void", + () -> StringConcatFactory.makeConcat(lookup, methodName, MethodType.methodType(void.class, String.class, int.class))); + + fail("Return type: int", + () -> StringConcatFactory.makeConcat(lookup, methodName, MethodType.methodType(int.class, String.class, int.class))); + + fail("Return type: StringBuilder", + () -> StringConcatFactory.makeConcat(lookup, methodName, MethodType.methodType(StringBuilder.class, String.class, int.class))); + + ok("Return type: Object", + () -> StringConcatFactory.makeConcat(lookup, methodName, MethodType.methodType(Object.class, String.class, int.class))); + + ok("Return type: CharSequence", + () -> StringConcatFactory.makeConcat(lookup, methodName, MethodType.methodType(CharSequence.class, String.class, int.class))); + + ok("Return type: Serializable", + () -> StringConcatFactory.makeConcat(lookup, methodName, MethodType.methodType(Serializable.class, String.class, int.class))); + + // Advanced factory, check for return types + fail("Return type: void", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, MethodType.methodType(void.class, String.class, int.class), recipe, constants)); + + fail("Return type: int", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, MethodType.methodType(int.class, String.class, int.class), recipe, constants)); + + fail("Return type: StringBuilder", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, MethodType.methodType(StringBuilder.class, String.class, int.class), recipe, constants)); + + ok("Return type: Object", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, MethodType.methodType(Object.class, String.class, int.class), recipe, constants)); + + ok("Return type: CharSequence", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, MethodType.methodType(CharSequence.class, String.class, int.class), recipe, constants)); + + ok("Return type: Serializable", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, MethodType.methodType(Serializable.class, String.class, int.class), recipe, constants)); + + // Simple factory: check for dynamic arguments overflow + ok("Dynamic arguments is under limit", + () -> StringConcatFactory.makeConcat(lookup, methodName, mtUnderThreshold)); + + ok("Dynamic arguments is at the limit", + () -> StringConcatFactory.makeConcat(lookup, methodName, mtThreshold)); + + fail("Dynamic arguments is over the limit", + () -> StringConcatFactory.makeConcat(lookup, methodName, mtOverThreshold)); + + // Advanced factory: check for dynamic arguments overflow + ok("Dynamic arguments is under limit", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, mtUnderThreshold, recipeUnderThreshold, constants)); + + ok("Dynamic arguments is at the limit", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, mtThreshold, recipeThreshold, constants)); + + fail("Dynamic arguments is over the limit", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, mtOverThreshold, recipeOverThreshold, constants)); + + // Advanced factory: check for mismatched recipe and Constants + ok("Static arguments and recipe match", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, mtThreshold, recipeThreshold, "bar")); + + fail("Static arguments and recipe mismatch", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, mtThreshold, recipeThreshold, "bar", "baz")); + + // Advanced factory: check for mismatched recipe and dynamic arguments + fail("Dynamic arguments and recipe mismatch", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, mtThreshold, recipeUnderThreshold, constants)); + + ok("Dynamic arguments and recipe match", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, mtThreshold, recipeThreshold, constants)); + + fail("Dynamic arguments and recipe mismatch", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, mtThreshold, recipeOverThreshold, constants)); + + // Test passing array as constant + { + String[] arg = {"boo", "bar"}; + + CallSite cs1 = StringConcatFactory.makeConcatWithConstants(lookup, methodName, MethodType.methodType(String.class, int.class), "" + TAG_ARG + TAG_CONST + TAG_CONST, arg); + test("42boobar", (String) cs1.getTarget().invokeExact(42)); + } + + // Test passing null constant + ok("Can pass regular constants", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, MethodType.methodType(String.class, int.class), "" + TAG_ARG + TAG_CONST, "foo")); + + fail("Cannot pass null constants", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, MethodType.methodType(String.class, int.class), "" + TAG_ARG + TAG_CONST, new String[]{null})); + + // Simple factory: test empty arguments + ok("Ok to pass empty arguments", + () -> StringConcatFactory.makeConcat(lookup, methodName, mtEmpty)); + + // Advanced factory: test empty arguments + ok("Ok to pass empty arguments", + () -> StringConcatFactory.makeConcatWithConstants(lookup, methodName, mtEmpty, recipeEmpty)); + } + + public static void ok(String msg, Callable runnable) { + try { + runnable.call(); + } catch (Throwable e) { + e.printStackTrace(); + throw new IllegalStateException(msg + ", should have passed", e); + } + } + + public static void fail(String msg, Callable runnable) { + boolean expected = false; + try { + runnable.call(); + } catch (StringConcatException e) { + expected = true; + } catch (Throwable e) { + e.printStackTrace(); + } + + if (!expected) { + throw new IllegalStateException(msg + ", should have failed with StringConcatException"); + } + } + + + public static void failNPE(String msg, Callable runnable) { + boolean expected = false; + try { + runnable.call(); + } catch (NullPointerException e) { + expected = true; + } catch (Throwable e) { + e.printStackTrace(); + } + + if (!expected) { + throw new IllegalStateException(msg + ", should have failed with NullPointerException"); + } + } + + public static void test(String expected, String actual) { + // Fingers crossed: String concat should work. + if (!expected.equals(actual)) { + StringBuilder sb = new StringBuilder(); + sb.append("Expected = "); + sb.append(expected); + sb.append(", actual = "); + sb.append(actual); + throw new IllegalStateException(sb.toString()); + } + } + +} --- /dev/null 2015-11-23 01:27:16.425045507 +0300 +++ new/test/java/lang/String/concat/update-tests.sh 2015-11-26 01:38:45.657603563 +0300 @@ -0,0 +1,5 @@ +#!/bin/bash + +javac ImplicitStringConcatShapesTestGen.java +java ImplicitStringConcatShapesTestGen > ImplicitStringConcatShapes.java +rm ImplicitStringConcatShapesTestGen.class