update Java version

Author: peteroupc

src/main/java/com/upokecenter/cbor/CBORDataUtilities.java

@@ -32,10 +32,10 @@ public static CBORObject ParseJSONNumber(String str) {
     /**
      * Parses a number whose format follows the JSON specification (RFC 7159).
      * Roughly speaking, a valid number consists of an optional minus sign,
-     * one or more digits (starting with 1 to 9 unless the only digit is 0),
-     * an optional decimal point with one or more digits, and an optional
-     * letter E or e with an optional plus or minus sign and one or more
-     * digits (the exponent).
+     * one or more basic digits (starting with 1 to 9 unless the only digit
+     * is 0), an optional decimal point ("." , full stop) with one or more
+     * basic digits, and an optional letter E or e with an optional plus or
+     * minus sign and one or more basic digits (the exponent).
      * @param str A string to parse.
      * @param integersOnly If true, no decimal points or exponents are allowed in
      * the string.

src/main/java/com/upokecenter/cbor/CBORObject.java

@@ -69,21 +69,20 @@
      * without such synchronization.</p> <p>One kind of CBOR object is
      * called a map, or a list of key-value pairs. Keys can be any kind of
      * CBOR object, including numbers, strings, arrays, and maps. However,
-     * text strings are the most suitable to ((use instanceof keys) ?
-     * (keys)use : null); other kinds of CBOR object are much better used as
-     * map values instead, keeping in mind that some of them are not thread
-     * safe without synchronizing reads and writes to them.</p> <p>To find
-     * the type of a CBOR object, call its Type property (or "getType()" in
-     * Java). The return value can be Number, Boolean, SimpleValue, or
-     * TextString for immutable CBOR objects, and Array, Map, or ByteString
-     * for mutable CBOR objects.</p> <p><b>Nesting Depth:</b></p> <p>The
-     * DecodeFromBytes method can only read objects with a limited maximum
-     * depth of arrays and maps nested within other arrays and maps. The
-     * code sets this maximum depth to 500 (allowing more than enough
-     * nesting for most purposes), but it's possible that stack overflows in
-     * some runtimes might lower the effective maximum nesting depth. When
-     * the nesting depth goes above 500, the DecodeFromBytes method throws a
-     * CBORException.</p>
+     * text strings are the most suitable to use as keys; other kinds of
+     * CBOR object are much better used as map values instead, keeping in
+     * mind that some of them are not thread safe without synchronizing
+     * reads and writes to them.</p> <p>To find the type of a CBOR object,
+     * call its Type property (or "getType()" in Java). The return value can
+     * be Number, Boolean, SimpleValue, or TextString for immutable CBOR
+     * objects, and Array, Map, or ByteString for mutable CBOR objects.</p>
+     * <p><b>Nesting Depth:</b></p> <p>The DecodeFromBytes method can only
+     * read objects with a limited maximum depth of arrays and maps nested
+     * within other arrays and maps. The code sets this maximum depth to 500
+     * (allowing more than enough nesting for most purposes), but it's
+     * possible that stack overflows in some runtimes might lower the
+     * effective maximum nesting depth. When the nesting depth goes above
+     * 500, the DecodeFromBytes method throws a CBORException.</p>
      */
   public final class CBORObject implements Comparable<CBORObject> {
     private static CBORObject ConstructSimpleValue(int v) {
@@ -1048,7 +1047,33 @@ public static <TKey, TValue> CBORObject FromObject(Map<TKey,
     }
 
     /**
-     *
+     * Generates a CBORObject from an arbitrary object. The following types are
+     * specially handled by this method: null , primitive types, strings,
+     * CBORObject , ExtendedDecimal , ExtendedFloat , ExtendedRational, the
+     * custom BigInteger , lists, arrays, enumerations (<code>Enum</code>
+     * objects), and maps.<p>In the .NET version, if the object is a type
+     * not specially handled by this method, returns a CBOR map with the
+     * values of each of its read/write properties (or all properties in the
+     * case of an anonymous type). Properties are converted to their
+     * camel-case names (meaning if a name starts with A to Z, that letter
+     * is lower-cased). If the property name begins with the word "Is", that
+     * word is deleted from the name. Also, .NET <code>Enum</code> objects will be
+     * converted to their integer values, and a multidimensional array is
+     * converted to an array of arrays.</p> <p>In the Java version, if the
+     * object is a type not specially handled by this method, this method
+     * checks the CBOR object for methods starting with the word "get" or
+     * "is" that take no parameters, and returns a CBOR map with one entry
+     * for each such method found. For each method found, the starting word
+     * "get" or "is" is deleted from its name, and the name is converted to
+     * camel case (meaning if a name starts with A to Z, that letter is
+     * lower-cased). Also, Java <code>Enum</code> objects will be converted to the
+     * result of their name method.</p> <p>If the input is a byte array, the
+     * byte array is copied to a new byte array. (This method can't be used
+     * to decode CBOR data from a byte array; for that, use the
+     * DecodeFromBytes method instead.).</p>
+     * @param obj An arbitrary object.
+     * @return A CBOR object corresponding to the given object. Returns
+     * CBORObject.Null if the object is null.
      */
     public static CBORObject FromObject(Object obj) {
       if (obj == null) {

src/main/java/com/upokecenter/util/ExtendedDecimal.java

@@ -2365,10 +2365,9 @@ public ExtendedDecimal Remainder(
      * @param divisor The divisor.
      * @param ctx A precision context object to control the precision. The rounding
      * and exponent range settings of this context are ignored (the rounding
-     * mode is always ((treated instanceof HalfEven) ? (HalfEven)treated :
-     * null)). If HasFlags of the context is true, will also store the flags
-     * resulting from the operation (the flags are in addition to the
-     * pre-existing flags). Can be null.
+     * mode is always treated as HalfEven). If HasFlags of the context is
+     * true, will also store the flags resulting from the operation (the
+     * flags are in addition to the pre-existing flags). Can be null.
      * @return The distance of the closest multiple. Signals FlagInvalid and
      * returns NaN if the divisor is 0, or either the result of integer
      * division (the quotient) or the remainder wouldn't fit the given

src/main/java/com/upokecenter/util/ExtendedFloat.java

@@ -1565,10 +1565,9 @@ public ExtendedFloat Remainder(
      * @param divisor The divisor.
      * @param ctx A precision context object to control the precision. The rounding
      * and exponent range settings of this context are ignored (the rounding
-     * mode is always ((treated instanceof HalfEven) ? (HalfEven)treated :
-     * null)). If HasFlags of the context is true, will also store the flags
-     * resulting from the operation (the flags are in addition to the
-     * pre-existing flags). Can be null.
+     * mode is always treated as HalfEven). If HasFlags of the context is
+     * true, will also store the flags resulting from the operation (the
+     * flags are in addition to the pre-existing flags). Can be null.
      * @return The distance of the closest multiple. Signals FlagInvalid and
      * returns NaN if the divisor is 0, or either the result of integer
      * division (the quotient) or the remainder wouldn't fit the given

src/test/java/com/upokecenter/test/BigIntTest.java

@@ -15,7 +15,11 @@ public class BigIntTest {
     // Test some specific cases
     @Test
     public void TestSpecificCases() {
-  TestCommon.DoTestMultiply(
+      TestCommon.DoTestRemainder(
+        "-2472320648",
+        "2831812081",
+        "359491433");
+      TestCommon.DoTestMultiply(
 "39258416159456516340113264558732499166970244380745050",
 "39258416159456516340113264558732499166970244380745051",
 "1541223239349076530208308657654362309553698742116222355477449713742236585667505604058123112521437480247550");
@@ -46,6 +50,8 @@ public void TestMultiplyDivide() {
       for (int i = 0; i < 4000; ++i) {
         BigInteger bigintA = RandomObjects.RandomBigInteger(r);
         BigInteger bigintB = RandomObjects.RandomBigInteger(r);
+        bigintA = BigInteger.fromString("-2472320648");
+        bigintB = BigInteger.fromString("2831812081");
         // Test that A*B/A = B and A*B/B = A
         BigInteger bigintC = bigintA.multiply(bigintB);
         BigInteger bigintRem;
@@ -94,7 +100,10 @@ public void TestMultiplyDivide() {
 BigInteger[] divrem=(bigintA).divideAndRemainder(bigintB);
 bigintC = divrem[0];
 bigintRem = divrem[1]; }
+          System.out.println(bigintC);
+          System.out.println(bigintRem);
           bigintD = bigintB.multiply(bigintC);
+          System.out.println(bigintD);
           bigintD = bigintD.add(bigintRem);
           if (!bigintD.equals(bigintA)) {
             Assert.assertEquals("TestMultiplyDivide " + bigintA + "; " + bigintB,bigintA,bigintD);