openfast-commit Mailing List for OpenFAST (Page 8)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 131
          http://openfast.svn.sourceforge.net/openfast/?rev=131&view=rev
Author:   jacob_northey
Date:     2008-02-07 08:41:36 -0800 (Thu, 07 Feb 2008)

Log Message:
-----------
Fixed mantissa should be stored in long bug.

Modified Paths:
--------------
    trunk/src/main/java/org/openfast/DecimalValue.java
    trunk/src/main/java/org/openfast/template/operator/DefaultOperatorCodec.java
    trunk/src/main/java/org/openfast/template/operator/Operator.java
    trunk/src/main/java/org/openfast/template/type/DecimalConverter.java
    trunk/src/main/java/org/openfast/template/type/codec/NullableSingleFieldDecimal.java
    trunk/src/main/java/org/openfast/template/type/codec/SingleFieldDecimal.java
    trunk/src/test/java/org/openfast/template/operator/DefaultOperatorTest.java
    trunk/src/test/java/org/openfast/template/type/codec/ComposedDecimalTest.java

Added Paths:
-----------
    trunk/src/test/java/org/openfast/submitted/LargeValuesTest.java

Modified: trunk/src/main/java/org/openfast/DecimalValue.java
===================================================================

--- trunk/src/main/java/org/openfast/DecimalValue.java	2008-02-07 16:34:58 UTC (rev 130)
+++ trunk/src/main/java/org/openfast/DecimalValue.java	2008-02-07 16:41:36 UTC (rev 131)
@@ -17,22 +17,23 @@
 
 Contributor(s): Jacob Northey <ja...@la...>
                 Craig Otis <co...@la...>
-*/
+ */
 
-
 package org.openfast;
 
 import java.math.BigDecimal;
 
 import org.openfast.error.FastConstants;
 
-
 public class DecimalValue extends NumericValue {
     private static final long serialVersionUID = 1L;
-	public final double value;
+
+    public final double value;
+
     public final int exponent;
-    public final int mantissa;
 
+    public final long mantissa;
+
     public DecimalValue(double value) {
         if (value == 0.0) {
             this.value = 0.0;
@@ -46,7 +47,7 @@
 
         BigDecimal decimalValue = BigDecimal.valueOf(value);
         int exponent = decimalValue.scale();
-        int mantissa = decimalValue.unscaledValue().intValue();
+        long mantissa = decimalValue.unscaledValue().longValue();
 
         while (((mantissa % 10) == 0) && (mantissa != 0)) {
             mantissa /= 10;
@@ -57,7 +58,7 @@
         this.exponent = -exponent;
     }
 
-    public DecimalValue(int mantissa, int exponent) {
+    public DecimalValue(long mantissa, int exponent) {
         this.mantissa = mantissa;
         this.exponent = exponent;
 
@@ -109,42 +110,42 @@
     }
 
     public long toLong() {
-    	if (exponent < 0)
-    		Global.handleError(FastConstants.R5_DECIMAL_CANT_CONVERT_TO_INT, "");
+        if (exponent < 0)
+            Global.handleError(FastConstants.R5_DECIMAL_CANT_CONVERT_TO_INT, "");
         return (long) value;
     }
 
     public int toInt() {
-    	if (exponent < 0)
-    		Global.handleError(FastConstants.R5_DECIMAL_CANT_CONVERT_TO_INT, "");
+        if (exponent < 0)
+            Global.handleError(FastConstants.R5_DECIMAL_CANT_CONVERT_TO_INT, "");
         return (int) value;
     }
 
     public short toShort() {
-    	if (exponent < 0)
-    		Global.handleError(FastConstants.R5_DECIMAL_CANT_CONVERT_TO_INT, "");
+        if (exponent < 0)
+            Global.handleError(FastConstants.R5_DECIMAL_CANT_CONVERT_TO_INT, "");
         return (short) value;
     }
 
     public byte toByte() {
-    	if (exponent < 0)
-    		Global.handleError(FastConstants.R5_DECIMAL_CANT_CONVERT_TO_INT, "");
+        if (exponent < 0)
+            Global.handleError(FastConstants.R5_DECIMAL_CANT_CONVERT_TO_INT, "");
         return (byte) value;
     }
-    
+
     public double toDouble() {
-    	return value;
+        return value;
     }
-    
+
     public BigDecimal toBigDecimal() {
-    	return new BigDecimal(value);
+        return new BigDecimal(value);
     }
 
     public String toString() {
         return String.valueOf(value);
     }
-    
+
     public int hashCode() {
-    	return exponent * 37 + mantissa;
+        return exponent * 37 + (int) mantissa;
     }
 }

Modified: trunk/src/main/java/org/openfast/template/operator/DefaultOperatorCodec.java
===================================================================
--- trunk/src/main/java/org/openfast/template/operator/DefaultOperatorCodec.java	2008-02-07 16:34:58 UTC (rev 130)
+++ trunk/src/main/java/org/openfast/template/operator/DefaultOperatorCodec.java	2008-02-07 16:41:36 UTC (rev 131)
@@ -8,32 +8,33 @@
 import org.openfast.template.type.Type;
 
 final class DefaultOperatorCodec extends OperatorCodec {
-	private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L;
 
-	DefaultOperatorCodec(Operator operator, Type[] types) {
-		super(operator, types);
-	}
+    DefaultOperatorCodec(Operator operator, Type[] types) {
+        super(operator, types);
+    }
 
-	public ScalarValue getValueToEncode(ScalarValue value, ScalarValue priorValue, Scalar field) {
-	    if (value == null) {
-	    	if (field.getDefaultValue().isUndefined())
-	    		return null;
-	        return ScalarValue.NULL;
-	    }
-	
-	    return value.equals(field.getDefaultValue()) ? null : value;
-	}
+    public ScalarValue getValueToEncode(ScalarValue value, ScalarValue priorValue, Scalar field) {
+        if (value == null) {
+            if (field.getDefaultValue().isUndefined())
+                return null;
+            return ScalarValue.NULL;
+        }
 
-	public ScalarValue decodeValue(ScalarValue newValue, ScalarValue previousValue, Scalar field) {
-	    return newValue;
-	}
+        return value.equals(field.getDefaultValue()) ? null : value;
+    }
 
-	public ScalarValue decodeEmptyValue(ScalarValue previousValue, Scalar field) {
-		if (field.getDefaultValue().isUndefined()) return null;
-	    return field.getDefaultValue();
-	}
+    public ScalarValue decodeValue(ScalarValue newValue, ScalarValue previousValue, Scalar field) {
+        return newValue;
+    }
 
-	public boolean equals(Object obj) {
-		return obj != null && obj.getClass() == getClass();
-	}
-}
\ No newline at end of file
+    public ScalarValue decodeEmptyValue(ScalarValue previousValue, Scalar field) {
+        if (field.getDefaultValue().isUndefined())
+            return null;
+        return field.getDefaultValue();
+    }
+
+    public boolean equals(Object obj) {
+        return obj != null && obj.getClass() == getClass();
+    }
+}

Modified: trunk/src/main/java/org/openfast/template/operator/Operator.java
===================================================================
--- trunk/src/main/java/org/openfast/template/operator/Operator.java	2008-02-07 16:34:58 UTC (rev 130)
+++ trunk/src/main/java/org/openfast/template/operator/Operator.java	2008-02-07 16:41:36 UTC (rev 131)
@@ -11,105 +11,123 @@
 import org.openfast.template.type.Type;
 
 public class Operator implements Serializable {
-	private static final long serialVersionUID = 1L;
-	private static final Map OPERATOR_NAME_MAP = new HashMap();
-	private final String name;
+    private static final long serialVersionUID = 1L;
 
-	public static final Operator NONE = new Operator("none") {
-		private static final long serialVersionUID = 2L;
-		public boolean usesDictionary() {
-			return false;
-		}
-		public boolean shouldStoreValue(ScalarValue value) {
-			return false;
-		}
-	};
-	public static final Operator CONSTANT = new Operator("constant") {
-		private static final long serialVersionUID = 1L;
+    private static final Map OPERATOR_NAME_MAP = new HashMap();
 
-		public void validate(Scalar scalar) {
-	    	if (scalar.getDefaultValue().isUndefined())
-	    		Global.handleError(FastConstants.S4_NO_INITIAL_VALUE_FOR_CONST, "The field " + scalar + " must have a default value defined.");
-		}
-		
-		public boolean shouldStoreValue(ScalarValue value) {
-			return false;
-		}
-		
-		public boolean usesDictionary() {
-			return false;
-		}
-	};
-	public static final Operator DEFAULT = new Operator("default") {
-		private static final long serialVersionUID = 1L;
+    private final String name;
 
-		public void validate(Scalar scalar) {
-	    	if (!scalar.isOptional() && scalar.getDefaultValue().isUndefined())
-	    		Global.handleError(FastConstants.S5_NO_INITVAL_MNDTRY_DFALT, "The field " + scalar + " must have a default value defined.");
-		}
-	};
-	public static final Operator COPY = new Operator("copy") {
-		private static final long serialVersionUID = 1L;
+    public static final Operator NONE = new Operator("none") {
+        private static final long serialVersionUID = 2L;
 
-		public OperatorCodec getCodec(Type type) {
-			return OperatorCodec.COPY_ALL;
-		}
-	};
-	public static final Operator INCREMENT = new Operator("increment");
-	public static final Operator DELTA = new Operator("delta") {
-		private static final long serialVersionUID = 1L;
+        public boolean usesDictionary() {
+            return false;
+        }
 
-		public boolean shouldStoreValue(ScalarValue value) {
-			return value != null;
-		}
-	};
-	public static final Operator TAIL = new Operator("tail");
+        public boolean shouldStoreValue(ScalarValue value) {
+            return false;
+        }
+    };
 
-	public Operator(String name) {
-		this.name = name;
-		OPERATOR_NAME_MAP.put(name, this);
-	}
-	
-	public static Operator getOperator(String name) {
-		if (!OPERATOR_NAME_MAP.containsKey(name))
-			throw new IllegalArgumentException("The operator \"" + name + "\" does not exist.");
-		return (Operator) OPERATOR_NAME_MAP.get(name);
-	}
-	
-	public OperatorCodec getCodec(Type type) {
-		return OperatorCodec.getCodec(this, type);
-	}
-	
-	public String toString() {
-		return name;
-	}
+    public static final Operator CONSTANT = new Operator("constant") {
+        private static final long serialVersionUID = 1L;
 
-	public String getName() {
-		return name;
-	}
+        public void validate(Scalar scalar) {
+            if (scalar.getDefaultValue().isUndefined())
+                Global.handleError(FastConstants.S4_NO_INITIAL_VALUE_FOR_CONST, "The field " + scalar
+                        + " must have a default value defined.");
+        }
 
-	public boolean shouldStoreValue(ScalarValue value) {
-		return true;
-	}
+        public boolean shouldStoreValue(ScalarValue value) {
+            return false;
+        }
 
-	public void validate(Scalar scalar) {
-	}
+        public boolean usesDictionary() {
+            return false;
+        }
+    };
 
-	public boolean equals(Object other) {
-		if (other == this) return true;
-		if (other == null || !(other instanceof Operator)) return false;
-		return equals((Operator) other);
-	}
-	
-	private boolean equals(Operator other) {
-		return name.equals(other.name);
-	}
-	
-	public int hashCode() {
-		return name.hashCode();
-	}
+    public static final Operator DEFAULT = new Operator("default") {
+        private static final long serialVersionUID = 1L;
 
-	public boolean usesDictionary() {
-		return true;
-	}
+        public void validate(Scalar scalar) {
+            if (!scalar.isOptional() && scalar.getDefaultValue().isUndefined())
+                Global.handleError(FastConstants.S5_NO_INITVAL_MNDTRY_DFALT, "The field " + scalar
+                        + " must have a default value defined.");
+        }
+
+        public boolean shouldStoreValue(ScalarValue value) {
+            return value != null;
+        }
+    };
+
+    public static final Operator COPY = new Operator("copy") {
+        private static final long serialVersionUID = 1L;
+
+        public OperatorCodec getCodec(Type type) {
+            return OperatorCodec.COPY_ALL;
+        }
+    };
+
+    public static final Operator INCREMENT = new Operator("increment");
+
+    public static final Operator DELTA = new Operator("delta") {
+        private static final long serialVersionUID = 1L;
+
+        public boolean shouldStoreValue(ScalarValue value) {
+            return value != null;
+        }
+    };
+
+    public static final Operator TAIL = new Operator("tail");
+
+    public Operator(String name) {
+        this.name = name;
+        OPERATOR_NAME_MAP.put(name, this);
+    }
+
+    public static Operator getOperator(String name) {
+        if (!OPERATOR_NAME_MAP.containsKey(name))
+            throw new IllegalArgumentException("The operator \"" + name + "\" does not exist.");
+        return (Operator) OPERATOR_NAME_MAP.get(name);
+    }
+
+    public OperatorCodec getCodec(Type type) {
+        return OperatorCodec.getCodec(this, type);
+    }
+
+    public String toString() {
+        return name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public boolean shouldStoreValue(ScalarValue value) {
+        return true;
+    }
+
+    public void validate(Scalar scalar) {
+    }
+
+    public boolean equals(Object other) {
+        if (other == this)
+            return true;
+        if (other == null || !(other instanceof Operator))
+            return false;
+        return equals((Operator) other);
+    }
+
+    private boolean equals(Operator other) {
+        return name.equals(other.name);
+    }
+
+    public int hashCode() {
+        return name.hashCode();
+    }
+
+    public boolean usesDictionary() {
+        return true;
+    }
 }

Modified: trunk/src/main/java/org/openfast/template/type/DecimalConverter.java
===================================================================
--- trunk/src/main/java/org/openfast/template/type/DecimalConverter.java	2008-02-07 16:34:58 UTC (rev 130)
+++ trunk/src/main/java/org/openfast/template/type/DecimalConverter.java	2008-02-07 16:41:36 UTC (rev 131)
@@ -5,24 +5,28 @@
 import org.openfast.IntegerValue;
 import org.openfast.ScalarValue;
 import org.openfast.template.ComposedValueConverter;
+import org.openfast.template.LongValue;
 
 public class DecimalConverter implements ComposedValueConverter {
 
-	private static final FieldValue[] NULL_SET = new FieldValue[] { null, null };
-	private static final FieldValue[] UNDEFINED_SET = new FieldValue[] { ScalarValue.UNDEFINED, ScalarValue.UNDEFINED };
+    private static final FieldValue[] NULL_SET = new FieldValue[] { null, null };
 
-	public FieldValue[] split(FieldValue value) {
-		if (value == null)
-			return NULL_SET;
-		else if (value == ScalarValue.UNDEFINED)
-			return UNDEFINED_SET;
-		DecimalValue decimal = (DecimalValue) value;
-		return new FieldValue[] { new IntegerValue(decimal.exponent), new IntegerValue(decimal.mantissa) };
-	}
+    private static final FieldValue[] UNDEFINED_SET = new FieldValue[] { ScalarValue.UNDEFINED, ScalarValue.UNDEFINED };
 
-	public FieldValue compose(FieldValue[] values) {
-		if (values[0] == null) return null;
-		if (values[0] == ScalarValue.UNDEFINED) return ScalarValue.UNDEFINED;
-		return new DecimalValue(((IntegerValue) values[1]).value, ((IntegerValue) values[0]).value);
-	}
+    public FieldValue[] split(FieldValue value) {
+        if (value == null)
+            return NULL_SET;
+        else if (value == ScalarValue.UNDEFINED)
+            return UNDEFINED_SET;
+        DecimalValue decimal = (DecimalValue) value;
+        return new FieldValue[] { new IntegerValue(decimal.exponent), new LongValue(decimal.mantissa) };
+    }
+
+    public FieldValue compose(FieldValue[] values) {
+        if (values[0] == null)
+            return null;
+        if (values[0] == ScalarValue.UNDEFINED)
+            return ScalarValue.UNDEFINED;
+        return new DecimalValue(((ScalarValue)values[1]).toLong(), ((IntegerValue) values[0]).value);
+    }
 }

Modified: trunk/src/main/java/org/openfast/template/type/codec/NullableSingleFieldDecimal.java
===================================================================
--- trunk/src/main/java/org/openfast/template/type/codec/NullableSingleFieldDecimal.java	2008-02-07 16:34:58 UTC (rev 130)
+++ trunk/src/main/java/org/openfast/template/type/codec/NullableSingleFieldDecimal.java	2008-02-07 16:41:36 UTC (rev 131)
@@ -25,18 +25,18 @@
  */
 package org.openfast.template.type.codec;
 
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
 import org.openfast.DecimalValue;
 import org.openfast.Global;
 import org.openfast.IntegerValue;
 import org.openfast.ScalarValue;
-
 import org.openfast.error.FastConstants;
+import org.openfast.template.LongValue;
 
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
 
-
 final class NullableSingleFieldDecimal extends TypeCodec {
     private static final long serialVersionUID = 1L;
 
@@ -62,7 +62,7 @@
 
             buffer.write(TypeCodec.NULLABLE_INTEGER.encode(
                     new IntegerValue(value.exponent)));
-            buffer.write(TypeCodec.INTEGER.encode(new IntegerValue(value.mantissa)));
+            buffer.write(TypeCodec.INTEGER.encode(new LongValue(value.mantissa)));
         } catch (IOException e) {
             throw new RuntimeException(e);
         }

Modified: trunk/src/main/java/org/openfast/template/type/codec/SingleFieldDecimal.java
===================================================================
--- trunk/src/main/java/org/openfast/template/type/codec/SingleFieldDecimal.java	2008-02-07 16:34:58 UTC (rev 130)
+++ trunk/src/main/java/org/openfast/template/type/codec/SingleFieldDecimal.java	2008-02-07 16:41:36 UTC (rev 131)
@@ -17,34 +17,35 @@
 
 Contributor(s): Jacob Northey <ja...@la...>
                 Craig Otis <co...@la...>
-*/
+ */
 
-
 /**
  *
  */
 package org.openfast.template.type.codec;
 
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
 import org.openfast.DecimalValue;
 import org.openfast.Global;
 import org.openfast.IntegerValue;
 import org.openfast.ScalarValue;
-
 import org.openfast.error.FastConstants;
+import org.openfast.template.LongValue;
 
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-
-
 final class SingleFieldDecimal extends TypeCodec {
     private static final long serialVersionUID = 1L;
 
-	SingleFieldDecimal() { }
+    SingleFieldDecimal() {
+    }
 
     /**
      * Takes a ScalarValue object, and converts it to a byte array
-     * @param v The ScalarValue to be encoded
+     * 
+     * @param v
+     *            The ScalarValue to be encoded
      * @return Returns a byte array of the passed object
      */
     public byte[] encodeValue(ScalarValue v) {
@@ -57,12 +58,11 @@
 
         try {
             if (Math.abs(value.exponent) > 63) {
-                Global.handleError(FastConstants.R1_LARGE_DECIMAL,
-                    "Encountered exponent of size " + value.exponent);
+                Global.handleError(FastConstants.R1_LARGE_DECIMAL, "Encountered exponent of size " + value.exponent);
             }
 
             buffer.write(TypeCodec.INTEGER.encode(new IntegerValue(value.exponent)));
-            buffer.write(TypeCodec.INTEGER.encode(new IntegerValue(value.mantissa)));
+            buffer.write(TypeCodec.INTEGER.encode(new LongValue(value.mantissa)));
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
@@ -72,15 +72,16 @@
 
     /**
      * Reads in a stream of data and stores it to a decimalValue object
-     * @param in The InputStream to be decoded
+     * 
+     * @param in
+     *            The InputStream to be decoded
      * @return Returns a decimalValue object with the data stream
      */
     public ScalarValue decode(InputStream in) {
         int exponent = ((IntegerValue) TypeCodec.INTEGER.decode(in)).value;
 
         if (Math.abs(exponent) > 63) {
-            Global.handleError(FastConstants.R1_LARGE_DECIMAL,
-                "Encountered exponent of size " + exponent);
+            Global.handleError(FastConstants.R1_LARGE_DECIMAL, "Encountered exponent of size " + exponent);
         }
 
         int mantissa = ((IntegerValue) TypeCodec.INTEGER.decode(in)).value;
@@ -90,8 +91,11 @@
     }
 
     /**
-     * Convert a string to a DecimalValue object with the string as the passed value
-     * @param value The value as a string to be converted
+     * Convert a string to a DecimalValue object with the string as the passed
+     * value
+     * 
+     * @param value
+     *            The value as a string to be converted
      * @return Returns a new DecimalValue object
      */
     public ScalarValue fromString(String value) {
@@ -106,7 +110,7 @@
         return new DecimalValue(0.0);
     }
 
-	public boolean equals(Object obj) {
-		return obj != null && obj.getClass() == getClass();
-	}
+    public boolean equals(Object obj) {
+        return obj != null && obj.getClass() == getClass();
+    }
 }

Added: trunk/src/test/java/org/openfast/submitted/LargeValuesTest.java
===================================================================
--- trunk/src/test/java/org/openfast/submitted/LargeValuesTest.java	                        (rev 0)
+++ trunk/src/test/java/org/openfast/submitted/LargeValuesTest.java	2008-02-07 16:41:36 UTC (rev 131)
@@ -0,0 +1,27 @@
+package org.openfast.submitted;
+
+import org.openfast.IntegerValue;
+import org.openfast.Message;
+import org.openfast.QName;
+import org.openfast.codec.FastDecoder;
+import org.openfast.codec.FastEncoder;
+import org.openfast.template.MessageTemplate;
+import org.openfast.template.operator.Operator;
+import org.openfast.test.OpenFastTestCase;
+import org.openfast.util.Util;
+
+public class LargeValuesTest extends OpenFastTestCase {
+
+    public void testLargeDecimal() {
+        MessageTemplate composed = 
+            template(Util.composedDecimal(new QName("Line1"), Operator.COPY, new IntegerValue(-2), 
+                                                              Operator.COPY, new IntegerValue(94276), true));
+        FastEncoder encoder = encoder(composed);
+        Message message = (Message) composed.createValue(null);
+        message.setDecimal(1, 987654321.123456);
+        
+        byte[] encoded = encoder.encode(message);
+        FastDecoder decoder = decoder(composed, encoded);
+        assertEquals(message, decoder.readMessage());
+    }
+}

Modified: trunk/src/test/java/org/openfast/template/operator/DefaultOperatorTest.java
===================================================================
--- trunk/src/test/java/org/openfast/template/operator/DefaultOperatorTest.java	2008-02-07 16:34:58 UTC (rev 130)
+++ trunk/src/test/java/org/openfast/template/operator/DefaultOperatorTest.java	2008-02-07 16:41:36 UTC (rev 131)
@@ -1,5 +1,6 @@
 package org.openfast.template.operator;
 
+import org.openfast.Context;
 import org.openfast.IntegerValue;
 import org.openfast.Message;
 import org.openfast.QName;
@@ -12,25 +13,43 @@
 
 public class DefaultOperatorTest extends OpenFastTestCase {
 
-	public void testNullsNoInitialValue() throws Exception {
-		Scalar field = new Scalar(new QName("mostlyNull"), Type.I32, Operator.DEFAULT, ScalarValue.UNDEFINED, true);
-		MessageTemplate template = template(field);
-		FastEncoder encoder = encoder(template);
-		
-		Message message = (Message) template.createValue(null);
-		assertEquals("11000000 10000001", encoder.encode(message));
-		assertEquals("10000000", encoder.encode(message));
-	}
-	
-	public void testNullsWithInitialValue() throws Exception {
-		Scalar field = new Scalar(new QName("sometimesNull"), Type.I32, Operator.DEFAULT, new IntegerValue(10), true);
-		MessageTemplate template = template(field);
-		FastEncoder encoder = encoder(template);
-		
-		Message message = (Message) template.createValue(null);
-		assertEquals("11100000 10000001 10000000", encoder.encode(message));
-		assertEquals("10100000 10000000", encoder.encode(message));
-		message.setInteger(1, 10);
-		assertEquals("10000000", encoder.encode(message));
-	}
+    public void testNullsNoInitialValue() throws Exception {
+        Scalar field = new Scalar(new QName("mostlyNull"), Type.I32, Operator.DEFAULT, ScalarValue.UNDEFINED, true);
+        MessageTemplate template = template(field);
+        FastEncoder encoder = encoder(template);
+
+        Message message = (Message) template.createValue(null);
+        assertEquals("11000000 10000001", encoder.encode(message));
+        assertEquals("10000000", encoder.encode(message));
+    }
+
+    public void testNullsWithInitialValue() throws Exception {
+        Scalar field = new Scalar(new QName("sometimesNull"), Type.I32, Operator.DEFAULT, new IntegerValue(10), true);
+        MessageTemplate template = template(field);
+        FastEncoder encoder = encoder(template);
+
+        Message message = (Message) template.createValue(null);
+        assertEquals("11100000 10000001 10000000", encoder.encode(message));
+        assertEquals("10100000 10000000", encoder.encode(message));
+        message.setInteger(1, 10);
+        assertEquals("10000000", encoder.encode(message));
+    }
+
+    public void testNullValueDoesntAlterDictionary() {
+        Scalar copyField = new Scalar(new QName("value"), Type.I32, Operator.COPY, new IntegerValue(10), true);
+        Scalar field = new Scalar(new QName("value"), Type.I32, Operator.DEFAULT, new IntegerValue(10), true);
+        MessageTemplate copyTemplate = template(copyField);
+        MessageTemplate template = template(field);
+        Context context = new Context();
+        FastEncoder encoder = new FastEncoder(context);
+        encoder.registerTemplate(1, template);
+        encoder.registerTemplate(2, copyTemplate);
+        Message message = (Message) copyTemplate.createValue(null);
+        message.setInteger(1, 11);
+        encoder.encode(message);
+        assertEquals(11, context.lookup("global", copyTemplate, new QName("value")).toInt());
+        message = (Message) template.createValue(null);
+        encoder.encode(message);
+        assertEquals(11, context.lookup("global", copyTemplate, new QName("value")).toInt());
+    }
 }

Modified: trunk/src/test/java/org/openfast/template/type/codec/ComposedDecimalTest.java
===================================================================
--- trunk/src/test/java/org/openfast/template/type/codec/ComposedDecimalTest.java	2008-02-07 16:34:58 UTC (rev 130)
+++ trunk/src/test/java/org/openfast/template/type/codec/ComposedDecimalTest.java	2008-02-07 16:41:36 UTC (rev 131)
@@ -10,125 +10,133 @@
 import org.openfast.ScalarValue;
 import org.openfast.template.ComposedScalar;
 import org.openfast.template.Field;
+import org.openfast.template.LongValue;
 import org.openfast.template.MessageTemplate;
 import org.openfast.template.operator.Operator;
 import org.openfast.test.OpenFastTestCase;
 import org.openfast.util.Util;
 
-
 public class ComposedDecimalTest extends OpenFastTestCase {
-	QName name = new QName("Value");
-	MessageTemplate template = new MessageTemplate("", new Field[] { });
-	
-	public void testSimple() {
-		String encoding = "11111110 00111001 01000101 10100011";
-		
-		ComposedScalar scalar = Util.composedDecimal(name, Operator.COPY, ScalarValue.UNDEFINED, Operator.DELTA, ScalarValue.UNDEFINED, true);
-		
-		assertEquals(encoding, scalar.encode(d(942755, -2), template, new Context(), new BitVectorBuilder(7)));
-		assertEquals(d(942755, -2), scalar.decode(bitStream(encoding), template, new Context(), pmapReader("11000000")));
-	}
-	
-	private BitVectorReader pmapReader(String bits) {
-		return new BitVectorReader(new BitVector(ByteUtil.convertBitStringToFastByteArray(bits)));
-	}
+    QName name = new QName("Value");
 
-	public void testInitialValues() {
-		Context context = new Context();
-		ComposedScalar scalar = Util.composedDecimal(name, Operator.DEFAULT, i(-3), Operator.DELTA, ScalarValue.UNDEFINED, false);
-		assertEquals("00000101 01100000 11110101", scalar.encode(d(94325, -3), template, context, new BitVectorBuilder(7)));
-		assertEquals("11100111", scalar.encode(d(94300, -3), template, context, new BitVectorBuilder(7)));
-		assertEquals("11100111", scalar.encode(d(94275, -3), template, context, new BitVectorBuilder(7)));
-		assertEquals("00000000 11001011", scalar.encode(d(94350, -3), template, context, new BitVectorBuilder(7)));
-		assertEquals("10011001", scalar.encode(d(94375, -3), template, context, new BitVectorBuilder(7)));
-		assertEquals("10011001", scalar.encode(d(94400, -3), template, context, new BitVectorBuilder(7)));
-		assertEquals("01111111 10000011", scalar.encode(d(94275, -3), template, context, new BitVectorBuilder(7)));
-		assertEquals("11100111", scalar.encode(d(94250, -3), template, context, new BitVectorBuilder(7)));
-		assertEquals("11100111", scalar.encode(d(94225, -3), template, context, new BitVectorBuilder(7)));
-		assertEquals("00000000 11111101", scalar.encode(d(94350, -3), template, context, new BitVectorBuilder(7)));
+    MessageTemplate template = new MessageTemplate("", new Field[] {});
 
-		context = new Context();
-		assertEquals(d(94325, -3), scalar.decode(bitStream("00000101 01100000 11110101"), template, context, pmapReader("10100000")));
-		assertEquals(d(94300, -3), scalar.decode(bitStream("11100111"), template, context, pmapReader("10100000")));
-		assertEquals(d(94275, -3), scalar.decode(bitStream("11100111"), template, context, pmapReader("10100000")));
-		assertEquals(d(94350, -3), scalar.decode(bitStream("00000000 11001011"), template, context, pmapReader("10100000")));
-		assertEquals(d(94375, -3), scalar.decode(bitStream("10011001"), template, context, pmapReader("10100000")));
-		assertEquals(d(94400, -3), scalar.decode(bitStream("10011001"), template, context, pmapReader("10100000")));
-		assertEquals(d(94275, -3), scalar.decode(bitStream("01111111 10000011"), template, context, pmapReader("10100000")));
-		assertEquals(d(94250, -3), scalar.decode(bitStream("11100111"), template, context, pmapReader("10100000")));
-		assertEquals(d(94225, -3), scalar.decode(bitStream("11100111"), template, context, pmapReader("10100000")));
-		assertEquals(d(94350, -3), scalar.decode(bitStream("00000000 11111101"), template, context, pmapReader("10100000")));
-	}
-	
-	public void testCopyExponentDeltaMantissa() {
-		ComposedScalar decimal = Util.composedDecimal(name, Operator.COPY, ScalarValue.UNDEFINED, Operator.DELTA, new IntegerValue(1), false);
-		Context context = new Context();
-		BitVectorBuilder pmapBuilder = new BitVectorBuilder(7);
-		assertEquals("11111110 00000001 00010110 10101100", decimal.encode(d(19245, -2), template, context , pmapBuilder));
-		assertEquals("11000000", pmapBuilder.getBitVector().getBytes());
-		pmapBuilder = new BitVectorBuilder(7);
-		assertEquals("11111100", decimal.encode(d(19241, -2), template, context , pmapBuilder));
-		assertEquals("10000000", pmapBuilder.getBitVector().getBytes());
-	}
-	
-	public void testCopyExponentDefaultMantissa() {
-		ComposedScalar decimal = Util.composedDecimal(name, Operator.COPY, ScalarValue.UNDEFINED, Operator.DEFAULT, new IntegerValue(1), false);
-		Context context = new Context();
-		BitVectorBuilder pmapBuilder = new BitVectorBuilder(7);
-		assertEquals("11111110 00000001 00010110 10101101", decimal.encode(d(19245, -2), template, context , pmapBuilder));
-		assertEquals("11100000", pmapBuilder.getBitVector().getBytes());
-		
-		pmapBuilder = new BitVectorBuilder(7);
-		assertEquals("00000001 00010110 10101001", decimal.encode(d(19241, -2), template, context , pmapBuilder));
-		assertEquals("10100000", pmapBuilder.getBitVector().getBytes());
+    public void testSimple() {
+        String encoding = "11111110 00111001 01000101 10100011";
 
-		pmapBuilder = new BitVectorBuilder(7);
-		assertEquals("10000000", decimal.encode(d(1, 0), template, context , pmapBuilder));
-		assertEquals("11000000", pmapBuilder.getBitVector().getBytes());
-		
-		pmapBuilder = new BitVectorBuilder(7);
-		assertEquals("", decimal.encode(d(1, 0), template, context , pmapBuilder));
-		assertEquals("10000000", pmapBuilder.getBitVector().getBytes());
-		assertEquals(2, pmapBuilder.getIndex());
-	}
+        ComposedScalar scalar = Util.composedDecimal(name, Operator.COPY, ScalarValue.UNDEFINED, Operator.DELTA,
+                ScalarValue.UNDEFINED, true);
 
-	public void testOptionalDefaultNullExponent() {
-		ComposedScalar decimal = Util.composedDecimal(name, Operator.DEFAULT, ScalarValue.UNDEFINED, Operator.DELTA, new IntegerValue(12200), true);
-		Context context = new Context();
-		BitVectorBuilder pmapBuilder = new BitVectorBuilder(7);
-		
-		assertEquals("", decimal.encode(null, template, context , pmapBuilder));
-		assertEquals("10000000", pmapBuilder.getBitVector().getBytes());
-		assertEquals(1, pmapBuilder.getIndex()); // ONLY ONE PMAP BIT SHOULD BE WRITTEN
-		
-		pmapBuilder = new BitVectorBuilder(7);
-		assertEquals("11111110 10000001", decimal.encode(d(12201, -2), template, context , pmapBuilder));
-		assertEquals("11000000", pmapBuilder.getBitVector().getBytes());
-		assertEquals(1, pmapBuilder.getIndex());
-	}
-	
-	public void testOptionalConstantExponent() {
-		ComposedScalar decimal = Util.composedDecimal(name, Operator.CONSTANT, new IntegerValue(-2), Operator.DEFAULT, new IntegerValue(100), true);
-		Context context = new Context();
-		BitVectorBuilder pmapBuilder = new BitVectorBuilder(7);
-		
-		assertEquals("", decimal.encode(d(100, -2), template, context , pmapBuilder));
-		assertEquals("11000000", pmapBuilder.getBitVector().getBytes());
-		assertEquals(2, pmapBuilder.getIndex());
-	}
-	
-	public void testOptionalDeltaExponentCopyMantissa() {
-		ComposedScalar decimal = Util.composedDecimal(name, Operator.DELTA, ScalarValue.UNDEFINED, Operator.COPY, ScalarValue.UNDEFINED, true);
-		Context context = new Context();
-		BitVectorBuilder pmapBuilder = new BitVectorBuilder(7);
+        assertEquals(encoding, scalar.encode(d(942755, -2), template, new Context(), new BitVectorBuilder(7)));
+        assertEquals(d(942755, -2), scalar.decode(bitStream(encoding), template, new Context(), pmapReader("11000000")));
+    }
 
-		assertEquals("10000000", decimal.encode(null, template, context , pmapBuilder));
-		assertEquals("10000000", pmapBuilder.getBitVector().getBytes());
-		assertEquals(0, pmapBuilder.getIndex());
+    private BitVectorReader pmapReader(String bits) {
+        return new BitVectorReader(new BitVector(ByteUtil.convertBitStringToFastByteArray(bits)));
+    }
 
-		pmapBuilder = new BitVectorBuilder(7);
-		assertEquals("10000001 10000001", decimal.encode(d(1, 0), template, context , pmapBuilder));
-		assertEquals("11000000", pmapBuilder.getBitVector().getBytes());
-		assertEquals(1, pmapBuilder.getIndex());
-	}
+    public void testInitialValues() {
+        Context context = new Context();
+        ComposedScalar scalar = Util.composedDecimal(name, Operator.DEFAULT, i(-3), Operator.DELTA, ScalarValue.UNDEFINED, false);
+        assertEquals("00000101 01100000 11110101", scalar.encode(d(94325, -3), template, context, new BitVectorBuilder(7)));
+        assertEquals("11100111", scalar.encode(d(94300, -3), template, context, new BitVectorBuilder(7)));
+        assertEquals("11100111", scalar.encode(d(94275, -3), template, context, new BitVectorBuilder(7)));
+        assertEquals("00000000 11001011", scalar.encode(d(94350, -3), template, context, new BitVectorBuilder(7)));
+        assertEquals("10011001", scalar.encode(d(94375, -3), template, context, new BitVectorBuilder(7)));
+        assertEquals("10011001", scalar.encode(d(94400, -3), template, context, new BitVectorBuilder(7)));
+        assertEquals("01111111 10000011", scalar.encode(d(94275, -3), template, context, new BitVectorBuilder(7)));
+        assertEquals("11100111", scalar.encode(d(94250, -3), template, context, new BitVectorBuilder(7)));
+        assertEquals("11100111", scalar.encode(d(94225, -3), template, context, new BitVectorBuilder(7)));
+        assertEquals("00000000 11111101", scalar.encode(d(94350, -3), template, context, new BitVectorBuilder(7)));
+
+        context = new Context();
+        assertEquals(d(94325, -3), scalar.decode(bitStream("00000101 01100000 11110101"), template, context, pmapReader("10100000")));
+        assertEquals(d(94300, -3), scalar.decode(bitStream("11100111"), template, context, pmapReader("10100000")));
+        assertEquals(d(94275, -3), scalar.decode(bitStream("11100111"), template, context, pmapReader("10100000")));
+        assertEquals(d(94350, -3), scalar.decode(bitStream("00000000 11001011"), template, context, pmapReader("10100000")));
+        assertEquals(d(94375, -3), scalar.decode(bitStream("10011001"), template, context, pmapReader("10100000")));
+        assertEquals(d(94400, -3), scalar.decode(bitStream("10011001"), template, context, pmapReader("10100000")));
+        assertEquals(d(94275, -3), scalar.decode(bitStream("01111111 10000011"), template, context, pmapReader("10100000")));
+        assertEquals(d(94250, -3), scalar.decode(bitStream("11100111"), template, context, pmapReader("10100000")));
+        assertEquals(d(94225, -3), scalar.decode(bitStream("11100111"), template, context, pmapReader("10100000")));
+        assertEquals(d(94350, -3), scalar.decode(bitStream("00000000 11111101"), template, context, pmapReader("10100000")));
+    }
+
+    public void testCopyExponentDeltaMantissa() {
+        ComposedScalar decimal = Util.composedDecimal(name, Operator.COPY, ScalarValue.UNDEFINED, Operator.DELTA, new IntegerValue(1),
+                false);
+        Context context = new Context();
+        BitVectorBuilder pmapBuilder = new BitVectorBuilder(7);
+        assertEquals("11111110 00000001 00010110 10101100", decimal.encode(d(19245, -2), template, context, pmapBuilder));
+        assertEquals("11000000", pmapBuilder.getBitVector().getBytes());
+        pmapBuilder = new BitVectorBuilder(7);
+        assertEquals("11111100", decimal.encode(d(19241, -2), template, context, pmapBuilder));
+        assertEquals("10000000", pmapBuilder.getBitVector().getBytes());
+    }
+
+    public void testCopyExponentDefaultMantissa() {
+        ComposedScalar decimal = Util.composedDecimal(name, Operator.COPY, ScalarValue.UNDEFINED, Operator.DEFAULT,
+                new LongValue(1), false);
+        Context context = new Context();
+        BitVectorBuilder pmapBuilder = new BitVectorBuilder(7);
+        assertEquals("11111110 00000001 00010110 10101101", decimal.encode(d(19245, -2), template, context, pmapBuilder));
+        assertEquals("11100000", pmapBuilder.getBitVector().getBytes());
+
+        pmapBuilder = new BitVectorBuilder(7);
+        assertEquals("00000001 00010110 10101001", decimal.encode(d(19241, -2), template, context, pmapBuilder));
+        assertEquals("10100000", pmapBuilder.getBitVector().getBytes());
+
+        pmapBuilder = new BitVectorBuilder(7);
+        assertEquals("10000000", decimal.encode(d(1, 0), template, context, pmapBuilder));
+        assertEquals("11000000", pmapBuilder.getBitVector().getBytes());
+
+        pmapBuilder = new BitVectorBuilder(7);
+        assertEquals("", decimal.encode(d(1, 0), template, context, pmapBuilder));
+        assertEquals("10000000", pmapBuilder.getBitVector().getBytes());
+        assertEquals(2, pmapBuilder.getIndex());
+    }
+
+    public void testOptionalDefaultNullExponent() {
+        ComposedScalar decimal = Util.composedDecimal(name, Operator.DEFAULT, ScalarValue.UNDEFINED, Operator.DELTA, new IntegerValue(
+                12200), true);
+        Context context = new Context();
+        BitVectorBuilder pmapBuilder = new BitVectorBuilder(7);
+
+        assertEquals("", decimal.encode(null, template, context, pmapBuilder));
+        assertEquals("10000000", pmapBuilder.getBitVector().getBytes());
+        assertEquals(1, pmapBuilder.getIndex()); // ONLY ONE PMAP BIT SHOULD
+                                                    // BE WRITTEN
+
+        pmapBuilder = new BitVectorBuilder(7);
+        assertEquals("11111110 10000001", decimal.encode(d(12201, -2), template, context, pmapBuilder));
+        assertEquals("11000000", pmapBuilder.getBitVector().getBytes());
+        assertEquals(1, pmapBuilder.getIndex());
+    }
+
+    public void testOptionalConstantExponent() {
+        ComposedScalar decimal = Util.composedDecimal(name, Operator.CONSTANT, new IntegerValue(-2), Operator.DEFAULT,
+                new LongValue(100), true);
+        Context context = new Context();
+        BitVectorBuilder pmapBuilder = new BitVectorBuilder(7);
+
+        assertEquals("", decimal.encode(d(100, -2), template, context, pmapBuilder));
+        assertEquals("11000000", pmapBuilder.getBitVector().getBytes());
+        assertEquals(2, pmapBuilder.getIndex());
+    }
+
+    public void testOptionalDeltaExponentCopyMantissa() {
+        ComposedScalar decimal = Util.composedDecimal(name, Operator.DELTA, ScalarValue.UNDEFINED, Operator.COPY,
+                ScalarValue.UNDEFINED, true);
+        Context context = new Context();
+        BitVectorBuilder pmapBuilder = new BitVectorBuilder(7);
+
+        assertEquals("10000000", decimal.encode(null, template, context, pmapBuilder));
+        assertEquals("10000000", pmapBuilder.getBitVector().getBytes());
+        assertEquals(0, pmapBuilder.getIndex());
+
+        pmapBuilder = new BitVectorBuilder(7);
+        assertEquals("10000001 10000001", decimal.encode(d(1, 0), template, context, pmapBuilder));
+        assertEquals("11000000", pmapBuilder.getBitVector().getBytes());
+        assertEquals(1, pmapBuilder.getIndex());
+    }
 }


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




2007	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct (4)	Nov (7)	Dec (18)
2008	Jan (20)	Feb (7)	Mar	Apr (8)	May (9)	Jun (7)	Jul (23)	Aug (3)	Sep	Oct (16)	Nov	Dec (3)
2009	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug (1)	Sep	Oct	Nov	Dec
2010	Jan	Feb	Mar (1)	Apr	May (6)	Jun (8)	Jul	Aug	Sep	Oct (5)	Nov (2)	Dec
2011	Jan	Feb	Mar	Apr	May	Jun (1)	Jul	Aug	Sep (1)	Oct (30)	Nov	Dec
2012	Jan (4)	Feb (2)	Mar (1)	Apr (23)	May (4)	Jun	Jul (1)	Aug (2)	Sep	Oct	Nov	Dec
2013	Jan	Feb	Mar (7)	Apr	May (1)	Jun	Jul	Aug (1)	Sep	Oct	Nov	Dec

openfast-commit Mailing List for OpenFAST (Page 8)

openfast-commit — Publishes subversion log and diffs on each commit