internal static Datatype ReadMessage( DatatypeHeader aHeader, Hdf5Reader aReader, long?aLocalMessageSize, out long aBytes) { if (aHeader.Class != DatatypeClass.Opaque) { throw new ArgumentException( $"aHeader must be for type {nameof(DatatypeClass.Compound)}"); } int fTagSize = (int)aHeader.Flags & byte.MaxValue; if (aLocalMessageSize.HasValue && aLocalMessageSize < fTagSize) { throw new ArgumentException("Specified Local Message Size not long enough"); } aBytes = fTagSize; IEnumerable <MemberEntry> fMembers = null; return(new CompoundDataType( aHeader, fMembers)); }
public void TestBasicLengthedNilRead( [Values] uMessages.MessageAttributeFlag aFlags, [Values(2, 4, 8)] int aOffsetBytes, [Values(2, 4, 8)] int aLengthBytes, [Values(0, 2, 4, 8, 255, 2047)] int aReadBytes) { Mock <ndf5.Metadata.ISuperBlock> fSuperBlock = new Mock <ndf5.Metadata.ISuperBlock>(MockBehavior.Loose); fSuperBlock.SetupGet(a => a.SizeOfOffsets).Returns((byte)aOffsetBytes); fSuperBlock.SetupGet(a => a.SizeOfLengths).Returns((byte)aLengthBytes); Hdf5Reader fReader = new Hdf5Reader(new System.IO.MemoryStream(new byte[0]), fSuperBlock.Object); long fRead; uMessages.Message fShortTest = ndf5.Messages.Message.Read( fReader, uMessages.MessageType.NIL, aFlags, (long)aReadBytes, out fRead); Assert.That(fShortTest, Is.InstanceOf(typeof(uMessages.Nil)), "Incorrect Message type parsed"); Assert.That(fRead, Is.EqualTo(0), "Zero bytes should be read"); }
public void Test_SixteenBit_Example() { //Arrange using (Stream fTestSource = new MemoryStream()) using (BinaryWriter fWriter = new BinaryWriter(fTestSource)) { fWriter.Write(new byte[] { 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, }); fTestSource.Seek(0, SeekOrigin.Begin); Moq.Mock <ndf5.Metadata.ISuperBlock> fSuperblock = new Moq.Mock <ndf5.Metadata.ISuperBlock>( Moq.MockBehavior.Loose); using (Hdf5Reader fReader = new Hdf5Reader( fTestSource, fSuperblock.Object)) { long fReadBytes; uTest fResult = ndf5.Messages.Message.Read( fReader, uMessages.MessageType.Datatype, uMessages.MessageAttributeFlag.None, null, out fReadBytes) as uTest; Assert.That( fResult, Is.Not.Null, "Incorrect Message Type returned"); Assert.That( fReadBytes, Is.EqualTo(12), "Wrong number of bytes read"); Assert.That( fTestSource.Position, Is.EqualTo(12), "Wrong number of bytes read"); Assert.That( fResult.Class, Is.EqualTo(uMessages.DatatypeClass.Time), "Incorrect Data class"); Assert.That( fResult.ByteOrdering, Is.EqualTo(ByteOrdering.LittleEndian), "Incorrect byte ordering"); Assert.That( fResult.Size, Is.EqualTo(4), "Incorrect Data Element Size"); Assert.That( fResult.BitPrecision, Is.EqualTo(32), "Incorrect bit precision"); } } }
internal static Datatype ReadMessage( DatatypeHeader aHeader, Hdf5Reader aReader, long?aLocalMessageSize, out long aBytes) { if (aHeader.Class != DatatypeClass.Time) { throw new ArgumentException( $"aHeader must be for type {nameof(DatatypeClass.Time)}"); } if (aLocalMessageSize.HasValue && aLocalMessageSize < mcAddionalSize) { throw new ArgumentException("Specified Local Message Size not long enough"); } Flags fFlags = (Flags)aHeader.Flags; ByteOrdering fByteOrdering = fFlags.HasFlag(Flags.BigEndian) ? ByteOrdering.BigEndian : ByteOrdering.LittleEndian; uint fBitPrecision = aReader.ReadUInt32(); aBytes = mcAddionalSize; return(new TimeDataType( aHeader, fByteOrdering, fBitPrecision)); }
/// <summary> /// Read the specified aStream and aLocation. /// </summary> /// <returns>The read.</returns> /// <param name="aStream">A stream.</param> /// <param name="aLocation">A location.</param> public static SymbolTableEntry Read( Hdf5Reader aReader) { Offset fLinkNameOffset = aReader.ReadOffset(); Offset fObjectHeaderAddress = aReader.ReadOffset(); CacheType fCacheType = (CacheType)aReader.ReadUInt32(); aReader.ReadUInt32(); // Reserved Word switch (fCacheType) { case CacheType.NoCache: return(new SymbolTableEntry( fLinkNameOffset, fObjectHeaderAddress)); case CacheType.Cache: return(new SymbolTableEntry( fLinkNameOffset, fObjectHeaderAddress, aReader.ReadOffset(), aReader.ReadOffset())); case CacheType.SymbolicLink: return(new SymbolTableEntry( fLinkNameOffset, fObjectHeaderAddress, aReader.ReadUInt32())); default: throw new InvalidDataException($"Unknown {nameof(CacheType)}"); } }
public void Short_Read_Checking_Test( [Range(0, 11)] int aNumBytesGiven) { using (Stream fTestSource = new MemoryStream()) using (BinaryWriter fWriter = new BinaryWriter(fTestSource)) { fWriter.Write(new byte[] { 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }); fTestSource.Seek(0, SeekOrigin.Begin); Moq.Mock <ndf5.Metadata.ISuperBlock> fSuperblock = new Moq.Mock <ndf5.Metadata.ISuperBlock>( Moq.MockBehavior.Loose); using (Hdf5Reader fReader = new Hdf5Reader( fTestSource, fSuperblock.Object)) { long fReadBytes; Assert.That(() => { ndf5.Messages.Message.Read( fReader, uMessages.MessageType.Datatype, uMessages.MessageAttributeFlag.None, aNumBytesGiven, out fReadBytes); }, Throws.ArgumentException, "Length not checked"); } } }
/// <summary> /// Parse the specified SymbolTableEntry frome aStreamProvider and aLocation. /// </summary> /// <returns>The parsed SymbolTableEntry</returns> /// <param name="aStreamProvider">A stream provider.</param> /// <param name="aLocation">The location in the stream of the SymbolTableEntry</param> public static SymbolTableEntry Parse( IHdfStreamProvider aStreamProvider, long aLocation) { using (Hdf5Reader aReader = aStreamProvider.GetReader()) { return(Read(aReader)); } }
/// <summary> /// Initializes a new instance of the <see cref="T:ndf5.Infrastructure.BTrees.V1.Node"/> class. /// </summary> /// <param name="aStreamProvider">A stream provider.</param> /// <param name="aLocation">A location in the stream of this Node</param> public static Node Parse( IHdfStreamProvider aStreamProvider, Offset aLocation) { using (Hdf5Reader fReader = aStreamProvider.GetReader()) { return(new Node(fReader, aLocation)); } }
public void Short_Stream_Check( [Values] uMessages.DatatypeClass aDatatypeClass, [Values] uMessages.DatatypeVersion aVersion) { using (Stream fTestSource = new MemoryStream()) using (BinaryWriter fWriter = new BinaryWriter(fTestSource)) { fWriter.Write((byte)(((byte)aVersion << 4) | ((byte)aDatatypeClass))); fWriter.Write(new byte[] { 0x00, 0x00, }); fTestSource.Seek(0, SeekOrigin.Begin); Moq.Mock <ndf5.Metadata.ISuperBlock> fSuperblock = new Moq.Mock <ndf5.Metadata.ISuperBlock>( Moq.MockBehavior.Loose); using (Hdf5Reader fReader = new Hdf5Reader( fTestSource, fSuperblock.Object)) { long fReadBytes; Assert.That(() => { ndf5.Messages.Message.Read( fReader, uMessages.MessageType.Datatype, uMessages.MessageAttributeFlag.None, 12, out fReadBytes); }, Throws.Exception.TypeOf(typeof(System.IO.EndOfStreamException)), "Length not checked"); //Add three more bytes to get past the header length fWriter.Write(new byte[] { 0x10, 0x00, 0x00, }); fTestSource.Seek(0, SeekOrigin.Begin); Assert.That(() => { ndf5.Messages.Message.Read( fReader, uMessages.MessageType.Datatype, uMessages.MessageAttributeFlag.None, 12, out fReadBytes); }, Throws.Exception.TypeOf(typeof(System.IO.EndOfStreamException)), "Length not checked"); } } }
public static void Test_V1_Parse_Fail( [Values(0, 1, 12, 37, 42)] int aLength) { using (Stream fTestSource = new MemoryStream()) using (BinaryWriter fWriter = new BinaryWriter(fTestSource)) { fWriter.Write((byte)(((byte)DatatypeVersion.Version1 << 4) | 0x0A)); fWriter.Write((byte)0); fWriter.Write((byte)0); fWriter.Write((byte)0); fWriter.Write((byte)aLength); fWriter.Write((byte)0); fWriter.Write((byte)0); fWriter.Write((byte)0); System.Random fRandom = new Random(); for (int fIndex = 0; fIndex < aLength; ++fIndex) { int fRnd = fRandom.Next(); fWriter.Write(fRnd); } fTestSource.Seek(0, SeekOrigin.Begin); Moq.Mock <ndf5.Metadata.ISuperBlock> fSuperblock = new Moq.Mock <ndf5.Metadata.ISuperBlock>( Moq.MockBehavior.Loose); using (Hdf5Reader fReader = new Hdf5Reader( fTestSource, fSuperblock.Object)) { long fReadBytes; Assert.That(() => { uTest fResult = ndf5.Messages.Message.Read( fReader, MessageType.Datatype, MessageAttributeFlag.None, null, out fReadBytes) as uTest; }, Throws.Exception, "Version 1 should not parse"); } } }
internal static Message Read( Hdf5Reader aReader, long?aLocalMessageSize, out long aBytes) { //Read Message Headder data int fReadBytes = 4; //Always Read at least 4 byte fVersion = (byte)aReader.ReadByte(), fFlags = (byte)aReader.ReadByte(); aReader.ReadUInt16(); //Reserved if (fVersion != mcCurrentVersion) { throw new Exceptions.UnknownMessageVersion <LinkInfo>(fVersion); } bool fCreationOrderTracked = ((Flags)fFlags).HasFlag(Flags.CreationOrderTracked), fCreationOrderIndexed = ((Flags)fFlags).HasFlag(Flags.CreationOrderIndexed); //Calculate Length if (fCreationOrderTracked) { fReadBytes += 8; } fReadBytes += 2 * (int)aReader.SizeOfOffset; //Fractal Heap address, B-Tree adress if (fCreationOrderIndexed) { fReadBytes += (int)aReader.SizeOfOffset; } aBytes = fReadBytes; if (aLocalMessageSize.HasValue && fReadBytes > aLocalMessageSize.Value) { throw new ArgumentException("Specified Local Message Size not long enough"); } //Read Feilds and build the object LinkInfo fToReturn = new LinkInfo( fCreationOrderTracked ? aReader.ReadUInt64() : (ulong?)null, aReader.ReadOffset(), aReader.ReadOffset(), fCreationOrderIndexed, fCreationOrderIndexed ? aReader.ReadOffset() : (Offset)null); return(fToReturn); }
public static Version2 ReadAfterHeader( DSHeader aHeader, Hdf5Reader aReader, long?aLocalMessageSize, out long aBytes) { int fDimCount = aHeader.Dimensionality; long fReadlength = (fDimCount * aReader.SuperBlock.SizeOfLengths); Flags fHeaderFlags = (Flags)aHeader.Flags; bool fHasMax = fHeaderFlags.HasFlag(Flags.HasMax); if (fHasMax) { fReadlength *= 2; } if (aLocalMessageSize.HasValue && aLocalMessageSize.Value < fReadlength) { throw new ArgumentException("Specified Local Message Size not long enough"); } DataSpaceType fType; switch (aHeader.Type) { case (byte)DataSpaceType.Scaler: case (byte)DataSpaceType.Simple: case (byte)DataSpaceType.Null: fType = (DataSpaceType)aHeader.Type; break; default: throw new System.IO.InvalidDataException("Unknown DataSpaceType"); } aBytes = fReadlength; Dimension[] fDimensions = ReadDimensions( aReader, fHasMax, fDimCount); return(new Version2(fType, fDimensions)); }
public void Test_Data_Space_V2_Special_Parsing( [Values(uObjects.DataSpaceType.Null, uObjects.DataSpaceType.Scaler)] uObjects.DataSpaceType aType) { using (Stream fTestSource = new MemoryStream()) using (BinaryWriter fWriter = new BinaryWriter(fTestSource)) { fWriter.Write((byte)2); //Version 2 fWriter.Write((byte)0); //Dimensionality fWriter.Write((byte)0x1); //Flags, Has Max fWriter.Write((byte)aType); fTestSource.Seek(0, SeekOrigin.Begin); Mock <ndf5.Metadata.ISuperBlock> fSuperBlock = new Mock <ndf5.Metadata.ISuperBlock>(MockBehavior.Loose); fSuperBlock.SetupGet(a => a.SizeOfOffsets).Returns((byte)8); fSuperBlock.SetupGet(a => a.SizeOfLengths).Returns((byte)8); Hdf5Reader fReader = new Hdf5Reader(fTestSource, fSuperBlock.Object); //Act long fRead; uMessages.Message fTest = ndf5.Messages.Message.Read( fReader, uMessages.MessageType.Dataspace, uMessages.MessageAttributeFlag.None, null, out fRead); uMessages.Dataspace fResult = fTest as uMessages.Dataspace; //Assert Assert.That(fResult, Is.Not.Null, "Incorrect Message Type returned"); Assert.That(fResult.Dimensions.Count, Is.EqualTo(0), "Incorrect Dimensions"); Assert.That(fRead, Is.EqualTo(fTestSource.Position), "Incorrect Read Bytes"); Assert.That(fResult.DataSpaceType, Is.EqualTo(aType), "Incorrect object type"); } }
/// <summary> /// Reads the message at the current location of an Hdf5Reader /// </summary> /// <returns>The message.</returns> /// <param name="aReader">A reader.</param> /// <param name="aReadFlags">Flags that describe how to handle this message</param> /// <param name="aMessageType">Type of message to read</param> public static Message Read( Hdf5Reader aReader, MessageType aMessageType, MessageAttributeFlag aReadFlags) { long aDummy; return(Read( aReader, aMessageType, aReadFlags, null, out aDummy)); }
public static Version1 ReadAfterHeader( DSHeader aHeader, Hdf5Reader aReader, long?aLocalMessageSize, out long aBytes) { int fDimCount = aHeader.Dimensionality, fBlockLength = (fDimCount * aReader.SuperBlock.SizeOfLengths); long fReadlength = (fDimCount * aReader.SuperBlock.SizeOfLengths) + sizeof(UInt32); Flags fHeaderFlags = (Flags)aHeader.Flags; if (fHeaderFlags.HasFlag(Flags.HasPermutaions)) { throw new NotSupportedException("Permutation index not supported"); } bool fHasMax = fHeaderFlags.HasFlag(Flags.HasMax); if (fHasMax) { fReadlength += fBlockLength; } if (aLocalMessageSize.HasValue && aLocalMessageSize.Value < fReadlength) { throw new ArgumentException("Specified Local Message Size not long enough"); } aReader.ReadUInt32(); //Read reserved byte aBytes = fReadlength; Dimension[] fDimensions = ReadDimensions( aReader, fHasMax, fDimCount); return(new Version1(DataSpaceType.Simple, fDimensions)); }
public Node(Hdf5Reader aReader, Offset aLocation) : base( BTreeVerson.One, aLocation ?? aReader.Position) { aReader.VerifySignature(Signature); byte fType = (byte)aReader.ReadByte(); if (fType > (byte)NodeType.Data) { throw new InvalidDataException($"Unexpected Node Type: {fType}"); } this.NodeType = (NodeType)fType; this.NodeLevel = (byte)aReader.ReadByte(); this.EntriesUsed = aReader.ReadUInt16(); this.LeftSibling = aReader.ReadOffset(); this.RightSibling = aReader.ReadOffset(); }
internal static Dataspace Read( Hdf5Reader aReader, long?aLocalMessageSize, out long aBytes) { if (aLocalMessageSize.HasValue && aLocalMessageSize.Value < DSHeader.Size) { throw new ArgumentException("Specified Local Message Size not long enough"); } DSHeader fHeader = DSHeader.Read(aReader); long fMessageBodySize; Dataspace fToRetrun; long? fBodySize = aLocalMessageSize.HasValue ? (long?)aLocalMessageSize.Value - DSHeader.Size : null; switch (fHeader.Version) { case 1: fToRetrun = Version1.ReadAfterHeader( fHeader, aReader, fBodySize, out fMessageBodySize); break; case 2: fToRetrun = Version2.ReadAfterHeader( fHeader, aReader, fBodySize, out fMessageBodySize); break; default: throw new UnknownMessageVersion <Dataspace>(fHeader.Version); } aBytes = DSHeader.Size + fMessageBodySize; return(fToRetrun); }
/// <summary> /// Reads the message at the current location of an Hdf5Reader /// </summary> /// <returns>The message.</returns> /// <param name="aReader">A reader.</param> /// <param name="aReadFlags">Flags that describe how to handle this message</param> /// <param name="aMessageType">Type of message to read</param> /// <param name="aLocalMessageSize">Number of bytes to read</param> /// <param name="aBytes">Number of bytes that were actually read</param> public static Message Read( Hdf5Reader aReader, MessageType aMessageType, MessageAttributeFlag aReadFlags, long?aLocalMessageSize, out long aBytes) { switch (aMessageType) { case MessageType.NIL: aBytes = 0; return(new Nil()); case MessageType.Dataspace: return(Dataspace.Read( aReader, aLocalMessageSize, out aBytes)); case MessageType.LinkInfo: return(LinkInfo.Read( aReader, aLocalMessageSize, out aBytes)); case MessageType.Datatype: return(Datatype.Read( aReader, aLocalMessageSize, out aBytes)); default: if (aReadFlags.HasFlag(MessageAttributeFlag.MustUnderstandToRead)) { throw new Exceptions.RequiredMessageNotUnderstood( $"Message type {aMessageType} must be understood for this object to be valid"); } break; } throw new NotImplementedException();//TODO: Add 'Not Undestood' message }
internal static Datatype ReadMessage( DatatypeHeader aHeader, Hdf5Reader aReader, long?aLocalMessageSize, out long aBytes) { if (aHeader.Class != DatatypeClass.FixedPoint) { throw new ArgumentException( $"aHeader must be for type {nameof(DatatypeClass.FixedPoint)}"); } if (aLocalMessageSize.HasValue && aLocalMessageSize < mcAddionalSize) { throw new ArgumentException("Specified Local Message Size not long enough"); } Flags fFlags = (Flags)aHeader.Flags; ByteOrdering fByteOrdering = fFlags.HasFlag(Flags.BigEndian) ? ByteOrdering.BigEndian : ByteOrdering.LittleEndian; byte fLowPad = (byte)(fFlags.HasFlag(Flags.LowPad) ? 1 : 0), fHighPad = (byte)(fFlags.HasFlag(Flags.HighPad) ? 1 : 0); bool fIsSigned = fFlags.HasFlag(Flags.Signed); ushort fBitOffset = aReader.ReadUInt16(), fBitPrecision = aReader.ReadUInt16(); aBytes = mcAddionalSize; return(new FixedPointDataType( aHeader, fByteOrdering, fHighPad, fLowPad, fIsSigned, fBitOffset, fBitPrecision)); }
public static IObjectHeader Read(byte[] aHeadBytes, Hdf5Reader aReader) { List <Message> fMessages = new List <Message>(); ushort fMessageCount = (ushort)(aHeadBytes[2] + (aHeadBytes[3] << 8)); //Little endian read of already consumed data uint fObjectReferenceCount = aReader.ReadUInt32(), fObjectHeaderSize = aReader.ReadUInt32(); //long // fTerminate = aReader.Position + fObjectHeaderSize; //while(aReader.Position <= fTerminate) //{ //} throw new NotImplementedException(); }
public void TestBasicNilRead( [Values] uMessages.MessageAttributeFlag aFlags, [Values(2, 4, 8)] int aOffsetBytes, [Values(2, 4, 8)] int aLengthBytes) { Mock <ndf5.Metadata.ISuperBlock> fSuperBlock = new Mock <ndf5.Metadata.ISuperBlock>(MockBehavior.Loose); fSuperBlock.SetupGet(a => a.SizeOfOffsets).Returns((byte)aOffsetBytes); fSuperBlock.SetupGet(a => a.SizeOfLengths).Returns((byte)aLengthBytes); Hdf5Reader fReader = new Hdf5Reader(new System.IO.MemoryStream(new byte[0]), fSuperBlock.Object); uMessages.Message fShortTest = ndf5.Messages.Message.Read( fReader, uMessages.MessageType.NIL, aFlags); Assert.That(fShortTest, Is.InstanceOf(typeof(uMessages.Nil))); }
internal static Datatype ReadMessage( DatatypeHeader aHeader, Hdf5Reader aReader, long?aLocalMessageSize, out long aBytes) { if (aHeader.Class != DatatypeClass.Opaque) { throw new ArgumentException( $"aHeader must be for type {nameof(DatatypeClass.Opaque)}"); } int fTagSize = (int)aHeader.Flags & byte.MaxValue; if (aLocalMessageSize.HasValue && aLocalMessageSize < fTagSize) { throw new ArgumentException("Specified Local Message Size not long enough"); } byte[] fTagBytes = new byte[fTagSize]; int fReadByteCount = aReader.Read(fTagBytes, 0, fTagSize); if (fReadByteCount != fTagSize) { throw new EndOfStreamException("Could not read entire Opaque data type"); } String fAsciiTag = Encoding.ASCII.GetString(fTagBytes).TrimEnd((char)0); aBytes = fTagSize; return(new OpaqueDataType( aHeader, fAsciiTag)); }
internal protected static Dimension[] ReadDimensions( Hdf5Reader aReader, bool aHasMax, int aDimCount) { Dimension[] fDimensions; Length[] fSizes = Enumerable .Range(0, aDimCount) .Select(a => { Length fLength = aReader.ReadLength(); if (fLength.IsNull()) { throw new System.IO.InvalidDataException( "Dimension lengths must have real values"); } return(fLength); }) .ToArray(); if (aHasMax) { fDimensions = fSizes.Zip( Enumerable.Range(0, aDimCount) .Select(a => aReader.ReadLength()), (aLength, aMax) => new Dimension(aLength, aMax)) .ToArray(); } else { fDimensions = fSizes.Select(a => new Dimension(a)).ToArray(); } return(fDimensions); }
public static DatatypeHeader Read(Hdf5Reader aStream) { byte[] fBuffer = new byte[HeaderSize]; if (4 != aStream.Read(fBuffer, 0, 4)) { throw new EndOfStreamException(); } byte fVersion = (byte)((fBuffer[0] >> 4) & 0xF); if (fVersion < (byte)DatatypeVersion.Version1 || fVersion > (byte)DatatypeVersion.Version3) { throw new UnknownMessageVersion <Datatype>(fVersion); } byte fClass = (byte)(fBuffer[0] & 0xF); if (fClass > (byte)DatatypeClass.Array) { throw new InvalidDataException($"Unkown Datatype Class {fClass}"); } uint fFlags = (uint)(fBuffer[1] | fBuffer[2] << 8 | fBuffer[3] << 16); uint fSize = aStream.ReadUInt32(); return(new DatatypeHeader( (DatatypeVersion)fVersion, (DatatypeClass)fClass, fFlags, fSize)); }
public IObjectHeader ReadHeaderAt(long aHeaderLocation) { using (Hdf5Reader fReader = mrStreamProvider.GetReader()) { const int fcHeadBytes = 4; byte[] fHead = new byte[fcHeadBytes]; if (fcHeadBytes != fReader.Read(fHead, 0, fcHeadBytes)) { throw new System.IO.EndOfStreamException( $"Could not read header at 0x{aHeaderLocation:x16}"); } if (fHead[0] == 1 && fHead[1] == 0) { return(V1ObjectHeader.Read(fHead, fReader)); } if (fHead.Zip(msrV2Header, (arg1, arg2) => arg1 == arg2).All(a => a)) { return(V2ObjectHeader.Read(fReader)); } } throw new Exceptions.CorruptObjectHeader("Could not determine Header version"); }
internal static Datatype ReadMessage( DatatypeHeader aHeader, Hdf5Reader aReader, long?aLocalMessageSize, out long aBytes) { if (aHeader.Class != DatatypeClass.String) { throw new ArgumentException( $"aHeader must be for type {nameof(DatatypeClass.String)}"); } if (aLocalMessageSize.HasValue && aLocalMessageSize < 0) { throw new ArgumentException("Specified Local Message Size not long enough"); } byte fStringPadding = (byte)(aHeader.Flags & 0x0F), fStringEncoding = (byte)((aHeader.Flags & 0xF0) >> 4); if (fStringPadding > (byte)StringPadding.SpacePad) { throw new ArgumentException($"Invalid {nameof(StringPadding)}: {fStringPadding}"); } if (fStringEncoding > (byte)StringEncoding.UTF8) { throw new ArgumentException($"Invalid {nameof(StringEncoding)}: {fStringEncoding}"); } aBytes = 0;// No addional Read return(new StringDataType( aHeader, (StringPadding)fStringPadding, (StringEncoding)fStringEncoding)); }
public void Test_Basic_Parsing( [Values] uMessages.DatatypeVersion aVersion, [Values(ByteOrdering.BigEndian, ByteOrdering.LittleEndian)] ByteOrdering aByteOrdering, [Values(0, 1)] byte aLowPaddingBit, [Values(0, 1)] byte aHighPaddingBit, [Values] bool aIsSigned, [Values((uint)0, (uint)0xffffffff), Random(1)] uint aSize, [Values((ushort)0, (ushort)0xffff), Random(1)] ushort aBitOffset, [Values((ushort)0, (ushort)0xffff), Random(1)] ushort aBitPrecision) { //Arrange using (Stream fTestSource = new MemoryStream()) using (BinaryWriter fWriter = new BinaryWriter(fTestSource)) { fWriter.Write((byte)((byte)aVersion << 4)); fWriter.Write((byte)( (aByteOrdering == ByteOrdering.BigEndian ? 1 : 0) | (aLowPaddingBit << 1) | (aHighPaddingBit << 2) | (aIsSigned ? 0x8 : 0))); fWriter.Write((byte)0); fWriter.Write((byte)0); fWriter.Write(aSize); fWriter.Write(aBitOffset); fWriter.Write(aBitPrecision); fTestSource.Seek(0, SeekOrigin.Begin); Moq.Mock <ndf5.Metadata.ISuperBlock> fSuperblock = new Moq.Mock <ndf5.Metadata.ISuperBlock>( Moq.MockBehavior.Loose); using (Hdf5Reader fReader = new Hdf5Reader( fTestSource, fSuperblock.Object)) { long fReadBytes; uTest fExpected = new uTest( aSize, aByteOrdering, aHighPaddingBit, aLowPaddingBit, aIsSigned, aBitOffset, aBitPrecision), fResult = ndf5.Messages.Message.Read( fReader, uMessages.MessageType.Datatype, uMessages.MessageAttributeFlag.None, null, out fReadBytes) as uTest; Assert.That( fResult, Is.Not.Null, "Incorrect Message Type returned"); Assert.That( fResult, Is.EqualTo(fExpected), "Equality check failed"); Assert.That( fResult, Is.Not.EqualTo(new uTest( aSize, aByteOrdering, aHighPaddingBit, aLowPaddingBit, aIsSigned, aBitOffset, (ushort)(aBitPrecision + 1))), "Inequality Check Failed"); Assert.That( fResult, Is.Not.EqualTo(null), "Null Inequality Check Failed"); Assert.That( fResult.GetHashCode(), Is.EqualTo(fExpected.GetHashCode()), "Hash Code Equality check failed"); Assert.That( fReadBytes, Is.EqualTo(12), "Wrong number of bytes read"); Assert.That( fTestSource.Position, Is.EqualTo(12), "Wrong number of bytes read"); Assert.That( fResult.Class, Is.EqualTo(uMessages.DatatypeClass.FixedPoint), "Incorrect Data class"); Assert.That( fResult.ByteOrdering, Is.EqualTo(aByteOrdering), "Incorrect byte ordering"); Assert.That( fResult.LowPaddingBit, Is.EqualTo(aLowPaddingBit), "Incorrect low bit padding"); Assert.That( fResult.HighPaddingBit, Is.EqualTo(aHighPaddingBit), "Incorrect high bit padding"); Assert.That( fResult.IsSigned, Is.EqualTo(aIsSigned), "Incorrect value for IsSigned"); Assert.That( fResult.Size, Is.EqualTo(aSize), "Incorrect Data Element Size"); Assert.That( fResult.BitOffset, Is.EqualTo(aBitOffset), "Incorrect bit offset"); Assert.That( fResult.BitPrecision, Is.EqualTo(aBitPrecision), "Incorrect bit precision"); } } }
private ISuperBlock ParseV2orV3(SuperBlockObj aContainer, bool aIsV3) { using (Stream fStream = mrStreamProvider.GetReadonlyStream()) { fStream.Seek( (long)(ulong)(aContainer.LocationAddress + FormatSignatureAndVersionInfo.Length), SeekOrigin.Begin); const byte fcHeaderBytes = 3; byte[] fHeadbuffer = new byte[fcHeaderBytes]; if (fcHeaderBytes != fStream.Read(fHeadbuffer, 0, fcHeaderBytes)) { throw new EndOfStreamException("Could not read Superblock"); } aContainer.SizeOfOffsets = fHeadbuffer[0]; aContainer.SizeOfLengths = fHeadbuffer[1]; byte fFlags = fHeadbuffer[2]; if ((fFlags & ~((int)(FileConsistencyFlags.SwmrAccessEngaged | FileConsistencyFlags.WriteAccessOpen))) != 0) { throw new InvalidDataException($"Unexpected {nameof(FileConsistencyFlags)}: 0x{fFlags:X}"); } if (aIsV3) { aContainer.FileConsistencyFlags = (FileConsistencyFlags)fFlags; } int fFieldByteCount = aContainer.SizeOfOffsets * 4 + 4; byte[] fFieldBytes = new byte[fFieldByteCount]; fStream.Read(fFieldBytes, 0, fFieldByteCount); using (MemoryStream fMemoryStream = new MemoryStream(fFieldBytes)) using (Hdf5Reader fReader = new Hdf5Reader(fMemoryStream, aContainer, false)) { Offset fBaseAddress = fReader.ReadOffset(), fSuperBlockExtensionAddress = fReader.ReadOffset(), fEndOfFileAddress = fReader.ReadOffset(), fRootGroupAddress = fReader.ReadOffset(); if (fBaseAddress.IsNull()) { throw new InvalidDataException("No base adddress Specified"); } aContainer.BaseAddress = fBaseAddress; //TODO: Handle SuperVlock Extensions if (fEndOfFileAddress.IsNull()) { throw new InvalidDataException("No End Of file Adddress Specified"); } aContainer.EndOfFileAddress = fEndOfFileAddress; if (fRootGroupAddress.IsNull()) { throw new InvalidDataException("No Root Group Specified"); } aContainer.RootGroupAddress = fRootGroupAddress; uint fExpectedCheckSum = Checksums.Lookup3.ComputeHash( mrFormatSignatureAndVersionInfo.AsBytes .Concat(fHeadbuffer) .Concat(fFieldBytes.Take(fFieldByteCount - 4)) .ToArray()); if (fExpectedCheckSum != fReader.ReadUInt32()) { throw new InvalidDataException("Bad Checksum"); } } } return(aContainer); }
private ISuperBlock ParseV0orV1(SuperBlockObj aContainer, bool aIsV1) { using (Stream fStream = mrStreamProvider.GetReadonlyStream()) { fStream.Seek( (long)(ulong)aContainer.LocationAddress + FormatSignatureAndVersionInfo.Length, SeekOrigin.Begin); const byte fcHeaderBytes = 15; byte[] fHeadbuffer = new byte[fcHeaderBytes]; if (fcHeaderBytes != fStream.Read(fHeadbuffer, 0, fcHeaderBytes)) { throw new EndOfStreamException("Could not read Superblock"); } aContainer.FreeSpaceStorageVersion = fHeadbuffer[0]; aContainer.RootGroupSymbolTableVersion = fHeadbuffer[1]; if (fHeadbuffer[2] != 0) { throw new InvalidDataException("Reserved byte expected to be zero"); } aContainer.SharedHeaderMessageFormatVersion = fHeadbuffer[3]; aContainer.SizeOfOffsets = fHeadbuffer[4]; aContainer.SizeOfLengths = fHeadbuffer[5]; if (fHeadbuffer[6] != 0) { throw new InvalidDataException("Reserved byte expected to be zero"); } aContainer.GroupLeafNodeK = (ushort)(fHeadbuffer[7] | (fHeadbuffer[8] << 8)); aContainer.GroupInternalNodeK = (ushort)(fHeadbuffer[9] | (fHeadbuffer[10] << 8)); if (aIsV1) { const int fcV1FeildBytes = 4; byte[] fV1Buffer = new byte[fcV1FeildBytes]; if (fcV1FeildBytes != fStream.Read(fV1Buffer, 0, fcV1FeildBytes)) { throw new EndOfStreamException("Could not read Superblock"); } aContainer.IndexedStorageInternalNodeK = (ushort)(fV1Buffer[0] + (fV1Buffer[1] << 8)); if (!(fV1Buffer[2] == 0 || fV1Buffer[3] == 0)) { throw new InvalidDataException("Reserved bytes expected to be zero"); } } aContainer.BaseAddress = aContainer.LocationAddress; using (Hdf5Reader fReader = new Hdf5Reader(fStream, aContainer, false)) { Offset fBaseAddress = fReader.ReadOffset(), fFreeSpaceAddress = fReader.ReadOffset(), fEndOfFileAddress = fReader.ReadOffset(), fDirverInformationBlockAddress = fReader.ReadOffset(); SymbolTableEntry fRootGroupEntry = SymbolTableEntry.Read(fReader); if (fBaseAddress.IsNull()) { throw new InvalidDataException("No base adddress Specified"); } aContainer.BaseAddress = fBaseAddress; aContainer.FileFreespaceInfoAddress = fFreeSpaceAddress; if (fEndOfFileAddress.IsNull()) { throw new InvalidDataException("No End Of file Adddress Specified"); } aContainer.EndOfFileAddress = fEndOfFileAddress; aContainer.DriverInformationBlockAddress = fDirverInformationBlockAddress; aContainer.RootGroupSymbolTableEntry = fRootGroupEntry; aContainer.RootGroupAddress = fRootGroupEntry.ObjectHeaderAddress; } } return(aContainer); }
public void Test_Float_Example() { //Arrange using (Stream fTestSource = new MemoryStream()) using (BinaryWriter fWriter = new BinaryWriter(fTestSource)) { fWriter.Write(new byte[] { 0x11, 0x10, 0x1F, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x17, 0x08, 0x00, 0x17, 0x7e, 0x00, 0x00, 0x00, }); fTestSource.Seek(0, SeekOrigin.Begin); Moq.Mock <ndf5.Metadata.ISuperBlock> fSuperblock = new Moq.Mock <ndf5.Metadata.ISuperBlock>( Moq.MockBehavior.Loose); using (Hdf5Reader fReader = new Hdf5Reader( fTestSource, fSuperblock.Object)) { long fReadBytes; uTest fResult = ndf5.Messages.Message.Read( fReader, uMessages.MessageType.Datatype, uMessages.MessageAttributeFlag.None, null, out fReadBytes) as uTest; Assert.That( fResult, Is.Not.Null, "Incorrect Message Type returned"); Assert.That( fReadBytes, Is.EqualTo(20), "Wrong number of bytes read"); Assert.That( fTestSource.Position, Is.EqualTo(20), "Wrong number of bytes read"); Assert.That( fResult.Class, Is.EqualTo(uMessages.DatatypeClass.FloatingPoint), "Incorrect Data class"); Assert.That( fResult.ByteOrdering, Is.EqualTo(ByteOrdering.LittleEndian), "Incorrect byte ordering"); Assert.That( fResult.LowPaddingBit, Is.EqualTo(0), "Incorrect low bit padding"); Assert.That( fResult.HighPaddingBit, Is.EqualTo(0), "Incorrect high bit padding"); Assert.That( fResult.InternalPaddingBit, Is.EqualTo(0), "Incorrect internal bit padding"); Assert.That( fResult.SignLocation, Is.EqualTo(31), "Incorrect Sign bit location"); Assert.That( fResult.Size, Is.EqualTo(4), "Incorrect Data Element Size"); Assert.That( fResult.BitOffset, Is.EqualTo(0), "Incorrect bit offset"); Assert.That( fResult.BitPrecision, Is.EqualTo(32), "Incorrect bit precision"); } } }