internal static Exception CreateReadElementContentAsException(string methodName, XmlNodeType nodeType) { return((Exception) new InvalidOperationException(Res.GetString(51, (object[])new string[2] { methodName, nodeType.ToString() }))); }
protected void TestOnInvalidNodeType(XmlNodeType nt) { ReloadSource(); PositionOnNodeType(nt); if (CheckCanReadBinaryContent()) return; try { byte[] buffer = new byte[1]; int nBytes = DataReader.ReadContentAsBase64(buffer, 0, 1); } catch (InvalidOperationException ioe) { if (ioe.ToString().IndexOf(nt.ToString()) < 0) CError.Compare(false, "Call threw wrong invalid operation exception on " + nt); else return; } CError.Compare(false, "Call succeeded on " + nt); }
public override string ToString() { XmlNodeType nodeType = this.node.NodeType; string str = nodeType.ToString(); switch (nodeType) { case XmlNodeType.Element: case XmlNodeType.EntityReference: return(str + ", Name=\"" + this.node.Name + "\""); case XmlNodeType.Attribute: case XmlNodeType.ProcessingInstruction: { string str2 = str; return(str2 + ", Name=\"" + this.node.Name + "\", Value=\"" + XmlConvert.EscapeValueForDebuggerDisplay(this.node.Value) + "\""); } case XmlNodeType.Text: case XmlNodeType.CDATA: case XmlNodeType.Comment: case XmlNodeType.Whitespace: case XmlNodeType.SignificantWhitespace: case XmlNodeType.XmlDeclaration: return(str + ", Value=\"" + XmlConvert.EscapeValueForDebuggerDisplay(this.node.Value) + "\""); case XmlNodeType.Entity: case XmlNodeType.Document: case XmlNodeType.DocumentFragment: case XmlNodeType.Notation: case XmlNodeType.EndElement: case XmlNodeType.EndEntity: return(str); case XmlNodeType.DocumentType: { XmlDocumentType node = (XmlDocumentType)this.node; string str3 = str; return(str3 + ", Name=\"" + node.Name + "\", SYSTEM=\"" + node.SystemId + "\", PUBLIC=\"" + node.PublicId + "\", Value=\"" + XmlConvert.EscapeValueForDebuggerDisplay(node.InternalSubset) + "\""); } } return(str); }
protected void TestOnInvalidNodeType(XmlNodeType nt) { XmlReader DataReader = GetReader(pBase64Xml); PositionOnNodeType(DataReader, nt); if (!DataReader.CanReadBinaryContent) return; try { byte[] buffer = new byte[1]; int nBytes = DataReader.ReadContentAsBase64(buffer, 0, 1); } catch (InvalidOperationException ioe) { if (ioe.ToString().IndexOf(nt.ToString()) < 0) TestLog.Compare(false, "Call threw wrong invalid operation exception on " + nt); else return; } TestLog.Compare(false, "Call succeeded on " + nt); }
public override string ToString() { XmlNodeType nodeType = _node.NodeType; string result = nodeType.ToString(); switch (nodeType) { case XmlNodeType.Element: case XmlNodeType.EntityReference: result += ", Name=\"" + _node.Name + "\""; break; case XmlNodeType.Attribute: case XmlNodeType.ProcessingInstruction: result += ", Name=\"" + _node.Name + "\", Value=\"" + XmlConvertEx.EscapeValueForDebuggerDisplay(_node.Value) + "\""; break; case XmlNodeType.Text: case XmlNodeType.CDATA: case XmlNodeType.Comment: case XmlNodeType.Whitespace: case XmlNodeType.SignificantWhitespace: case XmlNodeType.XmlDeclaration: result += ", Value=\"" + XmlConvertEx.EscapeValueForDebuggerDisplay(_node.Value) + "\""; break; case XmlNodeType.DocumentType: XmlDocumentType documentType = (XmlDocumentType)_node; result += ", Name=\"" + documentType.Name + "\", SYSTEM=\"" + documentType.SystemId + "\", PUBLIC=\"" + documentType.PublicId + "\", Value=\"" + XmlConvertEx.EscapeValueForDebuggerDisplay(documentType.InternalSubset) + "\""; break; default: break; } return(result); }
public virtual XmlNode CreateNode( XmlNodeType type, string prefix, string name, string namespaceURI) { switch (type) { case XmlNodeType.Attribute: return(CreateAttribute(prefix, name, namespaceURI)); case XmlNodeType.CDATA: return(CreateCDataSection(null)); case XmlNodeType.Comment: return(CreateComment(null)); case XmlNodeType.Document: return(new XmlDocument()); case XmlNodeType.DocumentFragment: return(CreateDocumentFragment()); case XmlNodeType.DocumentType: return(CreateDocumentType(null, null, null, null)); case XmlNodeType.Element: return(CreateElement(prefix, name, namespaceURI)); case XmlNodeType.EntityReference: return(CreateEntityReference(null)); case XmlNodeType.ProcessingInstruction: return(CreateProcessingInstruction(null, null)); case XmlNodeType.SignificantWhitespace: return(CreateSignificantWhitespace(String.Empty)); case XmlNodeType.Text: return(CreateTextNode(null)); case XmlNodeType.Whitespace: return(CreateWhitespace(String.Empty)); case XmlNodeType.XmlDeclaration: return(CreateXmlDeclaration("1.0", null, null)); default: #if NET_2_0 throw new ArgumentException( #else // makes less sense throw new ArgumentOutOfRangeException( #endif String.Format("{0}\nParameter name: {1}", "Specified argument was out of the range of valid values", type.ToString())); } }
private void InitFragmentReader(XmlNodeType fragmentType, XmlParserContext parserContext, bool allowXmlDeclFragment) { _fragmentParserContext = parserContext; if (parserContext != null) { if (parserContext.NamespaceManager != null) { _namespaceManager = parserContext.NamespaceManager; _xmlContext.defaultNamespace = _namespaceManager.LookupNamespace(string.Empty); } else { _namespaceManager = new XmlNamespaceManager(_nameTable); } _ps.baseUriStr = parserContext.BaseURI; _ps.baseUri = null; _xmlContext.xmlLang = parserContext.XmlLang; _xmlContext.xmlSpace = parserContext.XmlSpace; } else { _namespaceManager = new XmlNamespaceManager(_nameTable); _ps.baseUriStr = string.Empty; _ps.baseUri = null; } _reportedBaseUri = _ps.baseUriStr; switch (fragmentType) { case XmlNodeType.Attribute: _ps.appendMode = false; _parsingFunction = ParsingFunction.SwitchToInteractive; _nextParsingFunction = ParsingFunction.FragmentAttribute; break; case XmlNodeType.Element: Debug.Assert(_parsingFunction == ParsingFunction.SwitchToInteractiveXmlDecl); _nextParsingFunction = ParsingFunction.DocumentContent; break; case XmlNodeType.Document: Debug.Assert(_parsingFunction == ParsingFunction.SwitchToInteractiveXmlDecl); Debug.Assert(_nextParsingFunction == ParsingFunction.DocumentContent); break; case XmlNodeType.XmlDeclaration: if (allowXmlDeclFragment) { _ps.appendMode = false; _parsingFunction = ParsingFunction.SwitchToInteractive; _nextParsingFunction = ParsingFunction.XmlDeclarationFragment; break; } else { goto default; } default: Throw(SR.Xml_PartialContentNodeTypeNotSupportedEx, fragmentType.ToString()); return; } _fragmentType = fragmentType; _fragment = true; }
#pragma warning restore 618 static internal Exception UnexpectedNodeType(XmlNodeType nodetype) { return new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, SR.Xml_UnexpectedNodeType, nodetype.ToString())); }
/// <summary> /// /// </summary> /// <remarks></remarks> /// <seealso cref=""/> /// <param name="name"></param> /// <param name="type"></param> /// <returns></returns> protected XElement CreateXElement(string name, XmlNodeType type) { if (_mode.Equals(XmlNodeMode.type)) { XElement element = new XElement(type.ToString()); element.SetAttributeValue("name", name); element.SetAttributeValue("type", type.ToString()); return element; } if (_mode.Equals(XmlNodeMode.xPath)) { XElement element = new XElement(name.Replace(" ", "")); element.SetAttributeValue("type", type.ToString()); return element; } return null; }
internal static Exception CreateReadElementContentAsException(string methodName, XmlNodeType nodeType, IXmlLineInfo lineInfo) { return new InvalidOperationException(AddLineInfo(Res.GetString("Xml_InvalidReadElementContentAs", new string[] { methodName, nodeType.ToString() }), lineInfo)); }
void UnexpectedNodeType(XmlNodeType type) { IXmlLineInfo li = (IXmlLineInfo)reader; throw new XmlException(string.Format(SR.UnexpectedNodeType, type.ToString()), null, li.LineNumber, li.LinePosition); }
static internal Exception CreateReadElementContentAsException(string methodName, XmlNodeType nodeType) { return new InvalidOperationException(Res.GetString(Res.Xml_InvalidReadElementContentAs, new string[] { methodName, nodeType.ToString() })); }
internal static Exception UnexpectedNodeType(XmlNodeType nodetype) { return new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, Res.GetString("Xml_UnexpectedNodeType"), new object[] { nodetype.ToString() })); }
static internal Exception CreateReadElementContentAsException(string methodName, XmlNodeType nodeType) { return(new InvalidOperationException(Res.GetString(Res.Xml_InvalidReadElementContentAs, new string[] { methodName, nodeType.ToString() }))); }
public virtual XmlNode CreateNode ( XmlNodeType type, string prefix, string name, string namespaceURI) { switch (type) { case XmlNodeType.Attribute: return CreateAttribute (prefix, name, namespaceURI); case XmlNodeType.CDATA: return CreateCDataSection (null); case XmlNodeType.Comment: return CreateComment (null); case XmlNodeType.Document: return new XmlDocument (); case XmlNodeType.DocumentFragment: return CreateDocumentFragment (); case XmlNodeType.DocumentType: return CreateDocumentType (null, null, null, null); case XmlNodeType.Element: return CreateElement (prefix, name, namespaceURI); case XmlNodeType.EntityReference: return CreateEntityReference (null); case XmlNodeType.ProcessingInstruction: return CreateProcessingInstruction (null, null); case XmlNodeType.SignificantWhitespace: return CreateSignificantWhitespace (String.Empty); case XmlNodeType.Text: return CreateTextNode (null); case XmlNodeType.Whitespace: return CreateWhitespace (String.Empty); case XmlNodeType.XmlDeclaration: return CreateXmlDeclaration ("1.0", null, null); default: #if NET_2_0 throw new ArgumentException ( #else // makes less sense throw new ArgumentOutOfRangeException ( #endif String.Format("{0}\nParameter name: {1}", "Specified argument was out of the range of valid values", type.ToString ())); } }
internal static Exception UnexpectedNodeType(XmlNodeType nodetype) { return(new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, Res.GetString("Xml_UnexpectedNodeType"), new object[] { nodetype.ToString() }))); }
static internal Exception CreateReadElementContentAsException(string methodName, XmlNodeType nodeType, IXmlLineInfo lineInfo) { return new InvalidOperationException(AddLineInfo(SR.Format(SR.Xml_InvalidReadElementContentAs, methodName, nodeType.ToString()), lineInfo)); }
////////////////////////////////////////// // PositionOnNodeType ////////////////////////////////////////// public void PositionOnNodeType(XmlNodeType nodeType) { CError.WriteLine("Seeking Nodetype : " + nodeType.ToString()); if (NodeType == nodeType) return; while (Read() && NodeType != nodeType) { if (NodeType == XmlNodeType.EntityReference) { if (CanResolveEntity) ResolveEntity(); } if (nodeType == XmlNodeType.ProcessingInstruction && NodeType == XmlNodeType.XmlDeclaration) { if (String.Compare(Name, 0, ST_XML, 0, 3) != 0) return; } if (NodeType == XmlNodeType.Element && nodeType == XmlNodeType.Attribute) { if (MoveToFirstAttribute()) { return; }; } } if (EOF) { throw new CTestException(CTestBase.TEST_FAIL, "Couldn't find XmlNodeType " + nodeType); } }
internal static Exception UnexpectedNodeType(XmlNodeType nodetype) { return(new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, SR.Xml_UnexpectedNodeType, nodetype.ToString()))); }
private static void AddCodeProperty( string nodeName, XmlNodeType nodeType, CodeTypeReference propertyType, CodeTypeDeclaration classType, bool collection, string nameSpaceName) { string propertyVariableName = CodePrivateNameFromRssName(nodeName); string propertyName = CodeNameFromRssName(nodeName); if (collection) { propertyVariableName = Pluralizer.ToPlural(propertyVariableName); propertyName = Pluralizer.ToPlural(propertyName); propertyType = new CodeTypeReference( "List", new CodeTypeReference[1] { propertyType }); } bool alreadyThere = TypeContainsProperty(classType, propertyVariableName); if (alreadyThere) return; classType.Members.Add(new CodeMemberField(propertyType, propertyVariableName)); CodeMemberProperty property = new CodeMemberProperty(); property.Attributes &= ~MemberAttributes.AccessMask; property.Attributes |= MemberAttributes.Public; property.Name = propertyName; property.Type = propertyType; // prevent warnings for RssDocumentBase properties if (propertyName.Equals("Version", StringComparison.Ordinal) || propertyName.Equals("Channel", StringComparison.Ordinal)) { property.Attributes |= MemberAttributes.New; } CodeAttributeDeclaration cad; if (nodeType != XmlNodeType.Text) { cad = new CodeAttributeDeclaration( "Xml" + nodeType.ToString(), new CodeAttributeArgument(new CodePrimitiveExpression(nodeName))); } else { cad = new CodeAttributeDeclaration("Xml" + nodeType.ToString()); } if (!String.IsNullOrEmpty(nameSpaceName)) { cad.Arguments.Add(new CodeAttributeArgument("Namespace", new CodePrimitiveExpression(nameSpaceName))); } property.CustomAttributes.Add(cad); property.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(propertyVariableName))); property.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(propertyVariableName), new CodeArgumentReferenceExpression("value"))); classType.Members.Add(property); }