public void AttributeWithDefaultNamespaceSerializationTest() { const string result = @"<w:font w:name=""Arial"" xmlns:w=""http://example.com/namespace"" />"; var serializer = new YAXSerializer(typeof(AttributeWithNamespace), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); var got = serializer.Serialize(AttributeWithNamespace.GetSampleInstance()); Assert.That(got, Is.EqualTo(result)); }
public void AttributeNamespaceDeserializationTest() { var serializer = new YAXSerializer(typeof(AttributeNamespaceSample), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); var got = serializer.Serialize(AttributeNamespaceSample.GetSampleInstance()); var deserialized = serializer.Deserialize(got) as AttributeNamespaceSample; Assert.That(deserialized, Is.Not.Null); Assert.That(serializer.ParsingErrors, Has.Count.EqualTo(0)); }
public static string ParseAndRegenerateXml(string xml) { var project = Parse(xml); var yaxSer = new YAXSerializer(typeof(ProjectBuildDefinition), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Ignore, YAXSerializationOptions.DontSerializeNullObjects); return(yaxSer.Serialize(project)); }
public void DictionaryNamespaceForAllItemsDeserializationTest() { var serializer = new YAXSerializer(typeof(CellPhone_DictionaryNamespace), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); var got = serializer.Serialize(CellPhone_DictionaryNamespace.GetSampleInstance()); var deserialized = serializer.Deserialize(got) as CellPhone_DictionaryNamespace; Assert.That(deserialized, Is.Not.Null); Assert.That(serializer.ParsingErrors, Has.Count.EqualTo(0)); }
public void YAXAttributeAlreadyExistsExceptionTest() { var ex = Assert.Throws <YAXAttributeAlreadyExistsException>(() => { var serializer = new YAXSerializer(typeof(ClassWithDuplicateYaxAttribute), YAXExceptionHandlingPolicies.ThrowWarningsAndErrors, YAXExceptionTypes.Error); serializer.Serialize(ClassWithDuplicateYaxAttribute.GetSampleInstance()); }); Assert.AreEqual("test", ex.AttrName); StringAssert.Contains("'test'", ex.Message); }
public void MaxRecursionPreventsInfiniteLoop() { var ser = new YAXSerializer(typeof(CalculatedPropertiesCanCauseInfiniteLoop)); ser.MaxRecursion = 10; var result = ser.Serialize(CalculatedPropertiesCanCauseInfiniteLoop.GetSampleInstance()); var deserialzedInstance = ser.Deserialize(result) as CalculatedPropertiesCanCauseInfiniteLoop; Assert.IsNotNull(deserialzedInstance); Assert.AreEqual(2.0M, deserialzedInstance.Data); }
public void AttributeNamespaceSerializationTest() { const string result = "<AttributeNamespaceSample xmlns:ns=\"http://namespaces.org/ns\" xmlns=\"http://namespaces.org/default\">" + @" <Attribs " + "attrib=\"value\" ns:attrib2=\"value2\"" + @" /> </AttributeNamespaceSample>"; var serializer = new YAXSerializer(typeof(AttributeNamespaceSample), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); string got = serializer.Serialize(AttributeNamespaceSample.GetSampleInstance()); Assert.That(got, Is.EqualTo(result)); }
public void MultiLevelMemberAndClassDifferentNamespacesDeserializationTest() { var serializer = new YAXSerializer(typeof(CellPhone_MultiLevelMemberAndClassDifferentNamespaces), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); var got = serializer.Serialize(CellPhone_MultiLevelMemberAndClassDifferentNamespaces.GetSampleInstance()); var deserialized = serializer.Deserialize(got) as CellPhone_MultiLevelMemberAndClassDifferentNamespaces; Assert.That(deserialized, Is.Not.Null); Assert.That(serializer.ParsingErrors, Has.Count.EqualTo(0)); }
public static void SaveFile(ListShapes listShapes) { SaveFileDialog saveFileDialog = new SaveFileDialog(); if (saveFileDialog.ShowDialog() == true) { YAXSerializer serializer = new YAXSerializer(typeof(ListShapes)); string xmlResult = String.Empty; xmlResult = serializer.Serialize(listShapes); File.WriteAllText(saveFileDialog.FileName, xmlResult); } }
public void MemberAndClassDifferentNamespacesDeserializationTest() { const string result = @"<CellPhone_MemberAndClassDifferentNamespaces xmlns:x1=""http://namespace.org/x1"" xmlns=""http://namespace.org/nsmain""> <x1:TheName>HTC</x1:TheName> <OS>Windows Phone 8</OS> </CellPhone_MemberAndClassDifferentNamespaces>"; var serializer = new YAXSerializer(typeof(CellPhone_MemberAndClassDifferentNamespaces), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); string got = serializer.Serialize(CellPhone_MemberAndClassDifferentNamespaces.GetSampleInstance()); Assert.That(got, Is.EqualTo(result)); }
public string Yaxlib_Deserialization_With_Initialization() { var serializer = new YAXSerializer(typeof(Dummy)); foreach (var item in _testDataYaxLibXmls) { Dummy result = (Dummy)serializer.Deserialize(item); bool a = result.BoolProperty7; } return(serializer.Serialize(_testDataObjects[0])); }
private void SaveGameToolStripMenuItem_Click(object sender, EventArgs e) { YAXSerializer yax = new YAXSerializer(typeof(Game)); using (SaveFileDialog fileDialog = new SaveFileDialog()) { if (fileDialog.ShowDialog() == DialogResult.OK) { File.WriteAllText(fileDialog.FileName, yax.Serialize(this.Game)); } } }
public void MaxRecursionPreventsInfiniteLoop() { var ser = new YAXSerializer(typeof(CalculatedPropertiesCanCauseInfiniteLoop)); ser.Options.MaxRecursion = 10; var result = ser.Serialize(CalculatedPropertiesCanCauseInfiniteLoop.GetSampleInstance()); var deserializedInstance = ser.Deserialize(result) as CalculatedPropertiesCanCauseInfiniteLoop; Assert.IsNotNull(deserializedInstance); Assert.That(ser.Options.MaxRecursion, Is.EqualTo(10)); Assert.That(deserializedInstance.Data, Is.EqualTo(2.0M)); Assert.That(ser.RecursionCount, Is.EqualTo(0)); }
/// <summary> /// Convierte un objeto a xml /// </summary> /// <typeparam name="T"></typeparam> /// <param name="obj">Objeto</param> /// <returns>xml</returns> public static string ObjetToXML <T>(T obj) { try { var serializer = new YAXSerializer(typeof(T)); string xml = serializer.Serialize(obj); return(xml); } catch (Exception) { throw; } }
public void TestDoubleMax() { try { var ser = new YAXSerializer(typeof(double), YAXExceptionHandlingPolicies.ThrowErrorsOnly, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); double d = 0.55; var xml = ser.Serialize(d); var deseredInstance = ser.Deserialize(xml); Assert.AreEqual(d, deseredInstance); d = Double.MaxValue; xml = ser.Serialize(d); deseredInstance = ser.Deserialize(xml); // Causes a System.OverflowException {"Value was either too large or too small for a Double."} Assert.AreEqual(d, deseredInstance); } catch (Exception ex) { Assert.Fail("No exception should have been throwned, but received:" + Environment.NewLine + ex); } }
public void YAXObjectTypeMismatchExceptionTest() { var ex = Assert.Throws <YAXObjectTypeMismatch>(() => { var serializer = new YAXSerializer(typeof(Book), YAXExceptionHandlingPolicies.ThrowErrorsOnly); serializer.Serialize(new ClassWithDuplicateYaxAttribute()); }); Assert.AreEqual(typeof(Book), ex.ExpectedType); Assert.AreEqual(typeof(ClassWithDuplicateYaxAttribute), ex.ReceivedType); StringAssert.Contains("'Book'", ex.Message); StringAssert.Contains("'ClassWithDuplicateYaxAttribute'", ex.Message); }
public void DictionaryWithParentNamespaceSerializationTest() { const string result = @"<Warehouse_Dictionary xmlns=""http://www.mywarehouse.com/warehouse/def/v3""> <ItemInfo Item=""Item1"" Count=""10"" /> <ItemInfo Item=""Item4"" Count=""30"" /> <ItemInfo Item=""Item2"" Count=""20"" /> </Warehouse_Dictionary>"; var serializer = new YAXSerializer(typeof(Warehouse_Dictionary), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); string got = serializer.Serialize(Warehouse_Dictionary.GetSampleInstance()); Assert.That(got, Is.EqualTo(result)); }
public void YAXNamespaceOverridesImplicitNamespaceSerializationTest() { const string result = @"<CellPhone_YAXNamespaceOverridesImplicitNamespace xmlns:p1=""http://namespace.org/explicitBrand"" xmlns:p2=""http://namespace.org/os""> <p1:Brand>Samsung Galaxy S II</p1:Brand> <p2:OperatingSystem>Android 2</p2:OperatingSystem> </CellPhone_YAXNamespaceOverridesImplicitNamespace>"; var serializer = new YAXSerializer(typeof(CellPhone_YAXNamespaceOverridesImplicitNamespace), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); string got = serializer.Serialize(CellPhone_YAXNamespaceOverridesImplicitNamespace.GetSampleInstance()); Assert.That(got, Is.EqualTo(result)); }
public void SingleNamespaceSerializationTest() { const string result = @"<!-- This example shows usage of a custom default namespace --> " + "<SingleNamespaceSample xmlns=\"http://namespaces.org/default\">" + @" <StringItem>This is a test string</StringItem> <IntItem>10</IntItem> </SingleNamespaceSample>"; var serializer = new YAXSerializer(typeof(SingleNamespaceSample), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); string got = serializer.Serialize(SingleNamespaceSample.GetInstance()); Assert.That(got, Is.EqualTo(result)); }
public void MultipleNamespaceSerializationTest() { const string result = @"<!-- This example shows usage of a number of custom namespaces --> " + "<ns1:MultipleNamespaceSample xmlns:ns1=\"http://namespaces.org/ns1\" xmlns:ns2=\"http://namespaces.org/ns2\" xmlns:ns3=\"http://namespaces.org/ns3\">" + @" <ns1:BoolItem>True</ns1:BoolItem> <ns2:StringItem>This is a test string</ns2:StringItem> <ns3:IntItem>10</ns3:IntItem> </ns1:MultipleNamespaceSample>"; var serializer = new YAXSerializer(typeof(MultipleNamespaceSample), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); string got = serializer.Serialize(MultipleNamespaceSample.GetSampleInstance()); Assert.That(got, Is.EqualTo(result)); }
public void CollectionNamespaceGoesThruRecursiveNoContainingElementDeserializationTest() { var serializer = new YAXSerializer(typeof(CellPhone_CollectionNamespaceGoesThruRecursiveNoContainingElement), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); var got = serializer.Serialize(CellPhone_CollectionNamespaceGoesThruRecursiveNoContainingElement .GetSampleInstance()); var deserialized = serializer.Deserialize(got) as CellPhone_CollectionNamespaceGoesThruRecursiveNoContainingElement; Assert.That(deserialized, Is.Not.Null); Assert.That(serializer.ParsingErrors, Has.Count.EqualTo(0)); }
public void TestSingleKnownTypeSerialization() { var typeToTest = typeof(Color); var serializer = new YAXSerializer(typeToTest); var col1 = Color.FromArgb(145, 123, 123); var colStr1 = serializer.Serialize(col1); const string expectedCol1 = @"<Color> <A>255</A> <R>145</R> <G>123</G> <B>123</B> </Color>"; Assert.That(colStr1, Is.EqualTo(expectedCol1)); var col2 = SystemColors.ButtonFace; var colStr2 = serializer.Serialize(col2); const string expectedCol2 = @"<Color>ButtonFace</Color>"; Assert.That(colStr2, Is.EqualTo(expectedCol2)); }
public void DeserializeIndirectSelfReferringObjectWhenDontSerializeCyclingReferencesIsSet() { var inst = IndirectSelfReferringObject.GetSampleInstanceWithLoop(); var ser = new YAXSerializer(typeof(IndirectSelfReferringObject), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Error, YAXSerializationOptions.DontSerializeCyclingReferences); string input = ser.Serialize(inst); var deserializedInstance = (IndirectSelfReferringObject)ser.Deserialize(input); Assert.That(deserializedInstance, Is.Not.Null); Assert.IsNull(deserializedInstance.Child.Parent); }
public void DeserializeDirectSelfReferringObjectWithSelfCycleWhenThrowUponSerializingCyclingReferencesIsNotSet() { var inst = DirectSelfReferringObject.GetSampleInstanceWithSelfCycle(); var ser = new YAXSerializer(typeof(DirectSelfReferringObject), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Error); string input = ser.Serialize(inst); var deserializedInstance = (DirectSelfReferringObject)ser.Deserialize(input); Assert.That(deserializedInstance, Is.Not.Null); Assert.IsNull(deserializedInstance.Next); }
public static string Serialize <T>(T obj) where T : class { var serializer = new YAXSerializer(typeof(T)); using (var stringWriter = new StringWriter()) { using (XmlWriter writer = XmlWriter.Create(stringWriter, writerSettings)) { serializer.Serialize(obj, writer); } return(stringWriter.ToString()); } }
private void OnSerialize(bool saveToFile) { object selItem = lstSampleClasses.SelectedItem; if (selItem == null || !(selItem is ClassInfoListItem)) { return; } string fileName = null; if (saveToFile) { if (DialogResult.OK != saveFileDialog1.ShowDialog()) { return; } fileName = saveFileDialog1.FileName; } ClassInfoListItem info = selItem as ClassInfoListItem; YAXExceptionTypes defaultExType = GetSelectedDefaultExceptionType(); YAXExceptionHandlingPolicies exPolicy = GetSelectedExceptionHandlingPolicy(); YAXSerializationOptions serOption = GetSelectedSerializationOption(); try { YAXSerializer serializer = new YAXSerializer(info.ClassType, exPolicy, defaultExType, serOption); serializer.MaxRecursion = Convert.ToInt32(numMaxRecursion.Value); if (saveToFile) { serializer.SerializeToFile(info.SampleObject, fileName); } else { rtbXMLOutput.Text = serializer.Serialize(info.SampleObject); } rtbParsingErrors.Text = serializer.ParsingErrors.ToString(); } catch (YAXException ex) { MessageBox.Show("YAXException handled:\r\n\r\n" + ex.ToString()); } catch (Exception ex) { MessageBox.Show("Other Exception handled:\r\n\r\n" + ex.ToString()); } }
public void DataSetAndDataTableSerializationTest() { const string result = @"<DataSetAndDataTableKnownTypeSample> <TheDataTable> <NewDataSet> <TableName xmlns=""http://tableNs/""> <Col1>1</Col1> <Col2>2</Col2> <Col3>3</Col3> </TableName> <TableName xmlns=""http://tableNs/""> <Col1>y</Col1> <Col2>4</Col2> <Col3>n</Col3> </TableName> </NewDataSet> </TheDataTable> <TheDataSet> <MyDataSet> <Table1> <Cl1>num1</Cl1> <Cl2>34</Cl2> </Table1> <Table1> <Cl1>num2</Cl1> <Cl2>54</Cl2> </Table1> <Table2> <C1>one</C1> <C2>1</C2> <C3>1.5</C3> </Table2> <Table2> <C1>two</C1> <C2>2</C2> <C3>2.5</C3> </Table2> </MyDataSet> </TheDataSet> </DataSetAndDataTableKnownTypeSample>"; var serializer = new YAXSerializer(typeof(DataSetAndDataTableKnownTypeSample), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); var got = serializer.Serialize(DataSetAndDataTableKnownTypeSample.GetSampleInstance()); Assert.That(got, Is.EqualTo(result)); }
public void CollectionNamespaceGoesThruRecursiveNoContainingElementSerializationTest() { const string result = @"<MobilePhone xmlns:app=""http://namespace.org/apps""> <DeviceBrand>Samsung Galaxy Nexus</DeviceBrand> <OS>Android</OS> <app:String>Google Map</app:String> <app:String>Google+</app:String> <app:String>Google Play</app:String> </MobilePhone>"; var serializer = new YAXSerializer(typeof(CellPhone_CollectionNamespaceGoesThruRecursiveNoContainingElement), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); string got = serializer.Serialize(CellPhone_CollectionNamespaceGoesThruRecursiveNoContainingElement.GetSampleInstance()); Assert.That(got, Is.EqualTo(result)); }
private static void TryYax() { var obj = CreateFakeObject(); obj.SetValues(); var serializer = new YAXSerializer(typeof(Parameters), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Error, YAXSerializationOptions.DontSerializeCyclingReferences | YAXSerializationOptions.DontSerializeNullObjects | YAXSerializationOptions.DontSerializePropertiesWithNoSetter); var someString = serializer.Serialize(obj); File.WriteAllText("yax.xml", someString); var back = serializer.DeserializeFromFile("yax.xml"); }
public void TestSingleMin() { try { var ser = new YAXSerializer(typeof(float), YAXExceptionHandlingPolicies.ThrowErrorsOnly, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects); float f = Single.MinValue; var xml = ser.Serialize(f); var deseredInstance = ser.Deserialize(xml); Assert.AreEqual(f, deseredInstance); } catch (Exception ex) { Assert.Fail("No exception should have been throwned, but received:" + Environment.NewLine + ex); } }