Made numeric codec implementations more lenient

JAVA-2529

Author: rozza

bson/src/main/org/bson/codecs/AtomicIntegerCodec.java

@@ -21,21 +21,24 @@
 
 import java.util.concurrent.atomic.AtomicInteger;
 
+import static org.bson.codecs.NumberCodecHelper.decodeInt;
+
 /**
  * Encodes and decodes {@code AtomicInteger} objects.
  *
  * @since 3.0
  */
 
 public class AtomicIntegerCodec implements Codec<AtomicInteger> {
+
     @Override
     public void encode(final BsonWriter writer, final AtomicInteger value, final EncoderContext encoderContext) {
         writer.writeInt32(value.intValue());
     }
 
     @Override
     public AtomicInteger decode(final BsonReader reader, final DecoderContext decoderContext) {
-        return new AtomicInteger(reader.readInt32());
+        return new AtomicInteger(decodeInt(reader));
     }
 
     @Override

bson/src/main/org/bson/codecs/AtomicLongCodec.java

@@ -21,21 +21,24 @@
 
 import java.util.concurrent.atomic.AtomicLong;
 
+import static org.bson.codecs.NumberCodecHelper.decodeLong;
+
 /**
  * Encodes and decodes {@code AtomicLong} objects.
  *
  * @since 3.0
  */
 
 public class AtomicLongCodec implements Codec<AtomicLong> {
+
     @Override
     public void encode(final BsonWriter writer, final AtomicLong value, final EncoderContext encoderContext) {
         writer.writeInt64(value.longValue());
     }
 
     @Override
     public AtomicLong decode(final BsonReader reader, final DecoderContext decoderContext) {
-        return new AtomicLong(reader.readInt64());
+        return new AtomicLong(decodeLong(reader));
     }
 
     @Override

bson/src/main/org/bson/codecs/ByteCodec.java

@@ -21,21 +21,23 @@
 import org.bson.BsonWriter;
 
 import static java.lang.String.format;
+import static org.bson.codecs.NumberCodecHelper.decodeInt;
 
 /**
  * Encodes and decodes {@code Byte} objects.
  *
  * @since 3.0
  */
 public class ByteCodec implements Codec<Byte> {
+
     @Override
     public void encode(final BsonWriter writer, final Byte value, final EncoderContext encoderContext) {
         writer.writeInt32(value);
     }
 
     @Override
     public Byte decode(final BsonReader reader, final DecoderContext decoderContext) {
-        int value = reader.readInt32();
+        int value = decodeInt(reader);
         if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
             throw new BsonInvalidOperationException(format("%s can not be converted into a Byte.", value));
         }

bson/src/main/org/bson/codecs/DoubleCodec.java

@@ -19,6 +19,8 @@
 import org.bson.BsonReader;
 import org.bson.BsonWriter;
 
+import static org.bson.codecs.NumberCodecHelper.decodeDouble;
+
 /**
  * Encodes and decodes {@code Double} objects.
  *
@@ -32,7 +34,7 @@ public void encode(final BsonWriter writer, final Double value, final EncoderCon
 
     @Override
     public Double decode(final BsonReader reader, final DecoderContext decoderContext) {
-        return reader.readDouble();
+        return decodeDouble(reader);
     }
 
     @Override

bson/src/main/org/bson/codecs/FloatCodec.java

@@ -21,21 +21,23 @@
 import org.bson.BsonWriter;
 
 import static java.lang.String.format;
+import static org.bson.codecs.NumberCodecHelper.decodeDouble;
 
 /**
  * Encodes and decodes {@code Float} objects.
  *
  * @since 3.0
  */
 public class FloatCodec implements Codec<Float> {
+
     @Override
     public void encode(final BsonWriter writer, final Float value, final EncoderContext encoderContext) {
         writer.writeDouble(value);
     }
 
     @Override
     public Float decode(final BsonReader reader, final DecoderContext decoderContext) {
-        double value = reader.readDouble();
+        double value = decodeDouble(reader);
         if (value < -Float.MAX_VALUE || value > Float.MAX_VALUE) {
             throw new BsonInvalidOperationException(format("%s can not be converted into a Float.", value));
         }

bson/src/main/org/bson/codecs/IntegerCodec.java

@@ -19,20 +19,23 @@
 import org.bson.BsonReader;
 import org.bson.BsonWriter;
 
+import static org.bson.codecs.NumberCodecHelper.decodeInt;
+
 /**
  * Encodes and decodes {@code Integer} objects.
  *
  * @since 3.0
  */
 public class IntegerCodec implements Codec<Integer> {
+
     @Override
     public void encode(final BsonWriter writer, final Integer value, final EncoderContext encoderContext) {
         writer.writeInt32(value);
     }
 
     @Override
     public Integer decode(final BsonReader reader, final DecoderContext decoderContext) {
-        return reader.readInt32();
+        return decodeInt(reader);
     }
 
     @Override

bson/src/main/org/bson/codecs/LongCodec.java

@@ -19,21 +19,24 @@
 import org.bson.BsonReader;
 import org.bson.BsonWriter;
 
+import static org.bson.codecs.NumberCodecHelper.decodeLong;
+
 /**
  * Encodes and decodes {@code Long} objects.
  *
  * @since 3.0
  */
 
 public class LongCodec implements Codec<Long> {
+
     @Override
     public void encode(final BsonWriter writer, final Long value, final EncoderContext encoderContext) {
         writer.writeInt64(value);
     }
 
     @Override
     public Long decode(final BsonReader reader, final DecoderContext decoderContext) {
-        return reader.readInt64();
+        return decodeLong(reader);
     }
 
     @Override

bson/src/main/org/bson/codecs/NumberCodecHelper.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2017 MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.bson.codecs;
+
+import org.bson.BsonInvalidOperationException;
+import org.bson.BsonReader;
+import org.bson.BsonType;
+
+import static java.lang.String.format;
+
+final class NumberCodecHelper {
+
+    static int decodeInt(final BsonReader reader) {
+        int intValue;
+        BsonType bsonType = reader.getCurrentBsonType();
+        switch (bsonType) {
+            case INT32:
+                intValue = reader.readInt32();
+                break;
+            case INT64:
+                long longValue = reader.readInt64();
+                intValue = (int) longValue;
+                if (longValue != (long) intValue) {
+                    throw invalidConversion(Integer.class, longValue);
+                }
+                break;
+            case DOUBLE:
+                double doubleValue = reader.readDouble();
+                intValue = (int) doubleValue;
+                if (doubleValue != (double) intValue) {
+                    throw invalidConversion(Integer.class, doubleValue);
+                }
+                break;
+            default:
+                throw new BsonInvalidOperationException(format("Invalid numeric type, found: %s", bsonType));
+        }
+        return intValue;
+    }
+
+    static long decodeLong(final BsonReader reader) {
+        long longValue;
+        BsonType bsonType = reader.getCurrentBsonType();
+        switch (bsonType) {
+            case INT32:
+                longValue = reader.readInt32();
+                break;
+            case INT64:
+                longValue = reader.readInt64();
+                break;
+            case DOUBLE:
+                double doubleValue = reader.readDouble();
+                longValue = (long) doubleValue;
+                if (doubleValue != (double) longValue) {
+                    throw invalidConversion(Long.class, doubleValue);
+                }
+                break;
+            default:
+                throw new BsonInvalidOperationException(format("Invalid numeric type, found: %s", bsonType));
+        }
+        return longValue;
+    }
+
+    static double decodeDouble(final BsonReader reader) {
+        double doubleValue;
+        BsonType bsonType = reader.getCurrentBsonType();
+        switch (bsonType) {
+            case INT32:
+                doubleValue = reader.readInt32();
+                break;
+            case INT64:
+                long longValue = reader.readInt64();
+                doubleValue = longValue;
+                if (longValue != (long) doubleValue) {
+                    throw invalidConversion(Double.class, longValue);
+                }
+                break;
+            case DOUBLE:
+                doubleValue = reader.readDouble();
+                break;
+            default:
+                throw new BsonInvalidOperationException(format("Invalid numeric type, found: %s", bsonType));
+        }
+        return doubleValue;
+    }
+
+    private static  <T extends Number> BsonInvalidOperationException invalidConversion(final Class<T> clazz, final Number value) {
+        return new BsonInvalidOperationException(format("Could not convert `%s` to a %s without losing precision", value, clazz));
+    }
+
+    private NumberCodecHelper() {
+    }
+}

bson/src/main/org/bson/codecs/ShortCodec.java

@@ -21,21 +21,23 @@
 import org.bson.BsonWriter;
 
 import static java.lang.String.format;
+import static org.bson.codecs.NumberCodecHelper.decodeInt;
 
 /**
  * Encodes and decodes {@code Short} objects.
  *
  * @since 3.0
  */
 public class ShortCodec implements Codec<Short> {
+
     @Override
     public void encode(final BsonWriter writer, final Short value, final EncoderContext encoderContext) {
         writer.writeInt32(value);
     }
 
     @Override
     public Short decode(final BsonReader reader, final DecoderContext decoderContext) {
-        int value = reader.readInt32();
+        int value = decodeInt(reader);
         if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
             throw new BsonInvalidOperationException(format("%s can not be converted into a Short.", value));
         }

bson/src/test/unit/org/bson/codecs/AtomicIntegerCodecTest.java

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2017 MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.bson.codecs;
+
+import org.bson.BsonInvalidOperationException;
+import org.bson.Document;
+import org.junit.Test;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.Assert.assertEquals;
+
+public final class AtomicIntegerCodecTest extends CodecTestCase {
+
+    @Test
+    public void shouldRoundTripAtomicIntegerValues() {
+        Document original = new Document("a", new AtomicInteger(Integer.MAX_VALUE));
+        roundTrip(original, new AtomicIntegerComparator(original));
+
+        original = new Document("a", new AtomicInteger(Integer.MIN_VALUE));
+        roundTrip(original, new AtomicIntegerComparator(original));
+    }
+
+    @Test
+    public void shouldHandleAlternativeNumberValues() {
+        Document expected = new Document("a", new AtomicInteger(10));
+        roundTrip(new Document("a", 10), new AtomicIntegerComparator(expected));
+        roundTrip(new Document("a", 10L), new AtomicIntegerComparator(expected));
+        roundTrip(new Document("a", 10.00), new AtomicIntegerComparator(expected));
+        roundTrip(new Document("a", 9.9999999999999992), new AtomicIntegerComparator(expected));
+    }
+
+    @Test(expected = BsonInvalidOperationException.class)
+    public void shouldThrowWhenHandlingLossyDoubleValues() {
+        Document original = new Document("a", 9.9999999999999991);
+        roundTrip(original, new AtomicIntegerComparator(original));
+    }
+
+    @Test(expected = BsonInvalidOperationException.class)
+    public void shouldErrorDecodingOutsideMinRange() {
+        roundTrip(new Document("a", Long.MIN_VALUE));
+    }
+
+    @Test(expected = BsonInvalidOperationException.class)
+    public void shouldErrorDecodingOutsideMaxRange() {
+        roundTrip(new Document("a", Long.MAX_VALUE));
+    }
+
+    @Override
+    DocumentCodecProvider getDocumentCodecProvider() {
+        return getSpecificNumberDocumentCodecProvider(AtomicInteger.class);
+    }
+
+    private class AtomicIntegerComparator implements Comparator<Document> {
+        private final Document expected;
+
+        AtomicIntegerComparator(final Document expected) {
+            this.expected = expected;
+        }
+
+        @Override
+        public void apply(final Document result) {
+            assertEquals("Codec Round Trip",
+                    expected.get("a", AtomicInteger.class).get(),
+                    result.get("a", AtomicInteger.class).get());
+        }
+    }
+
+}