Beispiel #1
0
 /// <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);
     }
 }
Beispiel #2
0
 /// <summary>
 /// Serializes the specified DDValue into its XML representation and writes to a XML writer.
 /// The parent XML element &lt;v&gt; will be writed&lt;/v&gt;
 /// </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());
         }
     }
 }
Beispiel #3
0
 public void Resolve(DDValue v)
 {
     if (bNeedRebuild)
     {
         Rebuild();
     }
 }
Beispiel #4
0
        /// <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
            //}
        }
Beispiel #5
0
 /// <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());
             }
         }
     }
 }
Beispiel #6
0
        public static Stream SerializeItem(DDValue iSerializable, IFormatter formatter)
        {
            var s = new MemoryStream(0);

            SerializeItem(s, iSerializable, formatter);
            return(s);
        }
Beispiel #7
0
 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.");
 }
Beispiel #8
0
        /// <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
                }
            }
        }
Beispiel #9
0
 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.");
 }
Beispiel #10
0
        /// <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);
        }
Beispiel #11
0
        private void ValidateXMLDeserialization(DDValue original, MemoryStream xml)
        {
            xml.Position = 0;
            var deserialyzed = XMLDeserialyze(xml);

            UTestDrDataCommon.WriteMemmoryStreamToXmlFile(xml);
            ValidateDeserialization(original, (DDValue)deserialyzed);
        }
Beispiel #12
0
        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);
        }
Beispiel #13
0
        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();
        }
Beispiel #14
0
        /// <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);
        }
Beispiel #15
0
        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);
        }
Beispiel #16
0
        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);
        }
Beispiel #17
0
        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);
        }
Beispiel #18
0
        public void TestDDValueJsonDirectSerialization()
        {
            var           v  = new DDValue("string");
            StringBuilder sb = new StringBuilder();

            v.Serialize(sb);
            var dv = DDValueSje.Deserialize(sb.ToString());

            ValidateDeserialization(v, dv);
        }
Beispiel #19
0
        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());
        }
Beispiel #20
0
        public static SecureString ToSecureString(this DDValue v)
        {
            var sc = new SecureString();

            foreach (char c in v.GetValueAsString())
            {
                sc.AppendChar(c);
            }
            return(sc);
        }
Beispiel #21
0
 /// <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);
         }
     }
 }
Beispiel #22
0
 /// <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);
         }
     }
 }
Beispiel #23
0
        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());
        }
Beispiel #24
0
        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());
        }
Beispiel #25
0
        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.");
        }
Beispiel #26
0
        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());
        }
Beispiel #27
0
        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]);
            }
        }
Beispiel #28
0
        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.");
        }
Beispiel #29
0
        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);
        }
Beispiel #30
0
 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);
     }
 }
Beispiel #31
0
        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());
            }
        }
Beispiel #32
0
        /// <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.");
 }
Beispiel #34
0
 /// <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);
 }