public void SaveAndReadTest()
{
StringBuilder sb = new StringBuilder();
XmlWriter writer = new XmlTextWriter(new StringWriter(sb));
uint row = (uint)rng.Next();
cell.Row = row;
uint column = (uint)rng.Next();
cell.Column = column;
cell.InputValue = "input string";
cell.NumericValue = "numeric value";
cell.Value = "display value";
cell.Save(writer);
writer.Close();
XmlDocument document = new XmlDocument();
document.LoadXml(sb.ToString());
ExtensionElementEventArgs e = new ExtensionElementEventArgs();
e.ExtensionElement = document.FirstChild;
entry.Parse(e, new AtomFeedParser());
Assert.AreEqual(row, entry.Cell.Row, "Rows should be equal");
Assert.AreEqual(column, entry.Cell.Column, "Columns should be equal");
Assert.AreEqual("input string", entry.Cell.InputValue, "Input value should be equal");
Assert.AreEqual("numeric value", entry.Cell.NumericValue, "Numeric value should be equal");
Assert.AreEqual("display value", entry.Cell.Value, "Cell value should be equal");
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>eventhandler - called for new extension element
/// </summary>
/// <param name="sender"> the object which send the event</param>
/// <param name="e">FeedParserEventArguments, holds the feedentry</param>
/// <returns> </returns>
//////////////////////////////////////////////////////////////////////
protected void OnNewExtensionElement(object sender, ExtensionElementEventArgs e)
{
// by default, if our event chain is not hooked, the underlying parser will add it
Tracing.TraceCall("received new extension element notification");
Tracing.Assert(e != null, "e should not be null");
if (e == null)
{
throw new ArgumentNullException("e");
}
Tracing.TraceMsg("\t top level event = new extension");
if (String.Compare(e.ExtensionElement.NamespaceURI, "http://purl.org/dc/elements/1.1/", true) == 0)
{
// found DC namespace
Tracing.TraceMsg("\t top level event = new DC extension");
if (e.ExtensionElement.LocalName == "date")
{
MyEntry entry = e.Base as MyEntry;
if (entry != null)
{
entry.DCDate = DateTime.Parse(e.ExtensionElement.InnerText);
e.DiscardEntry = true;
}
}
}
}
public void SaveAndReadTest()
{
Who recipient = new Who();
recipient.Email = "*****@*****.**";
recipient.Rel = Who.RelType.MESSAGE_TO;
entry.Recipient = recipient;
StringBuilder sb = new StringBuilder();
XmlWriter writer = new XmlTextWriter(new StringWriter(sb));
entry.SaveToXml(writer);
writer.Close();
XmlDocument document = new XmlDocument();
document.LoadXml(sb.ToString());
EmailListRecipientEntry newEntry = new EmailListRecipientEntry();
foreach (XmlNode node in document.FirstChild.ChildNodes)
{
ExtensionElementEventArgs args = new ExtensionElementEventArgs();
args.ExtensionElement = node;
args.Base = newEntry;
newEntry.Parse(args, new AtomFeedParser());
}
Assert.AreEqual(recipient.Email, newEntry.Recipient.Email,
"Parsed entry should have same recipient as original entry");
}
public void SaveAndReadTest()
{
entry.Properties.Add(new PropertyElement("name", "value"));
StringBuilder sb = new StringBuilder();
XmlWriter writer = new XmlTextWriter(new StringWriter(sb));
entry.SaveToXml(writer);
writer.Close();
XmlDocument document = new XmlDocument();
document.LoadXml(sb.ToString());
GoogleMailSettingsEntry newEntry = new GoogleMailSettingsEntry();
foreach (XmlNode node in document.FirstChild.ChildNodes)
{
ExtensionElementEventArgs args = new ExtensionElementEventArgs();
args.ExtensionElement = node;
args.Base = newEntry;
newEntry.Parse(args, new AtomFeedParser());
}
Assert.AreEqual(entry.Properties[0].Name, newEntry.Properties[0].Name,
"Parsed entry should have same name for property[0] as original entry");
Assert.AreEqual(entry.Properties[0].Value, newEntry.Properties[0].Value,
"Parsed entry should have same value for property[0] as original entry");
}
protected void OnNewEventExtensionElement(object sender,
ExtensionElementEventArgs e)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
if (e.DiscardEntry)
{
return;
}
if (String.Compare(e.ExtensionElement.NamespaceURI,
GBaseNameTable.NSGBase, true) == 0)
{
e.DiscardEntry = true;
if (e.Base is GBaseAttributeContainer)
{
GBaseAttributeContainer container = e.Base as GBaseAttributeContainer;
container.GBaseAttributes.AddFromXml(e.ExtensionElement);
return;
}
}
if (e.Base is GBaseEntry)
{
GBaseEntry entry = e.Base as GBaseEntry;
if (entry.AddFromMetaNamespace(e.ExtensionElement))
{
e.DiscardEntry = true;
}
}
}
public void SaveAndReadTest()
{
LoginElement login = new LoginElement("jdoe");
entry.Login = login;
NicknameElement nickname = new NicknameElement("john");
entry.Nickname = nickname;
StringBuilder sb = new StringBuilder();
XmlWriter writer = new XmlTextWriter(new StringWriter(sb));
entry.SaveToXml(writer);
writer.Close();
XmlDocument document = new XmlDocument();
document.LoadXml(sb.ToString());
NicknameEntry newEntry = new NicknameEntry();
foreach (XmlNode node in document.FirstChild.ChildNodes)
{
ExtensionElementEventArgs args = new ExtensionElementEventArgs();
args.ExtensionElement = node;
args.Base = newEntry;
newEntry.Parse(args, new AtomFeedParser());
}
Assert.AreEqual(login.UserName, newEntry.Login.UserName,
"Parsed entry should have same username as original entry");
Assert.AreEqual(nickname.Name, newEntry.Nickname.Name,
"Parsed entry should have same nickname as original entry");
}
//////////////////////////////////////////////////////////////////////
/// <summary>parses the inner state of the element</summary>
/// <param name="e">the Event arguments</param>
/// <param name="parser">the atomFeedParser that called this</param>
//////////////////////////////////////////////////////////////////////
public override void Parse(ExtensionElementEventArgs e, AtomFeedParser parser)
{
XmlNode eventNode = e.ExtensionElement;
Tracing.TraceMsg(eventNode.LocalName);
// Ensure that the namespace is correct.
if (String.Compare(eventNode.NamespaceURI,
GCodeSearchParserNameTable.CSNamespace, true) == 0)
{
// Parse a File Element
if (eventNode.LocalName == GCodeSearchParserNameTable.EVENT_FILE)
{
file = File.ParseFile(eventNode, parser);
e.DiscardEntry = true;
}
// Parse a Package Element
else if ((eventNode.LocalName == GCodeSearchParserNameTable.EVENT_PACKAGE))
{
package = Package.ParsePackage(eventNode, parser);
e.DiscardEntry = true;
}
// Parse Match Elements
else if (eventNode.LocalName == GCodeSearchParserNameTable.EVENT_MATCH)
{
matches.Add(Match.ParseMatch(eventNode, parser));
e.DiscardEntry = true;
}
}
}
public void SaveAndReadMultipleTest()
{
for (int i = 0; i < 256; i++)
{
ListEntry.Custom element = new ListEntry.Custom();
element.LocalName = "local_name_" + i;
element.Value = "value_" + i;
StringBuilder sb = new StringBuilder();
XmlWriter writer = new XmlTextWriter(new StringWriter(sb));
element.Save(writer);
writer.Close();
XmlDocument document = new XmlDocument();
document.LoadXml(sb.ToString());
ExtensionElementEventArgs e = new ExtensionElementEventArgs();
e.ExtensionElement = document.FirstChild;
entry.Parse(e, new AtomFeedParser());
Assert.AreEqual(i + 1, entry.Elements.Count);
Assert.AreEqual(element.LocalName, entry.Elements[i].LocalName);
Assert.AreEqual(element.Value, entry.Elements[i].Value);
}
}
public void SaveAndReadTest()
{
EmailListElement emailList = new EmailListElement("foo");
entry.EmailList = emailList;
StringBuilder sb = new StringBuilder();
XmlWriter writer = new XmlTextWriter(new StringWriter(sb));
entry.SaveToXml(writer);
writer.Close();
XmlDocument document = new XmlDocument();
document.LoadXml(sb.ToString());
EmailListEntry newEntry = new EmailListEntry();
foreach (XmlNode node in document.FirstChild.ChildNodes)
{
ExtensionElementEventArgs args = new ExtensionElementEventArgs();
args.ExtensionElement = node;
args.Base = newEntry;
newEntry.Parse(args, new AtomFeedParser());
}
Assert.AreEqual(emailList.Name, newEntry.EmailList.Name,
"Parsed entry should have same email list name as original entry");
}
/// <summary>
/// Parses the inner state of the element. TODO.
/// </summary>
/// <param name="e">The extension element that should be added to this entry</param>
/// <param name="parser">The AtomFeedParser that called this</param>
public override void Parse(ExtensionElementEventArgs e, AtomFeedParser parser)
{
if (String.Compare(e.ExtensionElement.NamespaceURI, GDataSpreadsheetsNameTable.NSGSpreadsheetsExtended, true) == 0)
{
Elements.Add(Custom.ParseCustom(e.ExtensionElement, parser));
e.DiscardEntry = true;
}
}
public void ExtensionElementEventArgsConstructorTest()
{
ExtensionElementEventArgs target = new ExtensionElementEventArgs();
Assert.IsNotNull(target);
Assert.IsNull(target.Base);
Assert.IsNull(target.ExtensionElement);
Assert.IsFalse(target.DiscardEntry);
}
public void DiscardEntryTest()
{
ExtensionElementEventArgs target = new ExtensionElementEventArgs(); // TODO: Initialize to an appropriate value
bool expected = false; // TODO: Initialize to an appropriate value
bool actual;
target.DiscardEntry = expected;
actual = target.DiscardEntry;
Assert.AreEqual(expected, actual);
}
public void ExtensionElementTest()
{
ExtensionElementEventArgs target = new ExtensionElementEventArgs(); // TODO: Initialize to an appropriate value
XmlNode expected = null; // TODO: Initialize to an appropriate value
XmlNode actual;
target.ExtensionElement = expected;
actual = target.ExtensionElement;
Assert.AreEqual(expected, actual);
}
public void BaseTest()
{
ExtensionElementEventArgs target = new ExtensionElementEventArgs(); // TODO: Initialize to an appropriate value
AtomBase expected = new AtomEntry();
AtomBase actual;
target.Base = expected;
actual = target.Base;
Assert.AreEqual(expected, actual);
}
public void SaveAndReadTest()
{
LoginElement login = new LoginElement("jdoe");
login.Admin = true;
login.HashFunctionName = "SHA-1";
entry.Login = login;
QuotaElement quota = new QuotaElement(2048);
entry.Quota = quota;
NameElement name = new NameElement("Doe", "John");
entry.Name = name;
StringBuilder sb = new StringBuilder();
XmlWriter writer = new XmlTextWriter(new StringWriter(sb));
entry.SaveToXml(writer);
writer.Close();
XmlDocument document = new XmlDocument();
document.LoadXml(sb.ToString());
UserEntry newEntry = new UserEntry();
foreach (XmlNode node in document.FirstChild.ChildNodes)
{
ExtensionElementEventArgs args = new ExtensionElementEventArgs();
args.ExtensionElement = node;
args.Base = newEntry;
newEntry.Parse(args, new AtomFeedParser());
}
Assert.AreEqual(login.UserName, newEntry.Login.UserName,
"Parsed entry should have same username as original entry");
Assert.IsTrue(newEntry.Login.Admin,
"Parsed entry should have admin property set to true");
Assert.AreEqual(login.HashFunctionName, newEntry.Login.HashFunctionName,
"Parsed entry should have same hash function name as original entry");
Assert.AreEqual(quota.Limit, newEntry.Quota.Limit,
"Parsed entry should have same quota as original entry");
Assert.AreEqual(name.FamilyName, newEntry.Name.FamilyName,
"Parsed entry should have same family name as original entry");
Assert.AreEqual(name.GivenName, newEntry.Name.GivenName,
"Parsed entry should have same given name as original entry");
}
public void ParseXmlTest()
{
string xmlElementText = "<entry xmlns=\"http://www.w3.org/2005/Atom\" " +
"xmlns:gd=\"http://schemas.google.com/g/2005\">" + Rfc822MsgTest.xmlElementAsText +
LabelTest.xmlElementAsText + LabelTest.xmlElementAsText.Replace("Friends", "Acquaintances") +
MailItemPropertyTest.xmlElementAsText +
MailItemPropertyTest.xmlElementAsText.Replace("SENT", "STARRED") +
"<gd:when startTime=\"2005-10-06\"/></entry>";
// Parse the XML back into a new MigrationEntry
XmlDocument document = new XmlDocument();
document.LoadXml(xmlElementText);
foreach (XmlNode node in document.FirstChild.ChildNodes)
{
ExtensionElementEventArgs e = new ExtensionElementEventArgs();
e.ExtensionElement = node;
entry.Parse(e, new AtomFeedParser());
}
// Verify that the labels are correct
Assert.AreEqual(2, entry.Labels.Count, "Parsed MailItemEntry should have exactly two labels");
Assert.AreEqual("Friends", entry.Labels[0].LabelName,
"Parsed MailItemEntry does not contain a \"Friends\" label");
Assert.AreEqual("Acquaintances", entry.Labels[1].LabelName,
"Parsed MailItemEntry does not contain an \"Acquaintances\" label");
// Verify that the mail item properties are correct
Assert.AreEqual(2, entry.MailItemProperties.Count,
"Parsed MailItemEntry should have exactly two mail item properties");
Assert.AreEqual("IS_SENT", entry.MailItemProperties[0].Value.ToString(),
"Parsed MailItemEntry does not contain a SENT property.");
Assert.AreEqual("IS_STARRED", entry.MailItemProperties[1].Value.ToString(),
"Parsed MailItemEntry does not contain the STARRED property.");
// Verify that the RFC822 message is correct
Assert.AreEqual("Hi", entry.Rfc822Msg.ToString(), "Parsed MailItemEntry has incorrect Rfc822Msg");
}
public void SaveAndReadColTest()
{
ColCountElement count = new ColCountElement();
count.Count = (uint)new Random().Next();
StringBuilder sb = new StringBuilder();
XmlWriter writer = new XmlTextWriter(new StringWriter(sb));
count.Save(writer);
writer.Close();
XmlDocument document = new XmlDocument();
document.LoadXml(sb.ToString());
ExtensionElementEventArgs e = new ExtensionElementEventArgs();
e.ExtensionElement = document.FirstChild;
entry.Parse(e, new AtomFeedParser());
Assert.IsNotNull(entry.ColCount);
Assert.AreEqual(entry.ColCount.Count, count.Count);
}
/// <summary>
/// get's called after we already handled the custom entry, to handle all
/// other potential parsing tasks
/// </summary>
/// <param name="e"></param>
/// <param name="parser">the atom feed parser used</param>
protected override void HandleExtensionElements(ExtensionElementEventArgs e, AtomFeedParser parser)
{
}
/// <summary>
/// Get's called after we already handled the custom entry, to handle all other potential parsing tasks.
/// </summary>
/// <param name="e"></param>
/// <param name="parser">The atom feed parser.</param>
protected override void HandleExtensionElements(ExtensionElementEventArgs e, AtomFeedParser parser)
{
Tracing.TraceMsg("\t HandleExtensionElements for Portfolio feed called");
}