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);
}