/// <summary> /// Serializes the specified DDValue and writes the Json document to a text writer /// </summary> /// <param name="v">the value to serialize</param> /// <param name="tw">text writer used to write the Json document.</param> public static void Serialize(this DDValue v, TextWriter tw) { using (JsonWriter writer = new JsonTextWriter(tw)) { v.Serialize(writer); } }
/// <summary> /// Serializes the specified DDValue into its XML representation and writes to a XML writer. /// The parent XML element <v> will be writed</v> /// </summary> /// <param name="v">the value to serialize</param> /// <param name="writer">XML writer used to write the XML document.</param> internal static void XMLSerialize(DDValue v, XmlWriter writer) { if (v == null) { writer.WriteAttributeString(DDSchema.XML_SERIALIZE_ATTRIBUTE_TYPE, DDSchema.XML_SERIALIZE_VALUE_NULL); } else if (v.Type == null) { writer.WriteAttributeString(DDSchema.XML_SERIALIZE_ATTRIBUTE_TYPE, DDSchema.XML_SERIALIZE_VALUE_TYPE_NULL); } else { // doesn't write System.String value type, it's default type //if (v.Type != typeof(System.String)) writer.WriteAttributeString(DDSchema.XML_SERIALIZE_ATTRIBUTE_TYPE, v.Type.ToString()); if (v.Type != typeof(System.String)) { writer.WriteAttributeString(DDSchema.XML_SERIALIZE_ATTRIBUTE_TYPE, GetNumericType(v.Type).ToString()); } if (IsThisTypeXMLSerializeAsArray(v.Type)) { foreach (var element in v.ToStringArray()) { writer.WriteStartElement(DDSchema.XML_SERIALIZE_NODE_ARRAY_VALUE_ITEM); writer.WriteString(element); writer.WriteEndElement(); } } else { writer.WriteString(v.ToString()); } } }
public void Resolve(DDValue v) { if (bNeedRebuild) { Rebuild(); } }
/// <summary> /// Generates an attribute from its XML representation. /// </summary> /// <param name="reader"></param> private static void AddDeserializedAttribute(DDAttributesCollection ac, XmlReader reader) { var name = reader.GetAttribute(DDSchema.XML_SERIALIZE_ATTRIBUTE_NAME); var t = reader.GetAttribute(DDSchema.XML_SERIALIZE_ATTRIBUTE_TYPE); //if (name != null) //{ DDValue v = null; //if (t != null) v = DDValueSxe.Deserialize(reader); v = DDValueSxe.Deserialize(reader); if (name != null) { ac.Add(name, v); } else { ac.Add(v); } //} //else //{ // if (reader.NodeType == XmlNodeType.Element) reader.ReadStartElement(); // if (reader.NodeType == XmlNodeType.EndElement) reader.ReadEndElement(); // need to close the opened element //} }
/// <summary> /// Serializes the specified DDValue and writes the Json document to a Json writer /// </summary> /// <param name="v">the value to serialize</param> /// <param name="writer">Json writer used to write the Json document.</param> internal static void JsonSerialize(DDValue v, JsonWriter writer) { writer.Formatting = Newtonsoft.Json.Formatting.Indented; writer.WritePropertyName(DDSchema.JSON_SERIALIZE_ATTRIBUTE_TYPE); if (v.Type == null) { writer.WriteNull(); } else { writer.WriteValue(v.Type.ToString()); writer.WritePropertyName(DDSchema.JSON_SERIALIZE_NODE_VALUE); var a = IsThisTypeJsonSerializeAsArray(v.Type); if (a) { writer.WriteStartArray(); foreach (var i in (Array)v.GetValue()) { writer.WriteValue(i); } writer.WriteEndArray(); } else { if (v.Type == typeof(byte[])) { writer.WriteValue(v.GetValueAsHEX()); } else { writer.WriteValue(v.GetValue()); } } } }
public static Stream SerializeItem(DDValue iSerializable, IFormatter formatter) { var s = new MemoryStream(0); SerializeItem(s, iSerializable, formatter); return(s); }
private void ValidateDeserialization(DDValue original, DDValue deserialyzed) { Assert.IsTrue(original == deserialyzed, "Deserialized object must be mathematically equal to the original object."); Assert.AreNotEqual(original, deserialyzed, "Deserialized object should not be same as original object."); deserialyzed = true; // change type no true Assert.IsFalse(original == deserialyzed, "Changed deserialized object should not be equal to the original object."); }
/// <summary> /// Generates an attribute from its XML representation. /// </summary> /// <param name="reader"></param> private static void AddDeserializedAttribute(DDAttributesCollection ac, XmlReader reader) { var name = reader.GetAttribute(DDSchema.XML_SERIALIZE_ATTRIBUTE_NAME); var t = reader.GetAttribute(DDSchema.XML_SERIALIZE_ATTRIBUTE_TYPE); if (name != null) { DDValue v = null; if (t != null) { v = DDValueSxe.Deserialize(reader); } ac.Add(name, v); } if ((name == null) || (t == null)) // reads and close empty node { if (reader.NodeType == XmlNodeType.Element) { reader.ReadStartElement(); } if (reader.NodeType == XmlNodeType.EndElement) { reader.ReadEndElement(); // need to close the opened element } } }
public static void CompareAttribute(DDValue v1, DDValue v2) { if ((v1 == null) && (v2 == null)) return; Assert.IsTrue(v1.Size == v2.Size, "The size of value must be the same in both values."); Assert.IsTrue(v1.Type == v2.Type, "The type of value must be the same in both values."); Assert.IsTrue(v1 == v2, "The value must be the same in both values."); }
/// <summary> /// Save value in the attribute Value based on the parameters passed, and / or using default values /// </summary> public void ApplyDefaultValue() { var value = new DDValue(); if (GetResultIsOptionSpecified()) { if (GetAttributeValue(DrCmdOptionSettings.ResultIsOptionSpecifiedValue, false)) { value = GetAttributeValue(DrCmdOptionSettings.ResultValue, string.Empty); // if option value is specified } else { value = GetAttributeValue(DrCmdOptionSettings.DefaultValueIfSpecifiedWithoutValue, string.Empty); // if option is specified without value } } else { value = GetAttributeValue(DrCmdOptionSettings.DefaultValueIfNoneSpecified, string.Empty); // if option is not specified } if (Option.Attributes.Contains(DrCmdOptionSettings.ValueType)) // if ValueType is specified value will be converted to specified Type { if ((value.Type == typeof(System.String)) || (value.Type == typeof(System.String[]))) { value.ConvertFromStringTo(Option.Attributes[DrCmdOptionSettings.ValueType].GetValueAsString()); } } Option.Attributes.Add(DrCmdOptionSettings.Value, value); }
private void ValidateXMLDeserialization(DDValue original, MemoryStream xml) { xml.Position = 0; var deserialyzed = XMLDeserialyze(xml); UTestDrDataCommon.WriteMemmoryStreamToXmlFile(xml); ValidateDeserialization(original, (DDValue)deserialyzed); }
private void ValidateDeserialization(DDValue original, IFormatter iFormatter, Stream stream) { stream.Position = 0; UTestDrDataCommon.WriteMemmoryStreamToBinFile((MemoryStream)stream); var deserialyzed = (DDValue)DeserializeItem(stream, iFormatter); ValidateDeserialization(original, deserialyzed); }
static void Main(string[] args) { try { var s = new string[] {"a\0bc", "def"}; var b2 = Encoding.UTF8.GetBytes(s[0] + "\0\0" + s[1]); var attr = new DDValue(); attr.SetValue("ddddd+ыыыы"); } catch (Exception e) { } var a = new DDNode("A"); var b = a.Add("B"); var c = b.Add("C"); var z = b.Add(@".\."); c.Add(); c.Add(); c.Add(); c.Add(); c.Add(); c.Add(); c.Attributes.Add(new DDValue("value")); c.Attributes.Add(new DDValue("value")); c.Attributes.Add(new DDValue("value")); foreach (var node in c) { Debug.Print(node.Value.Name); } var d = a.Clone(true); //var ff = d.Attributes["fff"]; // c.Add(b); d.Attributes.Add("ff", 123); var f = d.Attributes["ff"]; var t = d.Attributes.GetValue("ff", 56); var r = d.Attributes.GetValue("fff", 56); d.Attributes.Add("Value"); var ddNode = new DDNode("test"); var ddNodeVars = ddNode.Add("Vars"); var ddNodeActions = ddNode.Add("Actions"); ddNodeVars.Attributes.Add("LogonName", "UserName"); ddNodeVars.Attributes.Add("ExpectedResult", "false"); ddNodeVars.Attributes.Add("ExpectedResult", "true", ResolveConflict.OVERWRITE); ddNodeVars.Attributes.GetValue("ExpectedResult", false).GetValueAsBool(); ddNode.GetNode("/Vars").Attributes.GetValue("ExpectedResult", true).GetValueAsBool(); }
/// <summary> /// Generates an object from its XML representation. /// </summary> /// <param name="reader">XML reader</param> /// <returns>an new DDValue </returns> public static DDValue Deserialize(XmlReader reader) { DDValue v = null; reader.MoveToContent(); var t = reader.GetAttribute(DDSchema.XML_SERIALIZE_ATTRIBUTE_TYPE); if (t == null) // if attribute type doesn't set default type - string { t = DEFAULT_VALUE_TYPE.ToString(); } if (t == String.Empty) // here is type attribute equals string.empty like t="", the value is null here { if (reader.NodeType == XmlNodeType.Element) { reader.ReadStartElement(); } } else if (t == DDSchema.XML_SERIALIZE_VALUE_TYPE_NULL) // here is type is null like t="null", the value is new DDValue here { v = new DDValue(); // data and type are null here, but class has been initialezed yet if (reader.NodeType == XmlNodeType.Element) { reader.ReadStartElement(); } } else { //var type = Type.GetType(t); var type = GetTypeByXMLType(t); if (type == null) { throw new DDTypeIncorrectException(t); } if (IsThisTypeXMLSerializeAsArray(type)) { var value = ReadXmlValueArray(reader); if (value == null) { value = new string[] { } } ; // support empty array v = new DDValue(DDValue.ConvertFromStringArrayTo(type, value)); } else { v = new DDValue(DDValue.ConvertFromStringTo(type, GetXmlElementValue(reader))); } } if ((reader.NodeType == XmlNodeType.EndElement) && (reader.Name == DDSchema.XML_SERIALIZE_NODE_VALUE)) { reader.ReadEndElement(); // Need to close the opened element </n>, only self } return(v); }
private void testAddAttributeAndValue(string name, DDValue value) { var attrs = new DDAttributesCollection(); attrs.Add(name, value); Assert.IsTrue(attrs.Count == 1, "Collection items count is incorrect."); Assert.IsTrue(attrs.Contains(name), "Attribute '{0}' was not found by name.", name); Assert.IsTrue(attrs.ContainsValue(value), "Attribute '{0}' was not found by value.", value); }
private MemoryStream XMLSerialyze(DDValue value) { var v = (DDValueSx)value; var ms = new MemoryStream(); var s = new XmlSerializer(v.GetType()); s.Serialize(ms, v); return(ms); }
public void TestDDValueArrayXmlDirectSerialization() { var v = new DDValue(new [] { 1, 0, -1 }); StringBuilder sb = new StringBuilder(); v.Serialize(sb); var dv = DDValueSxe.Deserialize(sb.ToString()); ValidateDeserialization(v, dv); }
public void TestDDValueJsonDirectSerialization() { var v = new DDValue("string"); StringBuilder sb = new StringBuilder(); v.Serialize(sb); var dv = DDValueSje.Deserialize(sb.ToString()); ValidateDeserialization(v, dv); }
public void TestConvertSByte() { var src = byte.MinValue; var v = new DDValue(src); var res = Convert.ToSByte((object)v); var trg = (sbyte)(v.GetValueAsByte() - 128); Assert.AreEqual(res, trg, "The converted result '{0}' doesn't much expected '{1}'.", res.ToString(), trg.ToString()); }
public static SecureString ToSecureString(this DDValue v) { var sc = new SecureString(); foreach (char c in v.GetValueAsString()) { sc.AppendChar(c); } return(sc); }
/// <summary> /// Serializes the specified DDValue and writes the Json document to a stream /// </summary> /// <param name="v">the value to serialize</param> /// <param name="s">stream used to write the Json document.</param> public static void Serialize(this DDValue v, Stream s) { using (StreamWriter sw = new StreamWriter(s)) { using (JsonWriter writer = new JsonTextWriter(sw)) { v.Serialize(writer); } } }
/// <summary> /// Serializes the specified DDValue and writes the Json document to a string builder /// </summary> /// <param name="v">the value to serialize</param> /// <param name="sb">string builder used to write the Json document.</param> public static void Serialize(this DDValue v, StringBuilder sb) { using (StringWriter sw = new StringWriter(sb)) { using (JsonWriter writer = new JsonTextWriter(sw)) { v.Serialize(writer); } } }
public void TestConvertBoolean() { var src = true; var v = new DDValue(src); var res = Convert.ToBoolean((object)v); var trg = v.GetValueAsBool(); Assert.AreEqual(res, trg, "The converted result '{0}' doesn't much expected '{1}'.", res.ToString(), trg.ToString()); Assert.AreEqual(res, src, "The converted result '{0}' doesn't much source '{1}'.", res.ToString(), src.ToString()); }
public void TestConvertULong() { var src = ulong.MaxValue; var v = new DDValue(src); var res = Convert.ToUInt64((object)v); var trg = v.GetValueAsULong(); Assert.AreEqual(res, trg, "The converted result '{0}' doesn't much expected '{1}'.", res.ToString(), trg.ToString()); Assert.AreEqual(res, src, "The converted result '{0}' doesn't much source '{1}'.", res.ToString(), src.ToString()); }
public void TestMergeStockCollectionConflictResolutionSkip() { var a1 = GetStockAttributesCollection(); var a2 = new DDAttributesCollection(); var newValue = new DDValue(1); a2.Add(TEST_ENUM.TEST_ENUM_a, newValue); a1.Merge(a2, ResolveConflict.SKIP); Assert.IsTrue(a1 == GetStockAttributesCollection(), "The both attribute collection must be equals."); Assert.IsFalse(a1.GetValue(TEST_ENUM.TEST_ENUM_a, null) == newValue, "The attribute must have previous value."); }
public void TestConvertDateTime() { var src = DateTime.Now; var v = new DDValue(src); var res = Convert.ToDateTime((object)v); var trg = v.GetValueAsDateTime(); Assert.AreEqual(res, trg, "The converted result '{0}' doesn't much expected '{1}'.", res.ToString(), trg.ToString()); Assert.AreEqual(res, src, "The converted result '{0}' doesn't much source '{1}'.", res.ToString(), src.ToString()); }
private void CheckArrayCast2Array <S, T>(S[] src, T[] trg) { var v = new DDValue(src); var res = v.GetValueAsArray <T>(); Assert.IsTrue(res.Length == trg.Length, "There are '{0}' elements in the array. Expected '{1}'.", res.Length, trg.Length); for (var i = 0; i < trg.Length; i++) { Assert.AreEqual <T>(res[i], trg[i], "The element value of result array '{0}' doesn't equal expected value '{1}'.", res[i], trg[i]); } }
public void TestMergeStockCollectionConflictResolutionOverwrite() { var a1 = GetStockAttributesCollection(); var a2 = new DDAttributesCollection(); var newValue = new DDValue(1); a2.Add(TEST_ENUM.TEST_ENUM_a, newValue); a1.Merge(a2, ResolveConflict.OVERWRITE); Assert.IsFalse(a1 == GetStockAttributesCollection(), "The both attribute collection cannot be equals."); Assert.IsTrue(a1.GetValue(TEST_ENUM.TEST_ENUM_a, null) == newValue, "The attribute must have new value."); }
public void TestCastingDateTime2Long2DateTime() { var now = DateTime.Now; var nowUtc = DateTime.UtcNow; var a = new DDValue(); var src = new DateTime[] { DateTime.MinValue, now, nowUtc, DateTime.MaxValue }; var trg = new long[] { DateTime.MinValue.ToBinary(), now.ToBinary(), nowUtc.ToBinary(), DateTime.MaxValue.ToBinary() }; CheckItemCast2Array <DateTime, long>(src, trg); CheckItemCast2Array <long, DateTime>(trg, src); }
private void CheckItemCast2Array <S, T>(S[] src, T[] trg) { for (var i = 0; i < src.Length; i++) { var v = new DDValue(src[i]); var res = v.GetValueAsArray <T>(); Assert.IsTrue(res.Length == 1, "There are '{0}' elements in the array. Expected {1}.", res.Length, 1); Assert.AreEqual(res[0].ToString(), trg[i].ToString(), "The element of string array '{0}' doesn't much 'DDValue.ToString()' result '{1}'. The first element must be equal 'DDValue.ToString()' result.", res[0].ToString(), trg[i].ToString()); Assert.AreEqual(res[0], trg[i], "The element value of result '{0}' doesn't equal '{1}'. The value of the first element must be equal '{1}'.", res[0], trg[i]); var cast = (T)(new DDValue(src[i]).GetValueAs <T>()); Assert.AreEqual(cast, trg[i], "Value '{0} is not equal to '{1}' after casting from '{2}' to '{3}'.", cast.ToString(), trg[i].ToString(), typeof(S).Name, typeof(T).Name); } }
public void TestMergeStockCollectionConflictResolutionThrow() { var a1 = GetStockAttributesCollection(); var a2 = new DDAttributesCollection(); var newValue = new DDValue(1); a2.Add(TEST_ENUM.TEST_ENUM_a, newValue); try { a1.Merge(a2, ResolveConflict.THROW_EXCEPTION); Assert.Fail("Cannot catch exception!"); } catch (DDAttributeExistsException e) { Assert.AreEqual(e.Name, TEST_ENUM.TEST_ENUM_a.ToString()); } }
/// <summary> /// Checking this option specified arguments. /// If arguments are incongruous the <exception cref="ArgumentException">ArgumentException</exception> will be thrown. /// </summary> public void ValidateOptionParameter() { // start validate value Type if (Option.Attributes.Contains(DrCmdOptionSettings.ValueType)) // validate specified Type for convert { var valueType = System.Type.GetType(Option.Attributes[DrCmdOptionSettings.ValueType].GetValueAsString()); if (!DDValue.ValidateType(valueType)) { throw new ArgumentException(string.Format(Msg.SPECIFIED_VALUE_TYPE_IS_NOT_SUPPORTED_BY_DDVALUE, valueType.ToString())); } } // end validate value Type var isSpecifiedOption = GetAttributeValue(DrCmdOptionSettings.ResultIsOptionSpecified, false); if ((Type.HasFlag(DrCmdOptionType.Required)) & (isSpecifiedOption == false)) { throw new ArgumentException(string.Format(Msg.REQUIRED_OPTION_IS_NOT_SPECIFIED, Name, CommandName)); } // value flag var valueAsStringArray = GetAttributeValue(DrCmdOptionSettings.ResultValueAsStringArray, new string[] { }).GetValueAsStringArray(); var valueAsString = GetAttributeValue(DrCmdOptionSettings.ResultValueAsStringArray, string.Empty).GetValueAsString(); // Single if ((ValueFlags.HasFlag(DrCmdValueFlags.Single)) & (valueAsStringArray.Length > 1)) { throw new ArgumentException(string.Format(Msg.OPTION_CANNOT_CONTAINS_MORE_THAN_ONE_VALUE, Name, valueAsString, valueAsStringArray.Length, DrCmdValueFlags.Single, CommandName)); } // Forbidden if ((ValueFlags.HasFlag(DrCmdValueFlags.Forbidden)) & (valueAsStringArray.Length > 0)) { throw new ArgumentException(string.Format(Msg.OPTION_CANNOT_CONTAIN_VALUE, Name, valueAsString, DrCmdValueFlags.Forbidden, CommandName)); } // Required if ((isSpecifiedOption) && (ValueFlags.HasFlag(DrCmdValueFlags.Required)) & (valueAsStringArray.Length == 0)) { throw new ArgumentException(string.Format(Msg.OPTION_MUST_CONTAIN_VALUE, Name, DrCmdValueFlags.Required, CommandName)); } if ((ValueFlags.HasFlag(DrCmdValueFlags.ListOfRestriction)) && (valueAsStringArray.Length > 0)) { ValidateOptionValueByRestrictionList(valueAsStringArray); // RestrictionList and AllowNumeric } }
private void ValidateAttribute(KeyValuePair<string, DDValue> attr, string expectedKey, DDValue expectedValue) { Assert.IsTrue(attr.Key == expectedKey, "The key is incorrect."); Assert.IsTrue(attr.Value == expectedValue, "The value is incorrect."); }
/// <summary> /// Save value in the attribute Value based on the parameters passed, and / or using default values /// </summary> public void ApplyDefaultValue() { var value = new DDValue(); if (GetResultIsOptionSpecified()) { if (GetAttributeValue(DrCmdOptionSettings.ResultIsOptionSpecifiedValue, false)) { value = GetAttributeValue(DrCmdOptionSettings.ResultValue, string.Empty); // if option value is specified } else { value = GetAttributeValue(DrCmdOptionSettings.DefaultValueIfSpecifiedWithoutValue, string.Empty); // if option is specified without value } } else { value = GetAttributeValue(DrCmdOptionSettings.DefaultValueIfNoneSpecified, string.Empty); // if option is not specified } Option.Attributes.Add(DrCmdOptionSettings.Value, value); }
private void ValidateAttribute(KeyValuePair<string, DDValue> attr, Enum expectedKey, DDValue expectedValue) { ValidateAttribute(attr, expectedKey.ToString(), expectedValue); }