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();
}
