public void Test_EncodedBitFieldDescriptor_CalculateRequiredBitFieldSize() { // Test case where all values are null (expected 0 bits of entropy) EncodedBitFieldDescriptor descriptor = new EncodedBitFieldDescriptor() { AllValuesAreNull = true, }; descriptor.CalculateRequiredBitFieldSize(); Assert.Equal(0, descriptor.RequiredBits); // Test case where there is 1024 possible values plus an encoded null value, resulting in 10 required bits descriptor = new EncodedBitFieldDescriptor() { AllValuesAreNull = false, EncodedNullValue = 1023, MinValue = 0, MaxValue = 1023, }; descriptor.CalculateRequiredBitFieldSize(); Assert.Equal(10, descriptor.RequiredBits); // Test case where there is 1024 possible values plus an encoded null value, resulting in 11 required bits descriptor = new EncodedBitFieldDescriptor() { AllValuesAreNull = false, EncodedNullValue = 1024, MinValue = 0, MaxValue = 1024, }; descriptor.CalculateRequiredBitFieldSize(); Assert.Equal(11, descriptor.RequiredBits); }
public void Test_EncodedBitFieldDescriptor_ReadWrite() { EncodedBitFieldDescriptor descriptor1 = new EncodedBitFieldDescriptor() { AllValuesAreNull = false, EncodedNullValue = 1235, MinValue = 0, MaxValue = 1234, NativeNullValue = 10000, Nullable = true, OffsetBits = 1280, RequiredBits = 35 }; MemoryStream ms = new MemoryStream(Consts.TREX_DEFAULT_MEMORY_STREAM_CAPACITY_ON_CREATION); using (var writer = new BinaryWriter(ms, Encoding.UTF8, true)) { descriptor1.Write(writer); } EncodedBitFieldDescriptor descriptor2 = new EncodedBitFieldDescriptor(); ms.Position = 0; using (var reader = new BinaryReader(ms, Encoding.UTF8, true)) { descriptor2.Read(reader); } Assert.Equal(descriptor1, descriptor2); }
public void Test_AttributeValueRangeCalculator_ZeroBitRange_Nullable() { EncodedBitFieldDescriptor descriptor = new EncodedBitFieldDescriptor(); AttributeValueRangeCalculator.CalculateAttributeValueRange(new long[] { 0, 0 }, 0, 2, 0xffffffff, 0, true, ref descriptor); Assert.Equal(0, descriptor.MinValue); Assert.Equal(0, descriptor.MaxValue); Assert.Equal(0, descriptor.RequiredBits); }
public void Test_BitFieldArray_MultiRecordMultiBitField_WithDescriptor() { using (var bfa = new BitFieldArray()) { BitFieldArrayRecordsDescriptor[] fieldsArray = new[] { new BitFieldArrayRecordsDescriptor() { BitsPerRecord = 11, NumRecords = 1000 }, }; bfa.Initialise(fieldsArray); Assert.Equal(11000, bfa.NumBits); Assert.Equal(172, bfa.NumStorageElements()); Assert.Equal(1375, bfa.MemorySize()); var descriptor = new EncodedBitFieldDescriptor(); AttributeValueRangeCalculator.CalculateAttributeValueRange(new long[] { 0, 2047 }, 0, 2, 0xffffffff, 0, false, ref descriptor); // Write a '1234' to the bfa bfa.StreamWriteStart(); try { for (int i = 0; i < 1000; i++) { bfa.StreamWrite(1234, descriptor); } } finally { bfa.StreamWriteEnd(); } // Read the value back again int bitAddress = 0; for (int i = 0; i < 1000; i++) { long readValue = bfa.ReadBitField(ref bitAddress, descriptor); Assert.Equal(1234, readValue); Assert.Equal(bitAddress, (i + 1) * 11); } } }
public void Test_AttributeValueRangeCalculator_NullRangeHeights() { // Simulate a subgrid containing the same non-null elevation in every cell, expressed as a single vector long value = AttributeValueModifiers.ModifiedHeight(12345.678F); long[] values = Enumerable.Range(0, SubGridTreeConsts.SubGridTreeCellsPerSubGrid).Select(x => value).ToArray(); EncodedBitFieldDescriptor descriptor = new EncodedBitFieldDescriptor(); AttributeValueRangeCalculator.CalculateAttributeValueRange(values, 0, values.Length, 0xffffffff, 0x7fffffff, true, ref descriptor); Assert.Equal(descriptor.MinValue, value); Assert.Equal(descriptor.MaxValue, value); Assert.Equal(0, descriptor.RequiredBits); }
public void Test_EncodedBitFieldDescriptor_Init() { EncodedBitFieldDescriptor descriptor = new EncodedBitFieldDescriptor(); descriptor.Init(); Assert.True(descriptor.EncodedNullValue == 0 && descriptor.AllValuesAreNull == false && descriptor.MaxValue == 0 && descriptor.MinValue == 0 && descriptor.NativeNullValue == 0 && descriptor.Nullable == false && descriptor.OffsetBits == 0 && descriptor.RequiredBits == 0, "Descriptor state after Init() incorrect"); }
public void WriteBitFieldVector_FailWithStorageSize() { long[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; var descriptor = new EncodedBitFieldDescriptor(); descriptor.RequiredBits = 4; using (var bfa = new BitFieldArray()) { bfa.Initialise(descriptor.RequiredBits, values.Length - 1); int bitLocation = 0; Action act = () => bfa.WriteBitFieldVector(ref bitLocation, descriptor, values.Length, values); act.Should().Throw <ArgumentException>().WithMessage("Insufficient storage present to satisfy*"); } }
public void WriteBitFieldVector_FailWithValuesArraySize() { long[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; var descriptor = new EncodedBitFieldDescriptor(); descriptor.RequiredBits = 4; using (var bfa = new BitFieldArray()) { bfa.Initialise(descriptor.RequiredBits, values.Length); int bitLocation = 0; Action act = () => bfa.WriteBitFieldVector(ref bitLocation, descriptor, values.Length + 1, values); act.Should().Throw <ArgumentException>().WithMessage("Supplied values array is null or not large enough*"); } }
public void Test_BitFieldArray_SingleRecordSingleVariableSizeField_WithDescriptor (int bitsPerRecord, int numRecords, int minValue, int maxValue, int mask, long valueToWrite, int numStorageElements, int memorySize, int nativeNullValue, bool fieldIsNullable, int expectedNumValues) { using (var bfa = new BitFieldArray()) { BitFieldArrayRecordsDescriptor[] fieldsArray = new[] { new BitFieldArrayRecordsDescriptor { BitsPerRecord = bitsPerRecord, NumRecords = numRecords }, }; bfa.Initialise(fieldsArray); bitsPerRecord.Should().Be(bfa.NumBits); numStorageElements.Should().Be(bfa.NumStorageElements()); Assert.Equal((int)memorySize, bfa.MemorySize()); var descriptor = new EncodedBitFieldDescriptor(); AttributeValueRangeCalculator.CalculateAttributeValueRange(new long[] { minValue, maxValue }, 0, 2, mask, nativeNullValue, fieldIsNullable, ref descriptor); descriptor.RequiredBits.Should().Be((byte)bitsPerRecord); descriptor.NumValues.Should().Be(expectedNumValues); // Write a value to the bfa bfa.StreamWriteStart(); try { bfa.StreamWrite(valueToWrite, descriptor); } finally { bfa.StreamWriteEnd(); } // Read the value back again int bitAddress = 0; long readValue = bfa.ReadBitField(ref bitAddress, descriptor); valueToWrite.Should().Be(readValue); bitsPerRecord.Should().Be(bitAddress); } }
public void Read(BinaryReader reader) { segmentPassCount = reader.ReadInt32(); var passCountBuffer = GenericArrayPoolCacheHelper <long> .Caches().Rent(SubGridTreeConsts.CellsPerSubGrid); try { var fieldDescriptor = new EncodedBitFieldDescriptor(); fieldDescriptor.Read(reader); using (var bfa = new BitFieldArray()) { bfa.Read(reader); int bitLocation = 0; bfa.ReadBitFieldVector(ref bitLocation, fieldDescriptor, SubGridTreeConsts.CellsPerSubGrid, passCountBuffer); } var counter = 0; for (var i = 0; i < SubGridTreeConsts.SubGridTreeDimension; i++) { for (var j = 0; j < SubGridTreeConsts.SubGridTreeDimension; j++) { var passCount = (int)passCountBuffer[counter++]; if (passCount > 0) { AllocatePasses(i, j, passCount); _passData[i, j].Passes.Count = passCount; var passes = _passData[i, j].Passes; for (int cpi = passes.Offset, limit = passes.OffsetPlusCount; cpi < limit; cpi++) { passes.Elements[cpi].Read(reader); } } } } } finally { GenericArrayPoolCacheHelper <long> .Caches().Return(ref passCountBuffer); } }
public void WriteBitFieldVector_Success_PartialWrite() { long[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; var descriptor = new EncodedBitFieldDescriptor(); descriptor.RequiredBits = 4; int partialWriteSize = 5; using (var bfa = new BitFieldArray()) { bfa.Initialise(descriptor.RequiredBits, values.Length); int bitLocation = 0; bfa.WriteBitFieldVector(ref bitLocation, descriptor, partialWriteSize, values); bitLocation.Should().Be(descriptor.RequiredBits * partialWriteSize); } }
public void Test_AttributeValueRangeCalculator_SingleBitRange_Nullable() { EncodedBitFieldDescriptor descriptor = new EncodedBitFieldDescriptor(); AttributeValueRangeCalculator.CalculateAttributeValueRange(new long[] { 0, 1 }, 0, 2, 0xffffffff, 5, true, ref descriptor); Assert.Equal(0, descriptor.MinValue); Assert.Equal(1, descriptor.MaxValue); Assert.False(descriptor.Nullable); Assert.Equal(5, descriptor.NativeNullValue); Assert.Equal(1, descriptor.RequiredBits); AttributeValueRangeCalculator.CalculateAttributeValueRange(new long[] { 0, 1, 5 }, 0, 3, 0xffffffff, 5, true, ref descriptor); Assert.Equal(0, descriptor.MinValue); Assert.Equal(2, descriptor.MaxValue); Assert.True(descriptor.Nullable); Assert.Equal(5, descriptor.NativeNullValue); Assert.Equal(2, descriptor.RequiredBits); }
public void Test_BitFieldArray_SingleRecordSingleBitField_WithDescriptor() { using (var bfa = new BitFieldArray()) { BitFieldArrayRecordsDescriptor[] fieldsArray = new[] { new BitFieldArrayRecordsDescriptor { BitsPerRecord = 1, NumRecords = 1 }, }; bfa.Initialise(fieldsArray); Assert.Equal(1, bfa.NumBits); Assert.Equal(1, bfa.NumStorageElements()); Assert.Equal(1, bfa.MemorySize()); var descriptor = new EncodedBitFieldDescriptor(); AttributeValueRangeCalculator.CalculateAttributeValueRange(new long[] { 0, 1 }, 0, 2, 0xffffffff, 0, false, ref descriptor); // Write a '1' to the bfa bfa.StreamWriteStart(); try { bfa.StreamWrite(1, descriptor); } finally { bfa.StreamWriteEnd(); } // Read the value back again int bitAddress = 0; long readValue = bfa.ReadBitField(ref bitAddress, descriptor); Assert.Equal(1, readValue); Assert.Equal(1, bitAddress); } }
public void ReadBitFieldVector_SuccessPartial() { long[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; var descriptor = new EncodedBitFieldDescriptor(); descriptor.RequiredBits = 4; using (var bfa = new BitFieldArray()) { bfa.Initialise(descriptor.RequiredBits, values.Length); int bitLocation = 0; bfa.WriteBitFieldVector(ref bitLocation, descriptor, values.Length, values); // Read the vector back bitLocation = 0; long[] outValues = new long[5]; bfa.ReadBitFieldVector(ref bitLocation, descriptor, outValues.Length, outValues); bitLocation.Should().Be(outValues.Length * descriptor.RequiredBits); outValues.ForEach((l, i) => l.Should().Be(values[i])); } }
public void ReadBitFieldVector_Success(byte valueBits) { long[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; var descriptor = new EncodedBitFieldDescriptor(); descriptor.RequiredBits = valueBits; using (var bfa = new BitFieldArray()) { bfa.Initialise(valueBits, values.Length); int bitLocation = 0; bfa.WriteBitFieldVector(ref bitLocation, descriptor, values.Length, values); // Read the vector back bitLocation = 0; long[] outValues = new long[values.Length]; bfa.ReadBitFieldVector(ref bitLocation, descriptor, outValues.Length, outValues); bitLocation.Should().Be(outValues.Length * valueBits); outValues.Should().BeEquivalentTo(values); } }
// CalculateAttributeValueRange scans a single attribute across all records in a block of values public static void CalculateAttributeValueRange(long[] Values, int startIndex, int count, long Mask, long ANativeNullValue, bool ANullable, ref EncodedBitFieldDescriptor FieldDescriptor) { bool ObservedANullValue = false; bool FirstValue = true; FieldDescriptor.NativeNullValue = ANativeNullValue; FieldDescriptor.MinValue = ANativeNullValue; FieldDescriptor.MaxValue = ANativeNullValue; FieldDescriptor.Nullable = ANullable; for (int i = startIndex, limit = startIndex + count; i < limit; i++) { long TestValue = Values[i]; // Ensure negative values are preserved TestValue = TestValue < 0 ? -(-TestValue & Mask) : TestValue & Mask; if (FieldDescriptor.Nullable) { if (FieldDescriptor.MinValue == ANativeNullValue || (TestValue != ANativeNullValue && TestValue < FieldDescriptor.MinValue)) { FieldDescriptor.MinValue = TestValue; } if (FieldDescriptor.MaxValue == ANativeNullValue || (TestValue != ANativeNullValue && TestValue > FieldDescriptor.MaxValue)) { FieldDescriptor.MaxValue = TestValue; } } else { if (FirstValue || TestValue < FieldDescriptor.MinValue) { FieldDescriptor.MinValue = TestValue; } if (FirstValue || TestValue > FieldDescriptor.MaxValue) { FieldDescriptor.MaxValue = TestValue; } } if (!ObservedANullValue && ANullable && TestValue == ANativeNullValue) { ObservedANullValue = true; } FirstValue = false; } // If the data stream processed contained no null values, then force the // nullable flag to false so we don't encode an extra token for a null value // that will never be written. if (!ObservedANullValue) { FieldDescriptor.Nullable = false; } if (FieldDescriptor.Nullable && FieldDescriptor.MaxValue != FieldDescriptor.NativeNullValue) { FieldDescriptor.MaxValue++; FieldDescriptor.EncodedNullValue = FieldDescriptor.MaxValue; } else { FieldDescriptor.EncodedNullValue = 0; } FieldDescriptor.CalculateRequiredBitFieldSize(); }