public void DoesNotThrowWithNullParameters()
{
var builder = new ArrowBuffer.Builder <int>();
builder.AppendRange(null);
builder.Append((Func <IEnumerable <int> >)null);
}
private static IArrowArray ToBooleanArray(bool[] array)
{
byte[] rawBytes = CreateRawBytesForBoolArray(array.Length);
for (int i = 0; i < array.Length; ++i)
{
// only need to set true values since rawBytes is zeroed
// by the .NET runtime.
if (array[i])
{
BitUtility.SetBit(rawBytes, i);
}
}
var builder = new ArrowBuffer.Builder <byte>(rawBytes.Length);
builder.AppendRange(rawBytes);
var data = new ArrayData(
BooleanType.Default,
array.Length,
0,
0,
new[] { ArrowBuffer.Empty, builder.Build() });
return(ArrowArrayFactory.BuildArray(data));
}
private static Action <bool> CreateBooleanArray(
int length,
out Func <IArrowArray> build)
{
byte[] rawBytes = CreateRawBytesForBoolArray(length);
build = () =>
{
var builder = new ArrowBuffer.Builder <byte>(rawBytes.Length);
builder.AppendRange(rawBytes);
var data = new ArrayData(
BooleanType.Default,
length,
0,
0,
new[] { ArrowBuffer.Empty, builder.Build() });
return(ArrowArrayFactory.BuildArray(data));
};
int currentIndex = 0;
return(item =>
{
// Only need to set true values since rawBytes is zeroed by the .NET runtime.
if (item)
{
BitUtility.SetBit(rawBytes, currentIndex);
}
++currentIndex;
});
}
public void CapacityGrowsAfterAppendEnumerable()
{
var builder = new ArrowBuffer.Builder <int>(1);
var capacity = builder.Capacity;
var data = Enumerable.Range(0, 10).Select(x => x);
builder.AppendRange(data);
Assert.True(builder.Capacity > capacity);
}
public void LengthGrowsByEnumerableCount()
{
var builder = new ArrowBuffer.Builder <int>(1);
var length = builder.Length;
var data = Enumerable.Range(0, 10).Select(x => x).ToArray();
var count = data.Length;
builder.AppendRange(data);
Assert.Equal(length + count, builder.Length);
}
public static Array MakeIntArray(int length)
{
// The following should be improved once the ArrayBuilder PR goes in
var intBuilder = new ArrowBuffer.Builder <int>();
intBuilder.AppendRange(Enumerable.Range(0, length).Select(x => x));
ArrowBuffer buffer = intBuilder.Build();
ArrayData intData = new ArrayData(Int32Type.Default, length, 0, 0, new[] { ArrowBuffer.Empty, buffer });
Array intArray = ArrowArrayFactory.BuildArray(intData) as Array;
return(intArray);
}
public void SetsAllValuesToDefault()
{
var builder = new ArrowBuffer.Builder <int>(1);
var data = Enumerable.Range(0, 10).Select(x => x).ToArray();
builder.AppendRange(data);
builder.Clear();
var buffer = builder.Build();
var zeros = Enumerable.Range(0, 10).Select(x => 0).ToArray();
var values = buffer.Span.CastTo <int>().Slice(0, 10).ToArray();
Assert.True(zeros.SequenceEqual(values));
}
public void BufferHasExpectedValues()
{
var builder = new ArrowBuffer.Builder <int>(1);
var data = Enumerable.Range(0, 10).Select(x => x).ToArray();
builder.AppendRange(data);
var buffer = builder.Build();
var span = buffer.Span.CastTo <int>();
for (var i = 0; i < 10; i++)
{
Assert.Equal(i, span[i]);
}
}
public void SetsAllValuesToDefault(int sizeBeforeClear)
{
var builder = new ArrowBuffer.Builder <int>(1);
var data = Enumerable.Range(0, sizeBeforeClear).Select(x => x).ToArray();
builder.AppendRange(data);
builder.Clear();
builder.Append(0);
var buffer = builder.Build();
// No matter the sizeBeforeClear, we only appended a single 0,
// so the buffer length should be the smallest possible.
Assert.Equal(64, buffer.Length);
// check all 16 int elements are default
var zeros = Enumerable.Range(0, 16).Select(x => 0).ToArray();
var values = buffer.Span.CastTo <int>().Slice(0, 16).ToArray();
Assert.True(zeros.SequenceEqual(values));
}
public static Array MakeArrayBuffer <T>(IArrowType dataType,
int length,
IEnumerable <T> data)
where T : struct
{
ArrowBuffer.Builder <T> builder = new ArrowBuffer.Builder <T>();
builder.AppendRange(data);
ArrowBuffer buffer = builder.Build();
ArrayData arrayData = new ArrayData(dataType,
length,
0,
0,
new[]
{
buffer
});
Array array = ArrowArrayFactory.BuildArray(arrayData) as Array;
return(array);
}