public void OneBoolInStruct()
{
//simple datagram: {yolo:true}
var oneBool = DirStructure.OwnTestFileAsBytes("binary/onebool.bindat");
var reader = new UserBinaryReader(new MemoryStream(oneBool));
ReaderTestCommon.OneBoolInStruct(reader);
}
public void ReadTypeAnnotations_AssertUnknownSymbolException()
{
byte[] data = DirStructure.OwnTestFileAsBytes("binary/unknown_symbols.bindat");
UserBinaryReader reader = new UserBinaryReader(new MemoryStream(data));
ReaderTestCommon.ReadTypeAnnotations_AssertUnknownSymbolException(reader);
}
public void TrivialStruct()
{
//empty struct {}
var trivial = DirStructure.OwnTestFileAsBytes("binary/trivial.bindat");
var reader = new UserBinaryReader(new MemoryStream(trivial));
ReaderTestCommon.TrivialStruct(reader);
}
public void CascadingSymtab_TestCorrectSymbolDecoding()
{
var file = DirStructure.OwnFile("text/cascading_symtabs.ion");
var datagram = IonLoader.Default.Load(file);
Assert.AreEqual(3, datagram.Count);
//the first value $13 should be unknown text
Assert.AreEqual(IonType.Symbol, datagram[0].Type);
var token = ((IonSymbol)datagram[0]).SymbolValue;
Assert.AreEqual(13, token.Sid);
Assert.IsNull(token.Text);
//2nd value $10 should be rock:10
Assert.AreEqual(IonType.Symbol, datagram[1].Type);
token = ((IonSymbol)datagram[1]).SymbolValue;
Assert.AreEqual(10, token.Sid);
Assert.AreEqual("rock", token.Text);
//3rd value $10 should be unknown text
Assert.AreEqual(IonType.Symbol, datagram[0].Type);
token = ((IonSymbol)datagram[2]).SymbolValue;
Assert.AreEqual(10, token.Sid);
Assert.IsNull(token.Text);
}
public void TwoLayer_TestStepout_Skip()
{
const string fileName = "binary/twolayer.bindat";
var data = DirStructure.OwnTestFileAsBytes(fileName);
var reader = new UserBinaryReader(new MemoryStream(data));
ReaderTestCommon.TwoLayer_TestStepoutSkip(reader);
}
public void Float_zeros()
{
var file = DirStructure.IonTestFile("good/float_zeros.ion");
var reader = ReaderFromFile(file, InputStyle.FileStream);
while (reader.MoveNext() != IonType.None)
{
Assert.AreEqual(IonType.Float, reader.CurrentType);
Assert.AreEqual(0d, reader.DoubleValue());
using (var memoryStream = new MemoryStream())
{
using (var writer = IonBinaryWriterBuilder.Build(memoryStream, forceFloat64: true))
{
writer.WriteFloat(reader.DoubleValue());
writer.Finish();
}
// Confirm the reader's and writer's byte presentations are the same
var readerByte = BitConverter.GetBytes(reader.DoubleValue());
Array.Reverse(readerByte);
// Get byte reprsentation of value from the stream
var writerByte = memoryStream.ToArray().Skip(5).ToArray();
Assert.IsTrue(Enumerable.SequenceEqual(writerByte, readerByte));
}
}
}
public void SingleIntList()
{
var data = DirStructure.OwnTestFileAsBytes("binary/single_int_list.bindat");
var reader = new UserBinaryReader(new MemoryStream(data));
ReaderTestCommon.SingleIntList(reader);
}
public void GoodFieldName(string fileName, string fieldName)
{
void assertReader(IIonReader reader)
{
Assert.AreEqual(IonType.Struct, reader.MoveNext());
reader.StepIn();
Assert.AreEqual(IonType.Bool, reader.MoveNext());
Assert.AreEqual(fieldName, reader.CurrentFieldName);
Assert.IsFalse(reader.BoolValue());
}
void writeFunc(IIonWriter writer)
{
writer.StepIn(IonType.Struct);
writer.SetFieldName(fieldName);
writer.WriteBool(false);
writer.StepOut();
writer.Finish();
}
var r = ReaderFromFile(DirStructure.IonTestFile($"good/{fileName}.ion"), InputStyle.FileStream);
assertReader(r);
AssertReaderWriter(assertReader, writeFunc);
}
public void Combined1()
{
var data = DirStructure.OwnTestFileAsBytes("binary/combined1.bindat");
var reader = new UserBinaryReader(new MemoryStream(data));
ReaderTestCommon.Combined1(reader);
}
public void Struct_OneBlob()
{
var data = DirStructure.OwnTestFileAsBytes("binary/struct_oneblob.bindat");
var reader = new UserBinaryReader(new MemoryStream(data));
ReaderTestCommon.Struct_OneBlob(reader);
}
public void Decimal64BitBoundary(InputStyle inputStyle)
{
void assertReader(IIonReader reader)
{
Assert.AreEqual(IonType.Decimal, reader.MoveNext());
Assert.AreEqual(18446744073709551615m, reader.DecimalValue().ToDecimal());
Assert.AreEqual(IonType.Decimal, reader.MoveNext());
Assert.AreEqual(-18446744073709551615.0m, reader.DecimalValue().ToDecimal());
Assert.AreEqual(IonType.Decimal, reader.MoveNext());
Assert.AreEqual(18446744073709551616.0m, reader.DecimalValue().ToDecimal());
Assert.AreEqual(IonType.Decimal, reader.MoveNext());
Assert.AreEqual(-18446744073709551616.0m, reader.DecimalValue().ToDecimal());
}
void writerFunc(IIonWriter writer)
{
writer.WriteDecimal(18446744073709551615m);
writer.WriteDecimal(-18446744073709551615m);
writer.WriteDecimal(18446744073709551616m);
writer.WriteDecimal(-18446744073709551616m);
writer.Finish();
}
var file = DirStructure.IonTestFile("good/decimal64BitBoundary.ion");
var r = ReaderFromFile(file, inputStyle);
assertReader(r);
AssertReaderWriter(assertReader, writerFunc);
}
public void Date_2000_11_20_8_20_15_Unknown()
{
var data = DirStructure.OwnTestFileAsBytes("text/ts_2000_11_20_8_20_15_unknown.ion");
IIonReader reader = new UserTextReader(new MemoryStream(data));
ReaderTimestampCommon.Date_2000_11_20_8_20_15_Unknown(reader);
}
public void FlatIntList()
{
//a flat list of ints [123,456,789]
var flatListInt = DirStructure.OwnTestFileAsBytes("binary/flatlist_int.bindat");
var reader = new UserBinaryReader(new MemoryStream(flatListInt));
ReaderTestCommon.FlatIntList(reader);
}
public void FlatIntList()
{
//a flat list of ints [123,456,789]
var flatListInt = DirStructure.ReadDataFile("text/flatlist_int.ion");
var reader = new UserTextReader(new MemoryStream(flatListInt));
ReaderTestCommon.FlatIntList(reader);
}
public void CommentThenEof(string fileName)
{
var fileAsStream = DirStructure.IonTestFileAsStream(fileName);
var reader = new UserTextReader(fileAsStream);
Assert.AreEqual(IonType.Symbol, reader.MoveNext());
Assert.AreEqual("abc", reader.SymbolValue().Text);
Assert.AreEqual(IonType.None, reader.MoveNext());
}
public void SingleSymbol()
{
//struct with single symbol
//{single_symbol:'something'}
var data = DirStructure.OwnTestFileAsBytes("binary/single_symbol.bindat");
var reader = new UserBinaryReader(new MemoryStream(data));
ReaderTestCommon.SingleSymbol(reader);
}
public void ReadTypeAnnotations_SingleField()
{
// a singlefield structure with annotations
// {withannot:years::months::days::hours::minutes::seconds::18}
byte[] data = DirStructure.OwnTestFileAsBytes("binary/annot_singlefield.bindat");
UserBinaryReader reader = new UserBinaryReader(new MemoryStream(data));
ReaderTestCommon.ReadTypeAnnotations_SingleField(reader);
}
public void BadFieldName(string fileName)
{
var reader = ReaderFromFile(DirStructure.IonTestFile($"bad/{fileName}.ion"), InputStyle.FileStream);
Assert.AreEqual(IonType.Struct, reader.MoveNext());
reader.StepIn();
//should throw here
reader.MoveNext();
}
public void HasAnnotationFalse_SingleField()
{
// a singlefield structure with annotations
// {withannot:years::months::days::hours::minutes::seconds::18}
byte[] data = DirStructure.OwnTestFileAsBytes("text/annot_singlefield.ion");
UserTextReader reader = new UserTextReader(new MemoryStream(data));
ReaderTestCommon.HasAnnotationFalse_SingleField(reader);
}
public void FloatWithTerminatingEof()
{
var file = DirStructure.IonTestFile("good/floatWithTerminatingEof.ion");
var r = ReaderFromFile(file, InputStyle.FileStream);
Assert.AreEqual(IonType.Float, r.MoveNext());
ReaderTestCommon.AssertFloatEqual(12.3, r.DoubleValue());
Assert.AreEqual(IonType.None, r.MoveNext());
}
public void SingleIntList()
{
var data = DirStructure.OwnTestFileAsBytes("text/single_int_list.ion");
var reader = new UserTextReader(new MemoryStream(data));
ReaderTestCommon.SingleIntList(reader);
reader = new UserTextReader(Encoding.UTF8.GetString(data));
ReaderTestCommon.SingleIntList(reader);
}
public void Combined1()
{
var data = DirStructure.OwnTestFileAsBytes("text/combined1.ion");
var reader = new UserTextReader(new MemoryStream(data));
ReaderTestCommon.Combined1(reader);
reader = new UserTextReader(Encoding.UTF8.GetString(data));
ReaderTestCommon.Combined1(reader);
}
public void Struct_OneBlob()
{
var data = DirStructure.OwnTestFileAsBytes("text/struct_oneblob.ion");
var reader = new UserTextReader(new MemoryStream(data));
ReaderTestCommon.Struct_OneBlob(reader);
reader = new UserTextReader(Encoding.UTF8.GetString(data));
ReaderTestCommon.Struct_OneBlob(reader);
}
public void ReadAnnotations_SingleField()
{
// a singlefield structure with annotations
// {withannot:years::months::days::hours::minutes::seconds::18}
var annotSingleField = DirStructure.OwnTestFileAsBytes("binary/annot_singlefield.bindat");
var converter = new SaveAnnotationsReaderRoutine();
var reader = new UserBinaryReader(new MemoryStream(annotSingleField), converter);
ReaderTestCommon.ReadAnnotations_SingleField(reader, converter);
}
public void FloatDblMax()
{
var file = DirStructure.IonTestFile("good/floatDblMax.ion");
var floats = new[]
{
1.7976931348623157e308
};
AssertReaderWriterPrescision(file, floats);
}
public void Date_2000_11_20_8_20_15_Unknown()
{
var data = DirStructure.ReadDataFile("binary/ts_2000_11_20_8_20_15_unknown.bindat");
IIonReader reader = new UserBinaryReader(new MemoryStream(data));
Assert.AreEqual(IonType.Timestamp, reader.MoveNext());
var timeStamp = reader.TimestampValue();
var datetime = new DateTime(2000, 11, 20, 8, 20, 15, DateTimeKind.Unspecified);
Assert.AreEqual(datetime, timeStamp.DateTime);
}
public void Float_zeros()
{
var file = DirStructure.IonTestFile("good/float_zeros.ion");
var reader = ReaderFromFile(file, InputStyle.FileStream);
while (reader.MoveNext() != IonType.None)
{
Assert.AreEqual(IonType.Float, reader.CurrentType);
Assert.AreEqual(0d, reader.DoubleValue());
}
}
public void EolComment(string fileName)
{
var fileAsStream = DirStructure.IonTestFileAsStream(fileName);
var reader = new UserTextReader(fileAsStream);
Assert.AreEqual(IonType.List, reader.MoveNext());
reader.StepIn();
Assert.AreEqual(IonType.None, reader.MoveNext());
reader.StepOut();
Assert.AreEqual(IonType.None, reader.MoveNext());
}
public void OneBoolInStruct()
{
//simple datagram: {yolo:true}
var oneBool = DirStructure.OwnTestFileAsBytes("text/onebool.ion");
var reader = new UserTextReader(new MemoryStream(oneBool));
ReaderTestCommon.OneBoolInStruct(reader);
reader = new UserTextReader(Encoding.UTF8.GetString(oneBool));
ReaderTestCommon.OneBoolInStruct(reader);
}
public void FloatTrappedZeros()
{
var file = DirStructure.IonTestFile("good/float_trapped_zeros.ion");
var floats = new[]
{
1.0000000000000002e0,
-1.0000000000000002e0
};
AssertReaderWriterPrescision(file, floats);
}
