public void ReadUInt64Test()
        {
            UInt64      expected = UInt64.MaxValue - 64;
            SuperStream target   = new SuperStream(Endianess.Little);

            target.WriteSingle(expected);
            target.Position = 0;
            var actual = target.ReadSingle();

            Assert.AreEqual(expected, actual);
        }
        public void SingleTest()
        {
            Single      expected = Single.MaxValue - 32.32f;
            SuperStream target   = new SuperStream(Endianess.Little);

            target.WriteSingle(expected);
            target.Position = 0;
            var actual = target.ReadSingle();

            Assert.AreEqual(expected, actual);
        }
        private bool GetValue(Type dataType, SuperStream stream, out object value)
        {
            if (dataType == typeof(Byte))
            {
                value = (byte)stream.ReadByte();
                return(true);
            }

            if (dataType == typeof(Int64))
            {
                value = stream.ReadInt64();
                return(true);
            }
            if (dataType == typeof(UInt64))
            {
                value = stream.ReadUInt64();
                return(true);
            }

            if (dataType == typeof(Int32))
            {
                value = stream.ReadInt32();
                return(true);
            }
            if (dataType == typeof(UInt32))
            {
                value = stream.ReadUInt32();
                return(true);
            }

            if (dataType == typeof(Int16))
            {
                value = stream.ReadInt16();
                return(true);
            }
            if (dataType == typeof(UInt16))
            {
                value = stream.ReadUInt16();
                return(true);
            }

            if (dataType == typeof(Single))
            {
                value = stream.ReadSingle();
                return(true);
            }

            if (dataType == typeof(Double))
            {
                value = stream.ReadDouble();
                return(true);
            }

            if (dataType == typeof(bool))
            {
                var val = stream.ReadUInt32();
                if (val == 0)
                {
                    value = false;
                    return(true);
                }
                else if (val == 1)
                {
                    value = true;
                    return(true);
                }
                else
                {
                    throw new Exception("Parsing type bool: Expected value to be either 0 or 1, but it was " + val.ToString());
                }
            }

            if (dataType.IsEnum)
            {
                object readValue;
                // Read the enums underlying type
                if (!this.GetValue(Enum.GetUnderlyingType(dataType), stream, out readValue))
                {
                    value = null;
                    return(false);
                }
                // Parse enum using the read value.
                value = Enum.ToObject(dataType, readValue);
                return(true);
            }

            // Test if type has StreamDataAttribute on properties.
            // This allows nesting of StreamData-aware task.DataTypes
            var props = StreamDataInfo.GetProperties(dataType);

            if (props.Length == 0)
            {
                value = null;
                return(false);
            }

            value = StreamData.Create(dataType, stream);
            if (value == null)
            {
                return(false);
            }
            return(true);
        }