public static void Test_CloneTextReader_01(string file)
{
FileStream fileStream = null;
string traceFile = zpath.PathSetFileName(file, zPath.GetFileNameWithoutExtension(file) + "_out_text_clone");
Trace.WriteLine("Test.Test_Unit.Test_Unit_PBBsonReader.Test_CloneTextReader_01()");
Trace.WriteLine("trace to file \"{0}\"", traceFile);
Trace.WriteLine();
Trace.CurrentTrace.DisableBaseLog();
Trace.CurrentTrace.AddTraceFile(traceFile, LogOptions.RazLogFile);
try
{
Trace.WriteLine("Test.Test_Unit.Test_Unit_PBBsonReader.Test_CloneTextReader_01()");
Trace.WriteLine();
Trace.WriteLine("read file \"{0}\"", file);
Trace.WriteLine();
PBBsonReader.TraceLevel = 0;
PBBsonReader reader = new PBBsonReader(BsonReader.Create(new StreamReader(new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read), Encoding.UTF8)));
PBBsonReader readerClone1 = null;
int pos1 = 0;
int pos = 1;
while (reader.Read())
{
TracePBBsonReader(reader, pos++);
if (pos == 5)
{
Trace.WriteLine("**** create clone 1 at {0}", pos);
readerClone1 = reader.Clone();
pos1 = pos;
}
}
Trace.WriteLine();
Trace.WriteLine("read clone 1");
reader = readerClone1;
pos = pos1;
while (reader.Read())
{
TracePBBsonReader(reader, pos++);
}
}
finally
{
if (fileStream != null)
{
fileStream.Close();
}
Trace.CurrentTrace.EnableBaseLog();
Trace.CurrentTrace.RemoveTraceFile(traceFile);
}
}
public void TestSymbol()
{
var document = new BsonDocument {
{ "symbol", BsonSymbol.Create("name") }
};
using (var bsonReader = BsonReader.Create(document)) {
var rehydrated = BsonDocument.ReadFrom(bsonReader);
Assert.IsTrue(document.Equals(rehydrated));
}
}
public void TestNull()
{
var document = new BsonDocument {
{ "maxkey", BsonNull.Value }
};
using (var bsonReader = BsonReader.Create(document)) {
var rehydrated = BsonDocument.ReadFrom(bsonReader);
Assert.IsTrue(document.Equals(rehydrated));
}
}
public void TestGuid()
{
var document = new BsonDocument {
{ "guid", new Guid("B5F21E0C2A0D42d6AD03D827008D8AB6") }
};
using (var bsonReader = BsonReader.Create(document)) {
var rehydrated = BsonDocument.ReadFrom(bsonReader);
Assert.IsTrue(document.Equals(rehydrated));
}
}
public void TestJavaScriptWithScope()
{
var document = new BsonDocument {
{ "f", new BsonJavaScriptWithScope("function f() { return n; }", new BsonDocument("n", 1)) }
};
using (var bsonReader = BsonReader.Create(document)) {
var rehydrated = BsonDocument.ReadFrom(bsonReader);
Assert.IsTrue(document.Equals(rehydrated));
}
}
public void TestBinary()
{
var document = new BsonDocument {
{ "bin", new BsonBinaryData(new byte[] { 1, 2, 3 }) }
};
using (var bsonReader = BsonReader.Create(document)) {
var rehydrated = BsonDocument.ReadFrom(bsonReader);
Assert.IsTrue(document.Equals(rehydrated));
}
}
public void TestTimestamp()
{
var document = new BsonDocument {
{ "timestamp", new BsonTimestamp(1234567890) }
};
using (var bsonReader = BsonReader.Create(document)) {
var rehydrated = BsonDocument.ReadFrom(bsonReader);
Assert.IsTrue(document.Equals(rehydrated));
}
}
public void TestDouble()
{
var json = "1.5";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.Double, bsonReader.ReadBsonType());
Assert.AreEqual(1.5, bsonReader.ReadDouble());
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <double>(new StringReader(json)).ToJson());
}
public static IEnumerable <T> StringReader <T>(string text)
{
using (StringReader stringReader = new StringReader(text))
{
BsonReader reader = BsonReader.Create(stringReader);
while (reader.ReadBsonType() != BsonType.EndOfDocument)
{
yield return(BsonSerializer.Deserialize <T>(reader));
}
}
}
public void TestNull()
{
var json = "null";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.Null, bsonReader.ReadBsonType());
bsonReader.ReadNull();
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <BsonNull>(new StringReader(json)).ToJson());
}
public void TestStringEmpty()
{
var json = "\"\"";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.String, bsonReader.ReadBsonType());
Assert.AreEqual("", bsonReader.ReadString());
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <string>(new StringReader(json)).ToJson());
}
public void TestJavaScript()
{
string json = "{ \"$code\" : \"function f() { return 1; }\" }";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.JavaScript, bsonReader.ReadBsonType());
Assert.AreEqual("function f() { return 1; }", bsonReader.ReadJavaScript());
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <BsonJavaScript>(new StringReader(json)).ToJson());
}
public void TestTimestamp()
{
var json = "{ \"$timestamp\" : NumberLong(1234) }";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.Timestamp, bsonReader.ReadBsonType());
Assert.AreEqual(1234L, bsonReader.ReadTimestamp());
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <BsonTimestamp>(new StringReader(json)).ToJson());
}
public void TestInt32()
{
var json = "123";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.Int32, bsonReader.ReadBsonType());
Assert.AreEqual(123, bsonReader.ReadInt32());
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <int>(new StringReader(json)).ToJson());
}
public void TestInt64NumberLong()
{
var json = "NumberLong(123)";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.Int64, bsonReader.ReadBsonType());
Assert.AreEqual(123, bsonReader.ReadInt64());
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <long>(new StringReader(json)).ToJson());
}
public static Dictionary <Tkey, Tvalue> AsDictionary <Tkey, Tvalue>(this BsonValue bsonValue)
{
using (BsonReader reader = BsonReader.Create(bsonValue.ToJson()))
{
var dictionarySerializer = new DictionarySerializer <Tkey, Tvalue>();
object result = dictionarySerializer.Deserialize(reader,
typeof(Dictionary <Tkey, Tvalue>),
new DictionarySerializationOptions());
return((Dictionary <Tkey, Tvalue>)result);
}
}
public void TestUndefined()
{
var json = "undefined";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.Undefined, bsonReader.ReadBsonType());
bsonReader.ReadUndefined();
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <BsonUndefined>(new StringReader(json)).ToJson());
}
public void TestDateTimeMaxBson()
{
var json = "new Date(9223372036854775807)";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.DateTime, bsonReader.ReadBsonType());
Assert.AreEqual(9223372036854775807, bsonReader.ReadDateTime());
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <BsonDateTime>(new StringReader(json)).ToJson());
}
public void TestBooleanTrue()
{
var json = "true";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.Boolean, bsonReader.ReadBsonType());
Assert.AreEqual(true, bsonReader.ReadBoolean());
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <bool>(new StringReader(json)).ToJson());
}
public void TestDateTimeStrict()
{
var json = "{ \"$date\" : 0 }";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.DateTime, bsonReader.ReadBsonType());
Assert.AreEqual(BsonConstants.UnixEpoch, bsonReader.ReadDateTime());
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <DateTime>(new StringReader(json)).ToJson());
}
public void TestSymbol()
{
var json = "{ \"$symbol\" : \"symbol\" }";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.Symbol, bsonReader.ReadBsonType());
Assert.AreEqual("symbol", bsonReader.ReadSymbol());
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <BsonSymbol>(new StringReader(json)).ToJson());
}
public void TestMinKey()
{
var json = "{ \"$minkey\" : 1 }";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.MinKey, bsonReader.ReadBsonType());
bsonReader.ReadMinKey();
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <BsonMinKey>(new StringReader(json)).ToJson());
}
public void TestSingleString()
{
BsonDocument document = new BsonDocument()
{
{ "abc", "xyz" }
};
using (var bsonReader = BsonReader.Create(document)) {
var rehydrated = BsonDocument.ReadFrom(bsonReader);
Assert.IsTrue(document.Equals(rehydrated));
}
}
//public static MongoDBRef ToDBRef(this Guid id, string href)
//{
// Guard.Instance.ArgumentNotNullOrWhiteSpace(()=>href, href);
// return new MongoDBRef(href, BsonValue.Create(id));
//}
static public BsonDocument ToBsonDocument(this string from)
{
if (string.IsNullOrWhiteSpace(from))
{
return(null);
}
using (var reader = BsonReader.Create(from))
{
return(BsonDocument.ReadFrom(reader));
}
}
public void TestObjectIdShell()
{
var json = "ObjectId(\"4d0ce088e447ad08b4721a37\")";
using (_bsonReader = BsonReader.Create(json))
{
Assert.AreEqual(BsonType.ObjectId, _bsonReader.ReadBsonType());
var objectId = _bsonReader.ReadObjectId();
Assert.AreEqual("4d0ce088e447ad08b4721a37", objectId.ToString());
Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <ObjectId>(new StringReader(json)).ToJson());
}
/// <summary>
/// Deserializes the value.
/// </summary>
/// <param name="value">The value.</param>
/// <returns>The deserialized value.</returns>
public object DeserializeValue(BsonValue value)
{
var tempDocument = new BsonDocument("value", value);
using (var reader = BsonReader.Create(tempDocument))
{
reader.ReadStartDocument();
reader.ReadName("value");
var deserializedValue = _serializer.Deserialize(reader, _nominalType, _serializationOptions);
reader.ReadEndDocument();
return(deserializedValue);
}
}
public void TestArrayEmpty()
{
var json = "[]";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.Array, bsonReader.ReadBsonType());
bsonReader.ReadStartArray();
Assert.AreEqual(BsonType.EndOfDocument, bsonReader.ReadBsonType());
bsonReader.ReadEndArray();
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <BsonArray>(new StringReader(json)).ToJson());
}
private void TryLoadData()
{
try
{
BsonReader reader = BsonReader.Create(File.ReadAllText(this.settingsFileLocation));
this.settings = BsonSerializer.Deserialize <MusicDatabaseSettings>(reader);
}
catch
{
this.settings = MusicDatabaseSettings.CreateDefault();
this.Save();
}
}
public void TestSingleString()
{
BsonDocument document = new BsonDocument()
{
{ "abc", "xyz" }
};
using (var bsonReader = BsonReader.Create(document))
{
var rehydrated = (BsonDocument)BsonDocumentSerializer.Instance.Deserialize(bsonReader, typeof(BsonDocument), null);
Assert.IsTrue(document.Equals(rehydrated));
}
}
public void TestDateTime()
{
DateTime jan_1_2010 = DateTime.SpecifyKind(new DateTime(2010, 1, 1), DateTimeKind.Utc);
BsonDocument document = new BsonDocument()
{
{ "date", jan_1_2010 }
};
using (var bsonReader = BsonReader.Create(document)) {
var rehydrated = BsonDocument.ReadFrom(bsonReader);
Assert.IsTrue(document.Equals(rehydrated));
}
}
