public async void serialize_simple_object()
{
var serializer = new DefaultXmlSerializer();
var obj = new TestXmlClass {
IgnoreA = 11,
B = 10,
C = "hello",
UnsafeD = @"<html></html>",
RealA = "a"
};
using (var stream = new MemoryStream()) {
using (var writer = new StreamWriter(stream, Encoding.UTF8)) {
await serializer.SerializeAsync(obj, writer);
writer.Flush();
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new StreamReader(stream)) {
var xml = reader.ReadToEnd();
Assert.NotNull(xml);
var expected =
@"<xml>
<a><![CDATA[a]]></a>
<b>10</b>
<c><![CDATA[hello]]></c>
<d><![CDATA[<html></html>]]></d>
</xml>
";
Assert.Equal(expected, xml);
}
}
}
}
private static LunaConfig CreateConfig()
{
EnsureFilePath();
IXmlSerializer serializer = new DefaultXmlSerializer();
return(serializer.Deserialize <LunaConfig>(CONFIGPATH));
}
public void Setup()
{
_testCommand = A.Fake<ICommand>();
_publisher = A.Fake<IPublisher>();
_compositeApp = A.Fake<ICompositeApp>();
_registry = A.Fake<ICommandRegistry>();
_formatter = A.Fake<IResponseFormatter>();
_publicationRecord = A.Fake<ICommandPublicationRecord>();
_jsonSerializer = new DefaultJsonSerializer();
_xmlSerializer = new DefaultXmlSerializer();
A.CallTo(() => _testCommand.Created).Returns(DateTime.MaxValue);
A.CallTo(() => _testCommand.CreatedBy).Returns(new Guid("ba5f18dc-e287-4d9e-ae71-c6989b10d778"));
A.CallTo(() => _testCommand.Identifier).Returns(new Guid("ba5f18dc-e287-4d9e-ae71-c6989b10d778"));
A.CallTo(() => _formatter.Serializers).Returns(new List<ISerializer> { _jsonSerializer, _xmlSerializer });
A.CallTo(() => _publicationRecord.Dispatched).Returns(true);
A.CallTo(() => _publicationRecord.Error).Returns(false);
A.CallTo(() => _publicationRecord.Completed).Returns(true);
A.CallTo(() => _publicationRecord.Created).Returns(DateTime.MinValue);
A.CallTo(() => _publicationRecord.MessageLocation).Returns(new Uri("http://localhost/fake/message"));
A.CallTo(() => _publicationRecord.MessageType).Returns(typeof(IPublicationRecord));
A.CallTo(() => _publicationRecord.CreatedBy).Returns(Guid.Empty);
A.CallTo(() => _compositeApp.GetCommandForInputModel(A.Dummy<IInputModel>())).Returns(_testCommand);
A.CallTo(() => _publisher.PublishMessage(A.Fake<ICommand>())).Returns(_publicationId);
A.CallTo(() => _registry.GetPublicationRecord(_publicationId)).Returns(_publicationRecord);
_euclidApi = new ApiModule(_compositeApp, _registry, _publisher);
}
public void Save()
{
IXmlSerializer serializer = new DefaultXmlSerializer();
serializer.Serialize(this, CONFIGPATH);
Nofity();
}
public void SerializeToStringSerializesCorrectly()
{
var serializer = new DefaultXmlSerializer(writerSettings: new XmlWriterSettings());
var xml = serializer.SerializeToString(_expectedItem, typeof(TypeForXmlSerializer));
xml.Should().Be(string.Format(_expectedXmlFormat, _stringHeader));
}
public void EmptyConstructorCreatesDefaultValues()
{
var serializer = new DefaultXmlSerializer();
serializer.Name.Should().Be("default");
serializer.WriterSettings.Should().BeNull();
serializer.ReaderSettings.Should().BeNull();
serializer.Namespaces.Should().BeNull();
}
public void DeserializeFromStringDeserializesCorrectly()
{
var serializer = new DefaultXmlSerializer();
var item = serializer.DeserializeFromString(string.Format(_expectedXmlFormat, _stringHeader), typeof(TypeForXmlSerializer)) as TypeForXmlSerializer;
item.Should().NotBeNull();
item.Should().BeEquivalentTo(_expectedItem);
}
public DefaultXmlSerializerTests()
{
var environment =
new DefaultNancyEnvironment();
environment.Tracing(
enabled: true,
displayErrorTraces: true);
environment.Xml(true);
environment.Globalization(new[] { "en-US" });
this.xmlSerializer = new DefaultXmlSerializer(environment);
}
public DefaultXmlSerializerTests()
{
var environment =
new DefaultNancyEnvironment();
environment.Tracing(
enabled: true,
displayErrorTraces: true);
environment.Xml(true);
environment.Globalization(new[] { "en-US" });
this.xmlSerializer = new DefaultXmlSerializer(environment);
}
public void ConstructorPassesValuesCorrectly()
{
var name = "notdefault";
var xmlWriterSettings = new XmlWriterSettings();
var xmlReaderSettings = new XmlReaderSettings();
var nameSpaces = new[] { new XmlQualifiedName("Name1", "Namespace1"), new XmlQualifiedName("Name2", "Namespace2") };
var serializer = new DefaultXmlSerializer(name, nameSpaces, xmlWriterSettings, xmlReaderSettings);
serializer.Name.Should().Be(name);
serializer.ReaderSettings.Should().BeSameAs(xmlReaderSettings);
serializer.WriterSettings.Should().BeSameAs(xmlWriterSettings);
serializer.Namespaces.ToArray().Should().BeEquivalentTo(nameSpaces);
}
public void SerializeToStreamSerializesCorrectly()
{
var serializer = new DefaultXmlSerializer(writerSettings: new XmlWriterSettings {
Encoding = Encoding.UTF8
});
using var stream = new MemoryStream();
serializer.SerializeToStream(stream, _expectedItem, typeof(TypeForXmlSerializer));
using var streamReader = new StreamReader(stream);
stream.Seek(0, SeekOrigin.Begin);
var xml = streamReader.ReadToEnd();
xml.Should().Be(ExpectedXml);
}
/// <summary>
/// Adds a application/xml request body to the <see cref="Browser"/>.
/// </summary>
/// <param name="browserContext">The <see cref="BrowserContext"/> that the data should be added to.</param>
/// <param name="model">The model to be serialized to xml.</param>
/// <param name="serializer">Optionally opt in to using a different XML serializer.</param>
public static void XMLBody <TModel>(this BrowserContext browserContext, TModel model, ISerializer serializer = null)
{
if (serializer == null)
{
serializer = new DefaultXmlSerializer(browserContext.Environment);
}
var contextValues =
(IBrowserContextValues)browserContext;
contextValues.Body = new MemoryStream();
serializer.Serialize("application/xml", model, contextValues.Body);
browserContext.Header("Content-Type", "application/xml");
}
public void DeserializeFromStreamDeserializesCorrectly()
{
var serializer = new DefaultXmlSerializer();
TypeForXmlSerializer item;
using (var stream = new MemoryStream())
{
using (var writer = new StreamWriter(stream, new UTF8Encoding(false, true), 1024, true))
{
writer.Write(_expectedXmlFormat, _streamHeader);
}
stream.Seek(0, SeekOrigin.Begin);
item = serializer.DeserializeFromStream(stream, typeof(TypeForXmlSerializer)) as TypeForXmlSerializer;
}
item.Should().NotBeNull();
item.Should().BeEquivalentTo(_expectedItem);
}
public void DefaultXmlSerializer_Test()
{
var o1 = new TestSerializeClass()
{
Id = 1,
Name = "zhang",
Age = 19
};
IXmlSerializer xmlSerializer = new DefaultXmlSerializer();
var xml1 = xmlSerializer.Serialize(o1);
var o2 = xmlSerializer.Deserialize <TestSerializeClass>(xml1);
Assert.Equal(o1.Id, o2.Id);
Assert.Equal(o1.Name, o2.Name);
Assert.Equal(o1.Age, o2.Age);
var o3 = (TestSerializeClass)xmlSerializer.Deserialize(xml1, typeof(TestSerializeClass));
Assert.Equal(o1.Id, o3.Id);
Assert.Equal(o1.Name, o3.Name);
Assert.Equal(o1.Age, o3.Age);
}
public void ConstructorWithNullNameCreatesDefaultName()
{
var serializer = new DefaultXmlSerializer(null);
serializer.Name.Should().Be("default");
}
public ContentTypeController()
{
_xmlSerializer = new DefaultXmlSerializer();
_jsonSerializer = new DefaultJsonSerializer();
}
public FeatureController()
{
_xmlSerializer = new DefaultXmlSerializer();
_jsonSerializer = new DefaultJsonSerializer();
_requestRepo = RequestRepo.Instance;
}
private static LunaConfig CreateConfig()
{
EnsureFilePath();
IXmlSerializer serializer = new DefaultXmlSerializer();
return serializer.Deserialize<LunaConfig>(CONFIGPATH);
}
public void Save()
{
IXmlSerializer serializer = new DefaultXmlSerializer();
serializer.Serialize(this, CONFIGPATH);
Nofity();
}
public void Setup()
{
_cachedSerializers = new Mock <IDictionary <Type, XmlSerializer> >();
_serializer = new DefaultXmlSerializer(_cachedSerializers.Object);
}
