public override void Execute(XElement el){
			string code = el.Attr("code");
			Type type = Type.GetType(code, false);
			if (null == type){
				_project.Log.Error("Не могу найти расширение - генератор с именем " + code);
				return;
			}
			var gen = Activator.CreateInstance(type) as ISourceCodeGenerator;
			if (null == gen){
				_project.Log.Error("Указанный класс " + code + " не соответствует интерфейсу ISourceCodeGenerator");
				return;
			}
			IEnumerable<XNode> replaces = null;
			try{
				replaces = gen.Execute(_project, el, null).ToArray();
			}
			catch (Exception ex){
				_project.Log.Error("Ошибка при вызове " + gen.GetType().Name + " на " + el, ex);
				return;
			}
			if (!replaces.Any()){
				el.Remove();
			}
			else{
				el.ReplaceWith(replaces.OfType<object>().ToArray());
			}
		}
 /// <summary>Removes the specified <see cref="XElement"/> from this node as an extension element.</summary>
 /// <param name="extElement">The <see cref="XElement"/> to remove.</param>
 /// <exception cref="ArgumentNullException"><paramref name="extElement"/> is null.</exception>
 /// <exception cref="ArgumentException"><paramref name="extElement"/> belongs to the Atom namespace.</exception>
 public void Remove(XElement extElement)
 {
   if(extElement == null) throw new ArgumentNullException("extElement");
   if(extElement.Name.Namespace == AtomNamespace) throw new ArgumentException(Errors.ElementAtomNamespace, "extElement");
   if(extElement.Parent == this.Element)
     extElement.Remove();
 }
 public EDIXmlNode(XElement el)
     : base(el)
 {
     if (el.Parent == null) return;
     //el.Parent.Add(this);
     el.Remove();
 }
		bool RewriteElement(XamlContext ctx, XElement parent, XElement elem) {
			var type = parent.Annotation<XamlType>();
			var property = elem.Annotation<XamlProperty>();
			if ((property == null || type == null) && elem.Name != key)
				return false;

			if (elem.Elements().Count() != 1 || elem.Attributes().Any(t => t.Name.Namespace != XNamespace.Xmlns))
				return false;

			var value = elem.Elements().Single();

			if (!CanInlineExt(ctx, value))
				return false;

			var ext = InlineExtension(ctx, value);
			if (ext == null)
				return false;

			ctx.CancellationToken.ThrowIfCancellationRequested();

			var extValue = ext.ToString(ctx, parent);

			var attrName = elem.Name;
			if (attrName != key)
				attrName = property.ToXName(ctx, parent, property.IsAttachedTo(type));
			var attr = new XAttribute(attrName, extValue);
			parent.Add(attr);
			elem.Remove();

			return true;
		}
		public override void Execute(XElement el){
			if (string.IsNullOrWhiteSpace(Name)){
				el.Remove();
				return;
			}
			XElement[] toremove = (Level == "all" ? el.Descendants(Name) : el.Elements(Name)).ToArray();
			toremove.Remove();
		}
 /// <summary>Removes the specified <see cref="XElement"/> from this node as an extension element.</summary>
 /// <param name="extElement">The <see cref="XElement"/> to remove.</param>
 /// <exception cref="ArgumentNullException"><paramref name="extElement"/> is null.</exception>
 /// <exception cref="ArgumentException"><paramref name="extElement"/> belongs to the Atom namespace.</exception>
 public void Remove(XElement extElement)
 {
   if(extElement == null) throw new ArgumentNullException("extElement");
   if(extElement.Name.Namespace == AtomPubNamespace) throw new ArgumentException(Errors.ElementAtomPubNamespace, "extElement");
   if(this.CanRemoveExtElement(extElement) == false) throw new ArgumentException(Errors.CannotRemoveExtElement, "extElement");
   if(extElement.Parent == this.Element)
     extElement.Remove();
 }
 private static bool RemoveElement(XElement el)
 {
     if (el == null)
     {
         return false;
     }
     el.Remove();
     return true;
 }
		/// <summary>
		/// 	Resolves the condition.
		/// </summary>
		/// <param name="e"> The e. </param>
		/// <param name="id"> The id. </param>
		/// <remarks>
		/// </remarks>
		private void ResolveCondition(XElement e, string id) {
			if (!Match(id)) {
				e.Remove();
				return;
			}
			foreach (var a in e.Attributes()) {
				SetParentAttribute(e, a);
			}
			e.ReplaceWith(e.Elements());
		}
		public override void InsertPredicate(
				XElement target, long id, ElementType type) {
			var oldcode = Python3XmlToCode.Instance.Generate(target);
			var code = "CoverageWriter.WritePredicate(" + id + "," + (int)type + ","
					+ oldcode + ")";
			var node = Python3CodeToXml.Instance.Generate(code)
					.Descendants(target.Name)
					.First();
			target.AddBeforeSelf(node);
			target.Remove();
		}
	    private void Execute(ClassFilter filter, XElement e, string rootns) {
		    if (e.Name.LocalName == BSharpSyntax.Namespace) {
			    var ns = e.Attr("code");
				if (!string.IsNullOrWhiteSpace(rootns)) {
					ns = rootns + "." + ns;
				}
				if (!filter.IsAvailableNamespace(ns)) {
					e.Remove();
				}
				foreach (var c in e.Elements().ToArray())
				{
					Execute(filter, c,ns);
				}
		    }
		    else {
			    var clsname = e.Attr("code");
				if (!filter.IsAvailableClassname(clsname)) {
					e.Remove();
				}
		    }
	    }
Exemple #11
0
        private void CreateControlFlowFromComment( XElement comment )
        {
            var row = comment.XPathSelectElement( "./ancestor::table:table-row", Manager );
            var commentValue = comment.Value.Replace( "U+10FFFD", "@" );

            var beforeNode = new XText( commentValue + "{" );

            var afterNode = new XText( "}" );

            row.AddBeforeSelf( beforeNode );
            row.AddAfterSelf( afterNode );
            comment.Remove();
        }
        private void ReplaceValues(XElement dynamicRow)
        {
            var readers = DataReader.GetReaders(TableTag.ItemsSource).ToList();
            for (var index = 0; index < readers.Count(); index++)
            {
                var currentRow = new XElement(dynamicRow);
                var tableElements = TableTag.MakeTableElementCallback(currentRow);

                this.ProcessElements(tableElements, readers[index], index+1, null, true);

                dynamicRow.AddBeforeSelf(currentRow);
            }
            dynamicRow.Remove();
        }
 public override void InsertPredicate(XElement target, long id, ElementType type) {
     var node = new XElement("call", new object[] {
             new XElement("nil"),
             new XElement("Symbol", "branch"),
             new XElement("lit", new[] {
                     new XElement("Fixnum", id),
             }),
             new XElement("lit", new[] {
                     new XElement("Fixnum", (int)type),
             }),
             target,
     });
     target.AddBeforeSelf(node);
     target.Remove();
 }
Exemple #14
0
        private void CreateControlFlowSection( XElement script )
        {
            //TODO: Test this method

            var parentSection = script.XPathSelectElement( "./ancestor::text:section", Manager );
            // TODO: If ParentSection is null, throw specific exception

            var scriptValue = script.Value.Replace( "U+10FFFD", "@" );

            var beforeNode = new XText( scriptValue + "{" );

            var afterNode = new XText( "}" );

            parentSection.AddBeforeSelf( beforeNode );

            parentSection.AddAfterSelf( afterNode );

            script.Remove();
        }
		bool RewriteElement(XamlContext ctx, XElement parent, XElement elem) {
			var property = elem.Annotation<XamlProperty>();
			if (property == null && elem.Name != key)
				return false;

			if (elem.HasAttributes || elem.HasElements)
				return false;

			ctx.CancellationToken.ThrowIfCancellationRequested();

			var value = elem.Value;
			var attrName = elem.Name;
			if (attrName != key)
				attrName = property.ToXName(ctx, parent, property.IsAttachedTo(parent.Annotation<XamlType>()));
			var attr = new XAttribute(attrName, value);
			parent.Add(attr);
			elem.Remove();

			return true;
		}
 public void removeMod(XElement modElement)
 {
     if (modElement != null)
     {
         modElement.Remove();
     }
 }
Exemple #17
0
                //[Variation(Priority = 1, Desc = "XElement - Change xnode's parent in the pre-event handler")]
                public void ParentedXNode()
                {
                    bool firstTime = true;
                    XElement element = XElement.Parse("<root></root>");
                    XElement child = new XElement("Add", "Me");
                    element.Add(child);
                    element.Changing += new EventHandler<XObjectChangeEventArgs>(
                        delegate (object sender, XObjectChangeEventArgs e)
                        {
                            if (firstTime)
                            {
                                firstTime = false;
                                child.Remove();
                            }
                        });

                    try
                    {
                        child.Remove();
                    }
                    catch (InvalidOperationException)
                    {
                        element.Verify();
                        return;
                    }

                    throw new TestFailedException("Should have thrown an InvalidOperationException");
                }
		public void OwningSequencePropertyHasCorrectResponses()
		{
			var element = new XElement("CmPossibility", new XAttribute(SharedConstants.GuidStr, "c1ee310c-e382-11de-8a39-0800200c9a66"));
			AddBasicPropertyElementsToPoss(element);
			var prop = new XElement("SubPossibilities");
			element.Add(prop);

			var extraAttr = new XAttribute("bogus", "badvalue");
			prop.Add(extraAttr);
			var result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has unrecognized attribute(s)"));
			extraAttr.Remove();

			// No children is fine.
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNull(result);

			var extraChild = new XElement("BogusChild");
			prop.Add(extraChild);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Contains unrecognized child elements"));
			extraChild.Remove();
		}
		public void OwningAtomicPropertyHasCorrectResponses()
		{
			var element = new XElement("CmPossibility", new XAttribute(SharedConstants.GuidStr, "c1ee3109-e382-11de-8a39-0800200c9a66"));
			AddBasicPropertyElementsToPoss(element);
			var prop = new XElement("Discussion");
			element.Add(prop);

			var extraAttr = new XAttribute("bogus", "badvalue");
			prop.Add(extraAttr);
			var result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has unrecognized attribute(s)"));
			extraAttr.Remove();

			var stText1 = new XElement("StText", new XAttribute(SharedConstants.GuidStr, "c1ee310a-e382-11de-8a39-0800200c9a66"), new XElement("DateModified", new XAttribute(SharedConstants.Val, "2013-1-1 19:39:28.829")), new XElement("RightToLeft", new XAttribute(SharedConstants.Val, "True")));
			prop.Add(stText1);
			var stText2 = new XElement("StText", new XAttribute(SharedConstants.GuidStr, "c1ee310b-e382-11de-8a39-0800200c9a66"), new XElement("DateModified", new XAttribute(SharedConstants.Val, "2013-1-1 19:39:28.829")), new XElement("RightToLeft", new XAttribute(SharedConstants.Val, "True")));
			prop.Add(stText2);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has too many child elements"));
			stText2.Remove();

			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNull(result);

			stText1.Attribute(SharedConstants.GuidStr).Remove();
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("No guid attribute"));
		}
		public void ReferenceCollectionPropertyHasCorrectResponses()
		{
			var element = new XElement("CmPossibility", new XAttribute(SharedConstants.GuidStr, "c1ee3106-e382-11de-8a39-0800200c9a66"));
			AddBasicPropertyElementsToPoss(element);
			var prop = new XElement("Restrictions");
			element.Add(prop);

			var extraAttr = new XAttribute("bogus", "badvalue");
			prop.Add(extraAttr);
			var result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has unrecognized attribute(s)"));
			extraAttr.Remove();

			var extraChild = new XElement("BogusChild");
			prop.Add(extraChild);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Contains child elements that are not 'refcol'"));
			extraChild.Remove();

			var refcol1 = new XElement(SharedConstants.Refcol, new XAttribute(SharedConstants.GuidStr, "c1ee3107-e382-11de-8a39-0800200c9a66"),
									   new XAttribute("t", "r"));
			var refcol2 = new XElement(SharedConstants.Refcol, new XAttribute(SharedConstants.GuidStr, "c1ee3108-e382-11de-8a39-0800200c9a66"),
									   new XAttribute("t", "r"));
			prop.Add(refcol1);
			prop.Add(refcol2);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNull(result);
		}
		public void ReferenceSequencePropertyHasCorrectResponses()
		{
			var element = new XElement("Segment", new XAttribute(SharedConstants.GuidStr, "c1ee3103-e382-11de-8a39-0800200c9a66"), new XElement("BeginOffset", new XAttribute(SharedConstants.Val, 1)));
			var prop = new XElement("Analyses");
			element.Add(prop);

			var extraAttr = new XAttribute("bogus", "badvalue");
			prop.Add(extraAttr);
			var result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has unrecognized attribute(s)"));
			extraAttr.Remove();

			var extraChild = new XElement("BogusChild");
			prop.Add(extraChild);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Contains child elements that are not 'refseq'"));
			extraChild.Remove();

			var refseq1 = new XElement(SharedConstants.Refseq, new XAttribute(SharedConstants.GuidStr, "c1ee3104-e382-11de-8a39-0800200c9a66"),
									   new XAttribute("t", "r"));
			var refseq2 = new XElement(SharedConstants.Refseq, new XAttribute(SharedConstants.GuidStr, "c1ee3105-e382-11de-8a39-0800200c9a66"),
									   new XAttribute("t", "r"));
			prop.Add(refseq1);
			prop.Add(refseq2);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNull(result);
		}
		public void ReferenceAtomicPropertyHasCorrectResponses()
		{
			var element = new XElement("CmPossibility", new XAttribute(SharedConstants.GuidStr, "c1ee3102-e382-11de-8a39-0800200c9a66"));
			AddBasicPropertyElementsToPoss(element);
			var prop = new XElement("Confidence");
			element.Add(prop);
			var objsurElement = new XElement(SharedConstants.Objsur);
			prop.Add(objsurElement);
			const string guidValue = "c1ee3113-e382-11de-8a39-0800200c9a66";
			var guidAttr = new XAttribute(SharedConstants.GuidStr, guidValue);
			var typeAttr = new XAttribute("t", "r");
			objsurElement.Add(guidAttr);
			objsurElement.Add(typeAttr);

			var result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNull(result);

			var extraAttr = new XAttribute("bogus", "badvalue");
			prop.Add(extraAttr);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has unrecognized attribute(s)"));

			extraAttr.Remove();
			objsurElement.Add(extraAttr);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has too many attributes"));
			extraAttr.Remove();

			var extraChild = new XElement("BogusChild");
			objsurElement.Add(extraChild);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("'objsur' element has child element(s)"));
			extraChild.Remove();

			prop.Add(extraChild);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has too many child elements"));
			extraChild.Remove();

			guidAttr.Value = "badValue";
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			guidAttr.Value = guidValue;

			guidAttr.Remove();
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			objsurElement.Add(guidAttr);

			typeAttr.Value = "o";
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			typeAttr.Value = "r";

			typeAttr.Remove();
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
		}
Exemple #23
0
    private void BtnFunctionCallClicked(XElement functionNode, XElement parameterNode, string parameterName)
    {
        if (parameterNode != null)
        {
            parameterNode.Remove();
        }

        // Adding function call to the xml
        string selectedFunction = btnFunctionCall.Value;
        IFunction newFunction = FunctionFacade.GetFunction(selectedFunction);

        functionNode.Add(new FunctionParameterRuntimeTreeNode(parameterName, new FunctionRuntimeTreeNode(newFunction)).Serialize());

        SaveChanges();
    }
Exemple #24
0
    private void BtnConstantClicked(XElement functionNode, XElement parameterNode, string parameterName)
    {
        IMetaFunction function = TreeHelper.GetFunction(functionNode);
        ParameterProfile parameterProfile = function.ParameterProfiles.FirstOrDefault(p => p.Name == parameterName);
        Verify.IsNotNull(parameterProfile, "Failed to get parameter profile");

        if (parameterNode != null)
        {
            parameterNode.Remove();
        }

        object defaultParameterValue = GetDefaultValue(parameterProfile);

        var newConstantParam = new ConstantObjectParameterRuntimeTreeNode(parameterProfile.Name, defaultParameterValue ?? string.Empty);
        functionNode.Add(newConstantParam.Serialize());

        SaveChanges();
    }
Exemple #25
0
    private void BtnDefaultClicked(XElement parameterNode)
    {
        if (parameterNode != null)
        {
            parameterNode.Remove();

            SaveChanges();
        }
    }
		public void UnicodePropertyHasCorrectResponses()
		{
			var element = new XElement("CmFilter", new XAttribute(SharedConstants.GuidStr, "c1ee3101-e382-11de-8a39-0800200c9a66"));
			var prop = new XElement("Name");
			var attr = new XAttribute(SharedConstants.Val, "badvalue");
			prop.Add(attr);
			element.Add(prop);
			var result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has unrecognized attribute(s)"));
			attr.Remove();

			var extraElement = new XElement("badchild");
			prop.Add(extraElement);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Unexpected child element"));
			extraElement.Remove();

			var uniElement = new XElement(SharedConstants.Uni);
			prop.Add(uniElement);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNull(result);

			uniElement.Value = "SomeText.";
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNull(result);

			uniElement.Add(attr);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has unrecognized attribute(s)"));
			attr.Remove();

			uniElement.Add(extraElement);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has non-text child element"));
			extraElement.Remove();

			var extraUniElement = new XElement(SharedConstants.Uni);
			prop.Add(extraUniElement);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Too many child elements"));
			extraUniElement.Remove();
		}
Exemple #27
0
    private void BtnInputParameterClicked(XElement functionNode, XElement parameterNode, string parameterName)
    {
        if (parameterNode != null)
        {
            parameterNode.Remove();
        }

        // Adding function call - GetInputParameter(InputParameterName = "...")

        IFunction getInputParameterFunc = FunctionFacade.GetFunction(GetInputParameterFunctionName);

        IMetaFunction function = TreeHelper.GetFunction(functionNode);
        ParameterProfile parameterProfile = function.ParameterProfiles.FirstOrDefault(p => p.Name == parameterName);
        var selectedParameter = _state.Parameters.First(ip => InputParameterCanBeAssigned(parameterProfile.Type, ip.Type));
        string selectedParameterName = selectedParameter != null ? selectedParameter.Name : string.Empty;

        var newElement = new FunctionParameterRuntimeTreeNode(parameterName, new FunctionRuntimeTreeNode(getInputParameterFunc)).Serialize();
        functionNode.Add(newElement);

        var inputParameterNameNode = new ConstantObjectParameterRuntimeTreeNode(GetInputParameterFunctionParameterName, selectedParameterName).Serialize();
        newElement.Elements().First().Add(inputParameterNameNode);

        SaveChanges();
    }
		public void MultiStringHasCorrectRepsonses()
		{
			const string str = @"<CmPossibilityList
						guid='cf379f73-9ee5-4e45-b2e2-4b169666d83e'>
		<Description>
			<AStr
				ws='en'>
				<Run
					ws='en'>English multi-string description.</Run>
			</AStr>
			<AStr
				ws='es'>
				<Run
					ws='es'>Spanish multi-string description.</Run>
			</AStr>
		</Description>
						</CmPossibilityList>";
			var element = XElement.Parse(str);
			AddBasicPropertyElementsToPossList(element);
			var result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNull(result);

			var badAttr = new XAttribute("bogusAttr", "badvalue");
			element.Element("Description").Add(badAttr);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has unrecognized attribute(s)"));
			badAttr.Remove();

			var extraChild = new XElement("extraChild");
			element.Element("Description").Add(extraChild);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has non-AStr child element"));
			extraChild.Remove();

			// Test the <Run> element.
			var runElement = element.Element("Description").Element("AStr").Element("Run");
			runElement.Add(extraChild);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has non-text child element"));
			extraChild.Remove();

			runElement.Add(badAttr);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Invalid attribute for <Run> element"));
			badAttr.Remove();
		}
Exemple #29
0
 private static void _grep_user_input_html(XElement m)
 {
     if (m.Name.LocalName.ToLower().In(
         "html", "body", "meta", "frame", "frameset", "iframe",
         "layer", "ilayer", "applet", "script", "style", "embed",
         "object", "link", "form", "input", "textarea", "select"
     ))
         m.Remove();
     if (m.Name.LocalName.ToLower() == "a")
     {
         foreach (XAttribute href in m.Attributes())
             if (href.Name.LocalName.ToLower() == "href")
             {
                 if (href.Value.TrimStart().IndexOf("javascript:", StringComparison.CurrentCultureIgnoreCase) == 0)
                     href.Remove();
             }
     }
     else if (m.Name.LocalName.ToLower() == "img")
     {
         foreach (XAttribute src in m.Attributes())
             if (src.Name.LocalName.ToLower() == "src")
             {
                 if (src.Value.TrimStart().IndexOf("javascript:", StringComparison.CurrentCultureIgnoreCase) == 0)
                     src.Remove();
             }
     }
     foreach (XAttribute attr in m.Attributes())
         if (attr.Name.LocalName.ToLower() == "style")
         {
             if (attr.Value.IndexOf("expression", StringComparison.CurrentCultureIgnoreCase) != -1)
                 attr.Remove();
         }
         else if (attr.Name.LocalName.ToLower().In("onload", "onunload", "onchange",
             "onsubmit", "onreset", "onselect", "onblur", "onfocus", "onabort",
             "onkeydown", "onkeyup", "onkeypress", "onclick", "ondblclick",
             "onmousedown", "onmouseup", "onmousemove", "onmouseout", "onmouseover"
         ))
             attr.Remove();
     foreach (XElement xe in m.Elements())
         _grep_user_input_html(xe);
 }
		public void MultiUnicodeHasCorrectRepsonses()
		{
			const string str = @"<CmPossibilityList
						guid='cf379f73-9ee5-4e45-b2e2-4b169666d83e'>
		<Name>
			<AUni
				ws='en'>Genres &amp;</AUni>
			<AUni
				ws='es'>Géneros &amp;</AUni>
		</Name>
						</CmPossibilityList>";
			var element = XElement.Parse(str);
			AddBasicPropertyElementsToPossList(element);
			var result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNull(result);

			element.Element("Name").Add(new XAttribute("bogusAttr", "badvalue"));
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has unrecognized attribute(s)"));
			element.Element("Name").Attributes().Remove();

			element.Element("Name").Add(new XElement("extraChild"));
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has non-AUni child element"));
			element.Element("Name").Element("extraChild").Remove();

			element.Element("Name").Element("AUni").Add(new XAttribute("bogusAttr", "badValue"));
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has too many attributes"));
			var wsAttr = element.Element("Name").Element("AUni").Attribute("ws");
			wsAttr.Remove();
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Does not have required 'ws' attribute"));
			element.Element("Name").Element("AUni").Attribute("bogusAttr").Remove();
			element.Element("Name").Element("AUni").Add(wsAttr);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNull(result);

			var extraChild = new XElement("extraChild");
			element.Element("Name").Element("AUni").Add(extraChild);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNotNull(result);
			Assert.IsTrue(result.Contains("Has non-text child element"));
			extraChild.Remove();

			// Comment doesn't count, as trouble.
			var comment = new XComment("Some comment.");
			element.Element("Name").Element("AUni").Add(comment);
			result = CmObjectValidator.ValidateObject(_mdc, element);
			Assert.IsNull(result);
			comment.Remove();
		}