Mirror
/
mongo-csharp-driver
mirror of https://github.com/mongodb/mongo-csharp-driver.git
2
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

Consolidated collection serializers in CollectionSerializers.cs and CollectionSerializersGeneric.cs (and similarly for the unit tests). Added unit tests for more generic collection types.

pull/28/head
rstam 15 years ago
parent
e709dd5675
commit
e918733496
10 changed files with 279 additions and 623 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      Bson/Bson.csproj
  2. 117
      Bson/DefaultSerializer/Serializers/CollectionSerializers.cs
  3. 96
      Bson/DefaultSerializer/Serializers/CollectionSerializersGeneric.cs
  4. 103
      Bson/DefaultSerializer/Serializers/EnumerableSerializer.cs
  5. 96
      Bson/DefaultSerializer/Serializers/EnumerableSerializerGeneric.cs
  6. 6
      BsonUnitTests/BsonUnitTests.csproj
  7. 65
      BsonUnitTests/DefaultSerializer/Serializers/CollectionSerializerGenericTests.cs
  8. 87
      BsonUnitTests/DefaultSerializer/Serializers/CollectionSerializerTests.cs
  9. 163
      BsonUnitTests/DefaultSerializer/Serializers/QueueSerializerTests.cs
  10. 163
      BsonUnitTests/DefaultSerializer/Serializers/StackSerializerTests.cs

6
Bson/Bson.csproj
View File

@ -86,12 +86,10 @@
<Compile Include="DefaultSerializer\Conventions\ElementNameConventions.cs" />
<Compile Include="DefaultSerializer\Conventions\IdMemberConventions.cs" />
<Compile Include="DefaultSerializer\Conventions\IgnoreExtraElementsConventions.cs" />
<Compile Include="DefaultSerializer\Serializers\EnumerableSerializerGeneric.cs" />
<Compile Include="DefaultSerializer\Serializers\EnumerableSerializer.cs" />
<Compile Include="DefaultSerializer\Serializers\CollectionSerializersGeneric.cs" />
<Compile Include="DefaultSerializer\Serializers\CollectionSerializers.cs" />
<Compile Include="DefaultSerializer\Serializers\NullableTypeSerializer.cs" />
<Compile Include="DefaultSerializer\Serializers\ObjectSerializer.cs" />
<Compile Include="DefaultSerializer\Serializers\QueueSerializers.cs" />
<Compile Include="DefaultSerializer\Serializers\StackSerializers.cs" />
<Compile Include="Exceptions\BsonInternalException.cs" />
<Compile Include="Exceptions\BsonSerializationException.cs" />
<Compile Include="ObjectModel\IConvertibleToBsonDocument.cs" />

117
Bson/DefaultSerializer/Serializers/QueueSerializers.cs → Bson/DefaultSerializer/Serializers/CollectionSerializers.cs
View File

@ -24,6 +24,83 @@ using MongoDB.Bson.IO;
using MongoDB.Bson.Serialization;
namespace MongoDB.Bson.DefaultSerializer {
public class EnumerableSerializer : BsonBaseSerializer {
#region private static fields
private static EnumerableSerializer singleton = new EnumerableSerializer();
#endregion
#region constructors
private EnumerableSerializer() {
}
#endregion
#region public static properties
public static EnumerableSerializer Singleton {
get { return singleton; }
}
#endregion
#region public static methods
public static void RegisterSerializers() {
BsonSerializer.RegisterSerializer(typeof(ArrayList), singleton);
BsonSerializer.RegisterSerializer(typeof(ICollection), singleton);
BsonSerializer.RegisterSerializer(typeof(IEnumerable), singleton);
BsonSerializer.RegisterSerializer(typeof(IList), singleton);
}
#endregion
#region public methods
public override object DeserializeElement(
BsonReader bsonReader,
Type nominalType,
out string name
) {
var bsonType = bsonReader.PeekBsonType();
if (bsonType == BsonType.Null) {
bsonReader.ReadNull(out name);
return null;
} else if (bsonType == BsonType.Array) {
bsonReader.ReadArrayName(out name);
bsonReader.ReadStartDocument();
var list = new ArrayList();
while (bsonReader.HasElement()) {
var elementType = BsonClassMapSerializer.GetActualElementType(bsonReader, typeof(object));
var serializer = BsonSerializer.LookupSerializer(elementType);
string elementName; // elementNames are ignored on input
var element = serializer.DeserializeElement(bsonReader, typeof(object), out elementName);
list.Add(element);
}
bsonReader.ReadEndDocument();
return list;
} else {
var message = string.Format("Can't deserialize a {0} from BsonType {1}", nominalType.FullName, bsonType);
throw new FileFormatException(message);
}
}
public override void SerializeElement(
BsonWriter bsonWriter,
Type nominalType,
string name,
object value
) {
if (value == null) {
bsonWriter.WriteNull(name);
} else {
bsonWriter.WriteArrayName(name);
bsonWriter.WriteStartDocument();
int index = 0;
foreach (var element in (IEnumerable) value) {
var elementName = index.ToString();
BsonSerializer.SerializeElement(bsonWriter, typeof(object), elementName, element);
index++;
}
bsonWriter.WriteEndDocument();
}
}
#endregion
}
public class QueueSerializer : BsonBaseSerializer {
#region private static fields
private static QueueSerializer singleton = new QueueSerializer();
@ -98,17 +175,25 @@ namespace MongoDB.Bson.DefaultSerializer {
#endregion
}
public static class QueueSerializerRegistration {
#region public static methods
public static void RegisterGenericSerializerDefinitions() {
BsonSerializer.RegisterGenericSerializerDefinition(typeof(Queue<>), typeof(QueueSerializer<>));
}
public class StackSerializer : BsonBaseSerializer {
#region private static fields
private static StackSerializer singleton = new StackSerializer();
#endregion
}
public class QueueSerializer<T> : BsonBaseSerializer {
#region constructors
public QueueSerializer() {
private StackSerializer() {
}
#endregion
#region public static properties
public static StackSerializer Singleton {
get { return singleton; }
}
#endregion
#region public static methods
public static void RegisterSerializers() {
BsonSerializer.RegisterSerializer(typeof(Stack), singleton);
}
#endregion
@ -125,16 +210,16 @@ namespace MongoDB.Bson.DefaultSerializer {
} else if (bsonType == BsonType.Array) {
bsonReader.ReadArrayName(out name);
bsonReader.ReadStartDocument();
var queue = new Queue<T>();
var stack = new Stack();
while (bsonReader.HasElement()) {
var elementType = BsonClassMapSerializer.GetActualElementType(bsonReader, typeof(T));
var elementType = BsonClassMapSerializer.GetActualElementType(bsonReader, typeof(object));
var serializer = BsonSerializer.LookupSerializer(elementType);
string elementName; // elementNames are ignored on input
var element = (T) serializer.DeserializeElement(bsonReader, typeof(T), out elementName);
queue.Enqueue(element);
var element = serializer.DeserializeElement(bsonReader, typeof(object), out elementName);
stack.Push(element);
}
bsonReader.ReadEndDocument();
return queue;
return stack;
} else {
var message = string.Format("Can't deserialize a {0} from BsonType {1}", nominalType.FullName, bsonType);
throw new FileFormatException(message);
@ -152,10 +237,12 @@ namespace MongoDB.Bson.DefaultSerializer {
} else {
bsonWriter.WriteArrayName(name);
bsonWriter.WriteStartDocument();
var outputOrder = new ArrayList((Stack) value); // serialize first pushed item first (reverse of enumerator order)
outputOrder.Reverse();
int index = 0;
foreach (var element in (Queue<T>) value) {
foreach (var element in outputOrder) {
var elementName = index.ToString();
BsonSerializer.SerializeElement(bsonWriter, typeof(T), elementName, element);
BsonSerializer.SerializeElement(bsonWriter, typeof(object), elementName, element);
index++;
}
bsonWriter.WriteEndDocument();

96
Bson/DefaultSerializer/Serializers/StackSerializers.cs → Bson/DefaultSerializer/Serializers/CollectionSerializersGeneric.cs
View File

@ -24,25 +24,87 @@ using MongoDB.Bson.IO;
using MongoDB.Bson.Serialization;
namespace MongoDB.Bson.DefaultSerializer {
public class StackSerializer : BsonBaseSerializer {
#region private static fields
private static StackSerializer singleton = new StackSerializer();
public static class EnumerableSerializerRegistration {
#region public static methods
public static void RegisterGenericSerializerDefinitions() {
BsonSerializer.RegisterGenericSerializerDefinition(typeof(HashSet<>), typeof(EnumerableSerializer<>));
BsonSerializer.RegisterGenericSerializerDefinition(typeof(ICollection<>), typeof(EnumerableSerializer<>));
BsonSerializer.RegisterGenericSerializerDefinition(typeof(IEnumerable<>), typeof(EnumerableSerializer<>));
BsonSerializer.RegisterGenericSerializerDefinition(typeof(IList<>), typeof(EnumerableSerializer<>));
BsonSerializer.RegisterGenericSerializerDefinition(typeof(List<>), typeof(EnumerableSerializer<>));
}
#endregion
}
public class EnumerableSerializer<T> : BsonBaseSerializer {
#region constructors
private StackSerializer() {
public EnumerableSerializer() {
}
#endregion
#region public static properties
public static StackSerializer Singleton {
get { return singleton; }
#region public methods
public override object DeserializeElement(
BsonReader bsonReader,
Type nominalType,
out string name
) {
var bsonType = bsonReader.PeekBsonType();
if (bsonType == BsonType.Null) {
bsonReader.ReadNull(out name);
return null;
} else if (bsonType == BsonType.Array) {
bsonReader.ReadArrayName(out name);
bsonReader.ReadStartDocument();
var list = (nominalType.IsInterface) ? new List<T>() : (ICollection<T>) Activator.CreateInstance(nominalType);
while (bsonReader.HasElement()) {
var elementType = BsonClassMapSerializer.GetActualElementType(bsonReader, typeof(T));
var serializer = BsonSerializer.LookupSerializer(elementType);
string elementName; // elementNames are ignored on input
var element = (T) serializer.DeserializeElement(bsonReader, typeof(T), out elementName);
list.Add(element);
}
bsonReader.ReadEndDocument();
return list;
} else {
var message = string.Format("Can't deserialize a {0} from BsonType {1}", nominalType.FullName, bsonType);
throw new FileFormatException(message);
}
}
public override void SerializeElement(
BsonWriter bsonWriter,
Type nominalType,
string name,
object value
) {
if (value == null) {
bsonWriter.WriteNull(name);
} else {
bsonWriter.WriteArrayName(name);
bsonWriter.WriteStartDocument();
int index = 0;
foreach (var element in (IEnumerable<T>) value) {
var elementName = index.ToString();
BsonSerializer.SerializeElement(bsonWriter, typeof(T), elementName, element);
index++;
}
bsonWriter.WriteEndDocument();
}
}
#endregion
}
public static class QueueSerializerRegistration {
#region public static methods
public static void RegisterSerializers() {
BsonSerializer.RegisterSerializer(typeof(Stack), singleton);
public static void RegisterGenericSerializerDefinitions() {
BsonSerializer.RegisterGenericSerializerDefinition(typeof(Queue<>), typeof(QueueSerializer<>));
}
#endregion
}
public class QueueSerializer<T> : BsonBaseSerializer {
#region constructors
public QueueSerializer() {
}
#endregion
@ -59,16 +121,16 @@ namespace MongoDB.Bson.DefaultSerializer {
} else if (bsonType == BsonType.Array) {
bsonReader.ReadArrayName(out name);
bsonReader.ReadStartDocument();
var stack = new Stack();
var queue = new Queue<T>();
while (bsonReader.HasElement()) {
var elementType = BsonClassMapSerializer.GetActualElementType(bsonReader, typeof(object));
var elementType = BsonClassMapSerializer.GetActualElementType(bsonReader, typeof(T));
var serializer = BsonSerializer.LookupSerializer(elementType);
string elementName; // elementNames are ignored on input
var element = serializer.DeserializeElement(bsonReader, typeof(object), out elementName);
stack.Push(element);
var element = (T) serializer.DeserializeElement(bsonReader, typeof(T), out elementName);
queue.Enqueue(element);
}
bsonReader.ReadEndDocument();
return stack;
return queue;
} else {
var message = string.Format("Can't deserialize a {0} from BsonType {1}", nominalType.FullName, bsonType);
throw new FileFormatException(message);
@ -86,12 +148,10 @@ namespace MongoDB.Bson.DefaultSerializer {
} else {
bsonWriter.WriteArrayName(name);
bsonWriter.WriteStartDocument();
var outputOrder = new ArrayList((Stack) value); // serialize first pushed item first (reverse of enumerator order)
outputOrder.Reverse();
int index = 0;
foreach (var element in outputOrder) {
foreach (var element in (Queue<T>) value) {
var elementName = index.ToString();
BsonSerializer.SerializeElement(bsonWriter, typeof(object), elementName, element);
BsonSerializer.SerializeElement(bsonWriter, typeof(T), elementName, element);
index++;
}
bsonWriter.WriteEndDocument();

103
Bson/DefaultSerializer/Serializers/EnumerableSerializer.cs
View File

@ -1,103 +0,0 @@
/* Copyright 2010 10gen Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using MongoDB.Bson.IO;
using MongoDB.Bson.Serialization;
namespace MongoDB.Bson.DefaultSerializer {
public class EnumerableSerializer : BsonBaseSerializer {
#region private static fields
private static EnumerableSerializer singleton = new EnumerableSerializer();
#endregion
#region constructors
private EnumerableSerializer() {
}
#endregion
#region public static properties
public static EnumerableSerializer Singleton {
get { return singleton; }
}
#endregion
#region public static methods
public static void RegisterSerializers() {
BsonSerializer.RegisterSerializer(typeof(ArrayList), singleton);
BsonSerializer.RegisterSerializer(typeof(ICollection), singleton);
BsonSerializer.RegisterSerializer(typeof(IEnumerable), singleton);
BsonSerializer.RegisterSerializer(typeof(IList), singleton);
}
#endregion
#region public methods
public override object DeserializeElement(
BsonReader bsonReader,
Type nominalType,
out string name
) {
var bsonType = bsonReader.PeekBsonType();
if (bsonType == BsonType.Null) {
bsonReader.ReadNull(out name);
return null;
} else if (bsonType == BsonType.Array) {
bsonReader.ReadArrayName(out name);
bsonReader.ReadStartDocument();
var list = new ArrayList();
while (bsonReader.HasElement()) {
var elementType = BsonClassMapSerializer.GetActualElementType(bsonReader, typeof(object));
var serializer = BsonSerializer.LookupSerializer(elementType);
string elementName; // elementNames are ignored on input
var element = serializer.DeserializeElement(bsonReader, typeof(object), out elementName);
list.Add(element);
}
bsonReader.ReadEndDocument();
return list;
} else {
var message = string.Format("Can't deserialize a {0} from BsonType {1}", nominalType.FullName, bsonType);
throw new FileFormatException(message);
}
}
public override void SerializeElement(
BsonWriter bsonWriter,
Type nominalType,
string name,
object value
) {
if (value == null) {
bsonWriter.WriteNull(name);
} else {
bsonWriter.WriteArrayName(name);
bsonWriter.WriteStartDocument();
int index = 0;
foreach (var element in (IEnumerable) value) {
var elementName = index.ToString();
BsonSerializer.SerializeElement(bsonWriter, typeof(object), elementName, element);
index++;
}
bsonWriter.WriteEndDocument();
}
}
#endregion
}
}

96
Bson/DefaultSerializer/Serializers/EnumerableSerializerGeneric.cs
View File

@ -1,96 +0,0 @@
/* Copyright 2010 10gen Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using MongoDB.Bson.IO;
using MongoDB.Bson.Serialization;
namespace MongoDB.Bson.DefaultSerializer {
public static class EnumerableSerializerRegistration {
#region public static methods
public static void RegisterGenericSerializerDefinitions() {
BsonSerializer.RegisterGenericSerializerDefinition(typeof(HashSet<>), typeof(EnumerableSerializer<>));
BsonSerializer.RegisterGenericSerializerDefinition(typeof(List<>), typeof(EnumerableSerializer<>));
BsonSerializer.RegisterGenericSerializerDefinition(typeof(ICollection<>), typeof(EnumerableSerializer<>));
BsonSerializer.RegisterGenericSerializerDefinition(typeof(IEnumerable<>), typeof(EnumerableSerializer<>));
BsonSerializer.RegisterGenericSerializerDefinition(typeof(IList<>), typeof(EnumerableSerializer<>));
}
#endregion
}
public class EnumerableSerializer<T> : BsonBaseSerializer {
#region constructors
public EnumerableSerializer() {
}
#endregion
#region public methods
public override object DeserializeElement(
BsonReader bsonReader,
Type nominalType,
out string name
) {
var bsonType = bsonReader.PeekBsonType();
if (bsonType == BsonType.Null) {
bsonReader.ReadNull(out name);
return null;
} else if (bsonType == BsonType.Array) {
bsonReader.ReadArrayName(out name);
bsonReader.ReadStartDocument();
var list = (nominalType.IsInterface) ? new List<T>() : (ICollection<T>) Activator.CreateInstance(nominalType);
while (bsonReader.HasElement()) {
var elementType = BsonClassMapSerializer.GetActualElementType(bsonReader, typeof(T));
var serializer = BsonSerializer.LookupSerializer(elementType);
string elementName; // elementNames are ignored on input
var element = (T) serializer.DeserializeElement(bsonReader, typeof(T), out elementName);
list.Add(element);
}
bsonReader.ReadEndDocument();
return list;
} else {
var message = string.Format("Can't deserialize a {0} from BsonType {1}", nominalType.FullName, bsonType);
throw new FileFormatException(message);
}
}
public override void SerializeElement(
BsonWriter bsonWriter,
Type nominalType,
string name,
object value
) {
if (value == null) {
bsonWriter.WriteNull(name);
} else {
bsonWriter.WriteArrayName(name);
bsonWriter.WriteStartDocument();
int index = 0;
foreach (var element in (IEnumerable<T>) value) {
var elementName = index.ToString();
BsonSerializer.SerializeElement(bsonWriter, typeof(T), elementName, element);
index++;
}
bsonWriter.WriteEndDocument();
}
}
#endregion
}
}

6
BsonUnitTests/BsonUnitTests.csproj
View File

@ -81,11 +81,9 @@
<Compile Include="DefaultSerializer\Conventions\ElementNameConventionsTests.cs" />
<Compile Include="DefaultSerializer\SerializeFlagsTests.cs" />
<Compile Include="DefaultSerializer\Serializers\DateTimeSerializerTests.cs" />
<Compile Include="DefaultSerializer\Serializers\EnumerableSerializerGenericTests.cs" />
<Compile Include="DefaultSerializer\Serializers\EnumerableSerializerTests.cs" />
<Compile Include="DefaultSerializer\Serializers\CollectionSerializerGenericTests.cs" />
<Compile Include="DefaultSerializer\Serializers\CollectionSerializerTests.cs" />
<Compile Include="DefaultSerializer\Serializers\NullableTypeSerializerTests.cs" />
<Compile Include="DefaultSerializer\Serializers\QueueSerializerTests.cs" />
<Compile Include="DefaultSerializer\Serializers\StackSerializerTests.cs" />
<Compile Include="IO\BsonBufferValueStraddlesChunksTests.cs" />
<Compile Include="Jira\CSharp70Tests.cs" />
<Compile Include="Jira\CSharp71Tests.cs" />

65
BsonUnitTests/DefaultSerializer/Serializers/EnumerableSerializerGenericTests.cs → BsonUnitTests/DefaultSerializer/Serializers/CollectionSerializerGenericTests.cs
View File

@ -23,8 +23,8 @@ using MongoDB.Bson;
using MongoDB.Bson.DefaultSerializer;
using MongoDB.Bson.Serialization;
namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializerGeneric {
[BsonDiscriminator("EnumerableSerializerGeneric.C")] // "C" is an ambiguous discriminator when nominalType is System.Object
namespace MongoDB.BsonUnitTests.DefaultSerializer.CollectionSerializersGeneric {
[BsonDiscriminator("CollectionSerializersGeneric.C")] // "C" is an ambiguous discriminator when nominalType is System.Object
public class C {
public string P { get; set; }
}
@ -33,6 +33,8 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializerGeneric {
public class EnumerableSerializerTests {
public class T {
public List<object> L { get; set; }
public Queue<object> Q { get; set; }
public Stack<object> S { get; set; }
public ICollection<object> IC { get; set; }
public IEnumerable<object> IE { get; set; }
public IList<object> IL { get; set; }
@ -40,16 +42,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializerGeneric {
[Test]
public void TestNull() {
List<object> list = null;
var obj = new T { L = list, IC = list, IE = list, IL = list };
var obj = new T { L = null, Q = null, S = null, IC = null, IE = null, IL = null };
var json = obj.ToJson();
var rep = "null";
var expected = "{ 'L' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsNull(rehydrated.L);
Assert.IsNull(rehydrated.Q);
Assert.IsNull(rehydrated.S);
Assert.IsNull(rehydrated.IC);
Assert.IsNull(rehydrated.IE);
Assert.IsNull(rehydrated.IL);
@ -59,15 +62,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializerGeneric {
[Test]
public void TestEmpty() {
var list = new List<object>();
var obj = new T { L = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue<object>(list), S = new Stack<object>(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "[]";
var expected = "{ 'L' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<List<object>>(rehydrated.L);
Assert.IsInstanceOf<Queue<object>>(rehydrated.Q);
Assert.IsInstanceOf<Stack<object>>(rehydrated.S);
Assert.IsInstanceOf<List<object>>(rehydrated.IC);
Assert.IsInstanceOf<List<object>>(rehydrated.IE);
Assert.IsInstanceOf<List<object>>(rehydrated.IL);
@ -77,15 +82,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializerGeneric {
[Test]
public void TestOneC() {
var list = new List<object>(new[] { new C { P = "x" } });
var obj = new T { L = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue<object>(list), S = new Stack<object>(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "[{ '_t' : 'EnumerableSerializerGeneric.C', 'P' : 'x' }]";
var expected = "{ 'L' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var rep = "[{ '_t' : 'CollectionSerializersGeneric.C', 'P' : 'x' }]";
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<List<object>>(rehydrated.L);
Assert.IsInstanceOf<Queue<object>>(rehydrated.Q);
Assert.IsInstanceOf<Stack<object>>(rehydrated.S);
Assert.IsInstanceOf<List<object>>(rehydrated.IC);
Assert.IsInstanceOf<List<object>>(rehydrated.IE);
Assert.IsInstanceOf<List<object>>(rehydrated.IL);
@ -95,15 +102,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializerGeneric {
[Test]
public void TestOneInt() {
var list = new List<object>(new object[] { 1 });
var obj = new T { L = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue<object>(list), S = new Stack<object>(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "[1]";
var expected = "{ 'L' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<List<object>>(rehydrated.L);
Assert.IsInstanceOf<Queue<object>>(rehydrated.Q);
Assert.IsInstanceOf<Stack<object>>(rehydrated.S);
Assert.IsInstanceOf<List<object>>(rehydrated.IC);
Assert.IsInstanceOf<List<object>>(rehydrated.IE);
Assert.IsInstanceOf<List<object>>(rehydrated.IL);
@ -113,15 +122,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializerGeneric {
[Test]
public void TestOneString() {
var list = new List<object>(new[] { "x" });
var obj = new T { L = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue<object>(list), S = new Stack<object>(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "['x']";
var expected = "{ 'L' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<List<object>>(rehydrated.L);
Assert.IsInstanceOf<Queue<object>>(rehydrated.Q);
Assert.IsInstanceOf<Stack<object>>(rehydrated.S);
Assert.IsInstanceOf<List<object>>(rehydrated.IC);
Assert.IsInstanceOf<List<object>>(rehydrated.IE);
Assert.IsInstanceOf<List<object>>(rehydrated.IL);
@ -131,15 +142,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializerGeneric {
[Test]
public void TestTwoCs() {
var list = new List<object>(new[] { new C { P = "x" }, new C { P = "y" } });
var obj = new T { L = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue<object>(list), S = new Stack<object>(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "[{ '_t' : 'EnumerableSerializerGeneric.C', 'P' : 'x' }, { '_t' : 'EnumerableSerializerGeneric.C', 'P' : 'y' }]";
var expected = "{ 'L' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var rep = "[{ '_t' : 'CollectionSerializersGeneric.C', 'P' : 'x' }, { '_t' : 'CollectionSerializersGeneric.C', 'P' : 'y' }]";
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<List<object>>(rehydrated.L);
Assert.IsInstanceOf<Queue<object>>(rehydrated.Q);
Assert.IsInstanceOf<Stack<object>>(rehydrated.S);
Assert.IsInstanceOf<List<object>>(rehydrated.IC);
Assert.IsInstanceOf<List<object>>(rehydrated.IE);
Assert.IsInstanceOf<List<object>>(rehydrated.IL);
@ -149,15 +162,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializerGeneric {
[Test]
public void TestTwoInts() {
var list = new List<object>(new object[] { 1, 2 });
var obj = new T { L = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue<object>(list), S = new Stack<object>(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "[1, 2]";
var expected = "{ 'L' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<List<object>>(rehydrated.L);
Assert.IsInstanceOf<Queue<object>>(rehydrated.Q);
Assert.IsInstanceOf<Stack<object>>(rehydrated.S);
Assert.IsInstanceOf<List<object>>(rehydrated.IC);
Assert.IsInstanceOf<List<object>>(rehydrated.IE);
Assert.IsInstanceOf<List<object>>(rehydrated.IL);
@ -167,15 +182,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializerGeneric {
[Test]
public void TestTwoStrings() {
var list = new List<object>(new[] { "x", "y" });
var obj = new T { L = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue<object>(list), S = new Stack<object>(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "['x', 'y']";
var expected = "{ 'L' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<List<object>>(rehydrated.L);
Assert.IsInstanceOf<Queue<object>>(rehydrated.Q);
Assert.IsInstanceOf<Stack<object>>(rehydrated.S);
Assert.IsInstanceOf<List<object>>(rehydrated.IC);
Assert.IsInstanceOf<List<object>>(rehydrated.IE);
Assert.IsInstanceOf<List<object>>(rehydrated.IL);
@ -189,18 +206,20 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializerGeneric {
var guid = Guid.Empty;
var objectId = ObjectId.Empty;
var list = new List<object>(new object[] { true, dateTime, 1.5, 1, 2L, guid, objectId, "x" });
var obj = new T { L = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue<object>(list), S = new Stack<object>(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "[true, #Date, 1.5, 1, 2, #Guid, #ObjectId, 'x']";
rep = rep.Replace("#Date", "{ '$date' : #ms }".Replace("#ms", millis.ToString()));
rep = rep.Replace("#Guid", "{ '$binary' : 'AAAAAAAAAAAAAAAAAAAAAA==', '$type' : '03' }");
rep = rep.Replace("#ObjectId", "{ '$oid' : '000000000000000000000000' }");
var expected = "{ 'L' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<List<object>>(rehydrated.L);
Assert.IsInstanceOf<Queue<object>>(rehydrated.Q);
Assert.IsInstanceOf<Stack<object>>(rehydrated.S);
Assert.IsInstanceOf<List<object>>(rehydrated.IC);
Assert.IsInstanceOf<List<object>>(rehydrated.IE);
Assert.IsInstanceOf<List<object>>(rehydrated.IL);

87
BsonUnitTests/DefaultSerializer/Serializers/EnumerableSerializerTests.cs → BsonUnitTests/DefaultSerializer/Serializers/CollectionSerializerTests.cs
View File

@ -23,16 +23,18 @@ using MongoDB.Bson;
using MongoDB.Bson.DefaultSerializer;
using MongoDB.Bson.Serialization;
namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializer {
[BsonDiscriminator("EnumerableSerializer.C")] // "C" is an ambiguous discriminator when nominalType is System.Object
namespace MongoDB.BsonUnitTests.DefaultSerializer.CollectionSerializers {
[BsonDiscriminator("CollectionSerializers.C")] // "C" is an ambiguous discriminator when nominalType is System.Object
public class C {
public string P { get; set; }
}
[TestFixture]
public class EnumerableSerializerTests {
public class CollectionSerializerTests {
public class T {
public ArrayList AL { get; set; }
public ArrayList L { get; set; }
public Queue Q { get; set; }
public Stack S { get; set; }
public ICollection IC { get; set; }
public IEnumerable IE { get; set; }
public IList IL { get; set; }
@ -40,16 +42,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializer {
[Test]
public void TestNull() {
ArrayList list = null;
var obj = new T { AL = list, IC = list, IE = list, IL = list };
var obj = new T { L = null, Q = null, S = null, IC = null, IE = null, IL = null };
var json = obj.ToJson();
var rep = "null";
var expected = "{ 'AL' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsNull(rehydrated.AL);
Assert.IsNull(rehydrated.L);
Assert.IsNull(rehydrated.Q);
Assert.IsNull(rehydrated.S);
Assert.IsNull(rehydrated.IC);
Assert.IsNull(rehydrated.IE);
Assert.IsNull(rehydrated.IL);
@ -59,15 +62,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializer {
[Test]
public void TestEmpty() {
var list = new ArrayList();
var obj = new T { AL = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue(list), S = new Stack(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "[]";
var expected = "{ 'AL' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<ArrayList>(rehydrated.AL);
Assert.IsInstanceOf<ArrayList>(rehydrated.L);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsInstanceOf<ArrayList>(rehydrated.IC);
Assert.IsInstanceOf<ArrayList>(rehydrated.IE);
Assert.IsInstanceOf<ArrayList>(rehydrated.IL);
@ -77,15 +82,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializer {
[Test]
public void TestOneC() {
var list = new ArrayList(new [] { new C { P = "x" } });
var obj = new T { AL = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue(list), S = new Stack(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "[{ '_t' : 'EnumerableSerializer.C', 'P' : 'x' }]";
var expected = "{ 'AL' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var rep = "[{ '_t' : 'CollectionSerializers.C', 'P' : 'x' }]";
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<ArrayList>(rehydrated.AL);
Assert.IsInstanceOf<ArrayList>(rehydrated.L);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsInstanceOf<ArrayList>(rehydrated.IC);
Assert.IsInstanceOf<ArrayList>(rehydrated.IE);
Assert.IsInstanceOf<ArrayList>(rehydrated.IL);
@ -95,15 +102,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializer {
[Test]
public void TestOneInt() {
var list = new ArrayList(new[] { 1 });
var obj = new T { AL = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue(list), S = new Stack(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "[1]";
var expected = "{ 'AL' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<ArrayList>(rehydrated.AL);
Assert.IsInstanceOf<ArrayList>(rehydrated.L);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsInstanceOf<ArrayList>(rehydrated.IC);
Assert.IsInstanceOf<ArrayList>(rehydrated.IE);
Assert.IsInstanceOf<ArrayList>(rehydrated.IL);
@ -113,15 +122,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializer {
[Test]
public void TestOneString() {
var list = new ArrayList(new[] { "x" });
var obj = new T { AL = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue(list), S = new Stack(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "['x']";
var expected = "{ 'AL' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<ArrayList>(rehydrated.AL);
Assert.IsInstanceOf<ArrayList>(rehydrated.L);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsInstanceOf<ArrayList>(rehydrated.IC);
Assert.IsInstanceOf<ArrayList>(rehydrated.IE);
Assert.IsInstanceOf<ArrayList>(rehydrated.IL);
@ -131,15 +142,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializer {
[Test]
public void TestTwoCs() {
var list = new ArrayList(new[] { new C { P = "x" }, new C { P = "y" } });
var obj = new T { AL = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue(list), S = new Stack(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "[{ '_t' : 'EnumerableSerializer.C', 'P' : 'x' }, { '_t' : 'EnumerableSerializer.C', 'P' : 'y' }]";
var expected = "{ 'AL' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var rep = "[{ '_t' : 'CollectionSerializers.C', 'P' : 'x' }, { '_t' : 'CollectionSerializers.C', 'P' : 'y' }]";
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<ArrayList>(rehydrated.AL);
Assert.IsInstanceOf<ArrayList>(rehydrated.L);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsInstanceOf<ArrayList>(rehydrated.IC);
Assert.IsInstanceOf<ArrayList>(rehydrated.IE);
Assert.IsInstanceOf<ArrayList>(rehydrated.IL);
@ -149,15 +162,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializer {
[Test]
public void TestTwoInts() {
var list = new ArrayList(new[] { 1, 2 });
var obj = new T { AL = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue(list), S = new Stack(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "[1, 2]";
var expected = "{ 'AL' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<ArrayList>(rehydrated.AL);
Assert.IsInstanceOf<ArrayList>(rehydrated.L);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsInstanceOf<ArrayList>(rehydrated.IC);
Assert.IsInstanceOf<ArrayList>(rehydrated.IE);
Assert.IsInstanceOf<ArrayList>(rehydrated.IL);
@ -167,15 +182,17 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializer {
[Test]
public void TestTwoStrings() {
var list = new ArrayList(new[] { "x", "y" });
var obj = new T { AL = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue(list), S = new Stack(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "['x', 'y']";
var expected = "{ 'AL' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<ArrayList>(rehydrated.AL);
Assert.IsInstanceOf<ArrayList>(rehydrated.L);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsInstanceOf<ArrayList>(rehydrated.IC);
Assert.IsInstanceOf<ArrayList>(rehydrated.IE);
Assert.IsInstanceOf<ArrayList>(rehydrated.IL);
@ -189,18 +206,20 @@ namespace MongoDB.BsonUnitTests.DefaultSerializer.EnumerableSerializer {
var guid = Guid.Empty;
var objectId = ObjectId.Empty;
var list = new ArrayList(new object[] { true, dateTime, 1.5, 1, 2L, guid, objectId, "x" });
var obj = new T { AL = list, IC = list, IE = list, IL = list };
var obj = new T { L = list, Q = new Queue(list), S = new Stack(list), IC = list, IE = list, IL = list };
var json = obj.ToJson();
var rep = "[true, #Date, 1.5, 1, 2, #Guid, #ObjectId, 'x']";
rep = rep.Replace("#Date", "{ '$date' : #ms }".Replace("#ms", millis.ToString()));
rep = rep.Replace("#Guid", "{ '$binary' : 'AAAAAAAAAAAAAAAAAAAAAA==', '$type' : '03' }");
rep = rep.Replace("#ObjectId", "{ '$oid' : '000000000000000000000000' }");
var expected = "{ 'AL' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
var expected = "{ 'L' : #R, 'Q' : #R, 'S' : #R, 'IC' : #R, 'IE' : #R, 'IL' : #R }".Replace("#R", rep).Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<ArrayList>(rehydrated.AL);
Assert.IsInstanceOf<ArrayList>(rehydrated.L);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsInstanceOf<ArrayList>(rehydrated.IC);
Assert.IsInstanceOf<ArrayList>(rehydrated.IE);
Assert.IsInstanceOf<ArrayList>(rehydrated.IL);

163
BsonUnitTests/DefaultSerializer/Serializers/QueueSerializerTests.cs
View File

@ -1,163 +0,0 @@
/* Copyright 2010 10gen Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
using System.Collections;
using System.Linq;
using System.Text;
using NUnit.Framework;
using MongoDB.Bson;
using MongoDB.Bson.DefaultSerializer;
using MongoDB.Bson.Serialization;
namespace MongoDB.BsonUnitTests.DefaultSerializer.QueueSerializer {
[BsonDiscriminator("QueueSerializer.C")] // "C" is an ambiguous discriminator when nominalType is System.Object
public class C {
public string P { get; set; }
}
[TestFixture]
public class QueueSerializerTests {
public class T {
public Queue Q { get; set; }
}
[Test]
public void TestNull() {
var obj = new T { Q = null };
var json = obj.ToJson();
var expected = "{ 'Q' : null }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsNull(rehydrated.Q);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestEmpty() {
var obj = new T { Q = new Queue() };
var json = obj.ToJson();
var expected = "{ 'Q' : [] }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestOneC() {
var obj = new T { Q = new Queue(new[] { new C { P = "x" } }) };
var json = obj.ToJson();
var expected = "{ 'Q' : [{ '_t' : 'QueueSerializer.C', 'P' : 'x' }] }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestOneInt() {
var obj = new T { Q = new Queue(new[] { 1 }) };
var json = obj.ToJson();
var expected = "{ 'Q' : [1] }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestOneString() {
var obj = new T { Q = new Queue(new[] { "x" }) };
var json = obj.ToJson();
var expected = "{ 'Q' : ['x'] }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestTwoCs() {
var obj = new T { Q = new Queue(new[] { new C { P = "x" }, new C { P = "y" } }) };
var json = obj.ToJson();
var expected = "{ 'Q' : [{ '_t' : 'QueueSerializer.C', 'P' : 'x' }, { '_t' : 'QueueSerializer.C', 'P' : 'y' }] }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestTwoInts() {
var obj = new T { Q = new Queue(new[] { 1, 2 }) };
var json = obj.ToJson();
var expected = "{ 'Q' : [1, 2] }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestTwoStrings() {
var obj = new T { Q = new Queue(new[] { "x", "y" }) };
var json = obj.ToJson();
var expected = "{ 'Q' : ['x', 'y'] }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestMixedPrimitiveTypes() {
var dateTime = DateTime.SpecifyKind(new DateTime(2010, 1, 1, 11, 22, 33), DateTimeKind.Utc);
var millis = (long) ((dateTime - BsonConstants.UnixEpoch).TotalMilliseconds);
var guid = Guid.Empty;
var objectId = ObjectId.Empty;
var obj = new T { Q = new Queue(new object[] { true, dateTime, 1.5, 1, 2L, guid, objectId, "x" }) };
var json = obj.ToJson();
var expected = "{ 'Q' : [true, #Date, 1.5, 1, 2, #Guid, #ObjectId, 'x'] }";
expected = expected.Replace("#Date", "{ '$date' : #ms }".Replace("#ms", millis.ToString()));
expected = expected.Replace("#Guid", "{ '$binary' : 'AAAAAAAAAAAAAAAAAAAAAA==', '$type' : '03' }");
expected = expected.Replace("#ObjectId", "{ '$oid' : '000000000000000000000000' }");
expected = expected.Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Queue>(rehydrated.Q);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
}
}

163
BsonUnitTests/DefaultSerializer/Serializers/StackSerializerTests.cs
View File

@ -1,163 +0,0 @@
/* Copyright 2010 10gen Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
using System.Collections;
using System.Linq;
using System.Text;
using NUnit.Framework;
using MongoDB.Bson;
using MongoDB.Bson.DefaultSerializer;
using MongoDB.Bson.Serialization;
namespace MongoDB.BsonUnitTests.DefaultSerializer.StackSerializer {
[BsonDiscriminator("StackSerializer.C")] // "C" is an ambiguous discriminator when nominalType is System.Object
public class C {
public string P { get; set; }
}
[TestFixture]
public class StackSerializerTests {
public class T {
public Stack S { get; set; }
}
[Test]
public void TestNull() {
var obj = new T { S = null };
var json = obj.ToJson();
var expected = "{ 'S' : null }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsNull(rehydrated.S);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestEmpty() {
var obj = new T { S = new Stack() };
var json = obj.ToJson();
var expected = "{ 'S' : [] }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestOneC() {
var obj = new T { S = new Stack(new[] { new C { P = "x" } }) };
var json = obj.ToJson();
var expected = "{ 'S' : [{ '_t' : 'StackSerializer.C', 'P' : 'x' }] }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestOneInt() {
var obj = new T { S = new Stack(new[] { 1 }) };
var json = obj.ToJson();
var expected = "{ 'S' : [1] }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestOneString() {
var obj = new T { S = new Stack(new[] { "x" }) };
var json = obj.ToJson();
var expected = "{ 'S' : ['x'] }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestTwoCs() {
var obj = new T { S = new Stack(new[] { new C { P = "x" }, new C { P = "y" } }) };
var json = obj.ToJson();
var expected = "{ 'S' : [{ '_t' : 'StackSerializer.C', 'P' : 'x' }, { '_t' : 'StackSerializer.C', 'P' : 'y' }] }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestTwoInts() {
var obj = new T { S = new Stack(new[] { 1, 2 }) };
var json = obj.ToJson();
var expected = "{ 'S' : [1, 2] }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestTwoStrings() {
var obj = new T { S = new Stack(new[] { "x", "y" }) };
var json = obj.ToJson();
var expected = "{ 'S' : ['x', 'y'] }".Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
[Test]
public void TestMixedPrimitiveTypes() {
var dateTime = DateTime.SpecifyKind(new DateTime(2010, 1, 1, 11, 22, 33), DateTimeKind.Utc);
var millis = (long) ((dateTime - BsonConstants.UnixEpoch).TotalMilliseconds);
var guid = Guid.Empty;
var objectId = ObjectId.Empty;
var obj = new T { S = new Stack(new object[] { true, dateTime, 1.5, 1, 2L, guid, objectId, "x" }) };
var json = obj.ToJson();
var expected = "{ 'S' : [true, #Date, 1.5, 1, 2, #Guid, #ObjectId, 'x'] }";
expected = expected.Replace("#Date", "{ '$date' : #ms }".Replace("#ms", millis.ToString()));
expected = expected.Replace("#Guid", "{ '$binary' : 'AAAAAAAAAAAAAAAAAAAAAA==', '$type' : '03' }");
expected = expected.Replace("#ObjectId", "{ '$oid' : '000000000000000000000000' }");
expected = expected.Replace("'", "\"");
Assert.AreEqual(expected, json);
var bson = obj.ToBson();
var rehydrated = BsonSerializer.DeserializeDocument<T>(bson);
Assert.IsInstanceOf<Stack>(rehydrated.S);
Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
}
}
}
Write Preview
Loading…
Cancel
Save