public void TestTables()
{
FlatBufferBuilder builder = new FlatBufferBuilder(1024 * 1024 * 32);
for (int x = 0; x < 500000; ++x)
{
var offset = builder.CreateString("T");
builder.StartObject(4);
builder.AddDouble(3.2);
builder.AddDouble(4.2);
builder.AddDouble(5.2);
builder.AddOffset(offset.Value);
builder.EndObject();
}
}
public static VectorOffset CreateVectorOfDoublesVector(FlatBufferBuilder builder, double[] data)
{
builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--)
{
builder.AddDouble(data[i]);
}
return(builder.EndVector());
}
public static void AddStrength(FlatBufferBuilder builder, double strength)
{
builder.AddDouble(2, strength, 0.0);
}
private void CheckObjects(int fieldCount, int objectCount)
{
_lcg.Reset();
const int testValuesMax = 11;
var builder = new FlatBufferBuilder(1);
var objects = new int[objectCount];
for (var i = 0; i < objectCount; ++i)
{
builder.StartObject(fieldCount);
for (var j = 0; j < fieldCount; ++j)
{
var fieldType = _lcg.Next() % testValuesMax;
switch (fieldType)
{
case 0:
{
builder.AddBool(j, FuzzTestData.BoolValue, false);
break;
}
case 1:
{
builder.AddSbyte(j, FuzzTestData.Int8Value, 0);
break;
}
case 2:
{
builder.AddByte(j, FuzzTestData.UInt8Value, 0);
break;
}
case 3:
{
builder.AddShort(j, FuzzTestData.Int16Value, 0);
break;
}
case 4:
{
builder.AddUshort(j, FuzzTestData.UInt16Value, 0);
break;
}
case 5:
{
builder.AddInt(j, FuzzTestData.Int32Value, 0);
break;
}
case 6:
{
builder.AddUint(j, FuzzTestData.UInt32Value, 0);
break;
}
case 7:
{
builder.AddLong(j, FuzzTestData.Int64Value, 0);
break;
}
case 8:
{
builder.AddUlong(j, FuzzTestData.UInt64Value, 0);
break;
}
case 9:
{
builder.AddFloat(j, FuzzTestData.Float32Value, 0);
break;
}
case 10:
{
builder.AddDouble(j, FuzzTestData.Float64Value, 0);
break;
}
default:
throw new Exception("Unreachable");
}
}
var offset = builder.EndObject();
// Store the object offset
objects[i] = offset;
}
_lcg.Reset();
// Test all objects are readable and return expected values...
for (var i = 0; i < objectCount; ++i)
{
var table = new TestTable(builder.DataBuffer, builder.DataBuffer.Length - objects[i]);
for (var j = 0; j < fieldCount; ++j)
{
var fieldType = _lcg.Next() % testValuesMax;
var fc = 2 + j; // 2 == VtableMetadataFields
var f = fc * 2;
switch (fieldType)
{
case 0:
{
Assert.AreEqual(FuzzTestData.BoolValue, table.GetSlot(f, false));
break;
}
case 1:
{
Assert.AreEqual(FuzzTestData.Int8Value, table.GetSlot(f, (sbyte)0));
break;
}
case 2:
{
Assert.AreEqual(FuzzTestData.UInt8Value, table.GetSlot(f, (byte)0));
break;
}
case 3:
{
Assert.AreEqual(FuzzTestData.Int16Value, table.GetSlot(f, (short)0));
break;
}
case 4:
{
Assert.AreEqual(FuzzTestData.UInt16Value, table.GetSlot(f, (ushort)0));
break;
}
case 5:
{
Assert.AreEqual(FuzzTestData.Int32Value, table.GetSlot(f, (int)0));
break;
}
case 6:
{
Assert.AreEqual(FuzzTestData.UInt32Value, table.GetSlot(f, (uint)0));
break;
}
case 7:
{
Assert.AreEqual(FuzzTestData.Int64Value, table.GetSlot(f, (long)0));
break;
}
case 8:
{
Assert.AreEqual(FuzzTestData.UInt64Value, table.GetSlot(f, (ulong)0));
break;
}
case 9:
{
Assert.AreEqual(FuzzTestData.Float32Value, table.GetSlot(f, (float)0));
break;
}
case 10:
{
Assert.AreEqual(FuzzTestData.Float64Value, table.GetSlot(f, (double)0));
break;
}
default:
throw new Exception("Unreachable");
}
}
}
}
public static void AddTestdPinf(FlatBufferBuilder builder, double testdPinf)
{
builder.AddDouble(4, testdPinf, Double.PositiveInfinity);
}
public static void AddDouble(FlatBufferBuilder builder, double Double)
{
builder.AddDouble(10, Double, 0.0);
}
public static void AddMaybeF64(FlatBufferBuilder builder, double?maybeF64)
{
builder.AddDouble(28, maybeF64);
}
public static void AddF64(FlatBufferBuilder builder, double f64)
{
builder.AddDouble(9, f64, 0.0);
}
public static void AddD2(FlatBufferBuilder builder, double d2)
{
builder.AddDouble(2, d2, Double.PositiveInfinity);
}
public static void AddRating(FlatBufferBuilder builder, double rating)
{
builder.AddDouble(2, rating, 0.0);
}
public static void AddSpeed(FlatBufferBuilder builder, double speed)
{
builder.AddDouble(1, speed, 0.0);
}
public static void AddDouble_(FlatBufferBuilder builder, double double_)
{
builder.AddDouble(4, double_, 1.0);
}
public static void AddDoubleProp(FlatBufferBuilder builder, double DoubleProp)
{
builder.AddDouble(5, DoubleProp, 0);
}
private void CheckObjects(int fieldCount, int objectCount)
{
_lcg.Reset();
const int testValuesMax = 11;
var builder = new FlatBufferBuilder(1);
var objects = new int[objectCount];
for (var i = 0; i < objectCount; ++i)
{
builder.StartObject(fieldCount);
for (var j = 0; j < fieldCount; ++j)
{
var fieldType = _lcg.Next()%testValuesMax;
switch (fieldType)
{
case 0:
{
builder.AddBool(j, FuzzTestData.BoolValue, false);
break;
}
case 1:
{
builder.AddSbyte(j, FuzzTestData.Int8Value, 0);
break;
}
case 2:
{
builder.AddByte(j, FuzzTestData.UInt8Value, 0);
break;
}
case 3:
{
builder.AddShort(j, FuzzTestData.Int16Value, 0);
break;
}
case 4:
{
builder.AddUshort(j, FuzzTestData.UInt16Value, 0);
break;
}
case 5:
{
builder.AddInt(j, FuzzTestData.Int32Value, 0);
break;
}
case 6:
{
builder.AddUint(j, FuzzTestData.UInt32Value, 0);
break;
}
case 7:
{
builder.AddLong(j, FuzzTestData.Int64Value, 0);
break;
}
case 8:
{
builder.AddUlong(j, FuzzTestData.UInt64Value, 0);
break;
}
case 9:
{
builder.AddFloat(j, FuzzTestData.Float32Value, 0);
break;
}
case 10:
{
builder.AddDouble(j, FuzzTestData.Float64Value, 0);
break;
}
default:
throw new Exception("Unreachable");
}
}
var offset = builder.EndObject();
// Store the object offset
objects[i] = offset;
}
_lcg.Reset();
// Test all objects are readable and return expected values...
for (var i = 0; i < objectCount; ++i)
{
var table = new TestTable(builder.DataBuffer, builder.DataBuffer.Length - objects[i]);
for (var j = 0; j < fieldCount; ++j)
{
var fieldType = _lcg.Next() % testValuesMax;
var fc = 2 + j; // 2 == VtableMetadataFields
var f = fc * 2;
switch (fieldType)
{
case 0:
{
Assert.AreEqual(FuzzTestData.BoolValue, table.GetSlot(f, false));
break;
}
case 1:
{
Assert.AreEqual(FuzzTestData.Int8Value, table.GetSlot(f, (sbyte)0));
break;
}
case 2:
{
Assert.AreEqual(FuzzTestData.UInt8Value, table.GetSlot(f, (byte)0));
break;
}
case 3:
{
Assert.AreEqual(FuzzTestData.Int16Value, table.GetSlot(f, (short)0));
break;
}
case 4:
{
Assert.AreEqual(FuzzTestData.UInt16Value, table.GetSlot(f, (ushort)0));
break;
}
case 5:
{
Assert.AreEqual(FuzzTestData.Int32Value, table.GetSlot(f, (int)0));
break;
}
case 6:
{
Assert.AreEqual(FuzzTestData.UInt32Value, table.GetSlot(f, (uint)0));
break;
}
case 7:
{
Assert.AreEqual(FuzzTestData.Int64Value, table.GetSlot(f, (long)0));
break;
}
case 8:
{
Assert.AreEqual(FuzzTestData.UInt64Value, table.GetSlot(f, (ulong)0));
break;
}
case 9:
{
Assert.AreEqual(FuzzTestData.Float32Value, table.GetSlot(f, (float)0));
break;
}
case 10:
{
Assert.AreEqual(FuzzTestData.Float64Value, table.GetSlot(f, (double)0));
break;
}
default:
throw new Exception("Unreachable");
}
}
}
}
public static void AddPosition(FlatBufferBuilder builder, double position)
{
builder.AddDouble(2, position, 0.0);
}
public static void AddD1(FlatBufferBuilder builder, double d1)
{
builder.AddDouble(1, d1, Double.NaN);
}
public static void AddTimestamp(FlatBufferBuilder builder, double timestamp)
{
builder.AddDouble(0, timestamp, 0.0);
}
public static void AddD3(FlatBufferBuilder builder, double d3)
{
builder.AddDouble(3, d3, Double.NegativeInfinity);
}
public static void AddVal(FlatBufferBuilder builder, double val)
{
builder.AddDouble(0, val, 0.0);
}
public static void AddJustF64(FlatBufferBuilder builder, double justF64)
{
builder.AddDouble(27, justF64, 0.0);
}
public static void AddValue(FlatBufferBuilder builder, double Value)
{
builder.AddDouble(0, Value, 0.0);
}
public static void AddDefaultF64(FlatBufferBuilder builder, double defaultF64)
{
builder.AddDouble(29, defaultF64, 42.0);
}
public static void AddMean(FlatBufferBuilder builder, double mean)
{
builder.AddDouble(3, mean, 0.0);
}
public static void AddTestdNan(FlatBufferBuilder builder, double testdNan)
{
builder.AddDouble(3, testdNan, Double.NaN);
}
public static void AddStdev(FlatBufferBuilder builder, double stdev)
{
builder.AddDouble(4, stdev, 0.0);
}
public static void AddTestdNinf(FlatBufferBuilder builder, double testdNinf)
{
builder.AddDouble(5, testdNinf, Double.NegativeInfinity);
}
public static void AddTestString1(FlatBufferBuilder builder, double testString1)
{
builder.AddDouble(2, testString1, 0.0);
}
public static void AddTestDouble(FlatBufferBuilder builder, double testDouble)
{
builder.AddDouble(5, testDouble, 0.0);
}
public static void AddD0(FlatBufferBuilder builder, double d0)
{
builder.AddDouble(0, d0, Double.NaN);
}
public static void AddConfigurableValue(FlatBufferBuilder builder, double configurableValue)
{
builder.AddDouble(1, configurableValue, 0.0);
}
public static void AddValue(FlatBufferBuilder builder, double value)
{
builder.AddDouble(1, value, 4567.0);
}
