public void GivenGetString_WhenEmailContainsValidDecimal_ThenValueIsReturned(string fileName, string elementName, string expected)
{
string textFromFile = File.ReadAllText(fileName);
var value = new XmlExtractor(textFromFile).GetString(elementName);
Assert.Equal(expected, value);
}
[InlineData("before <total>1,24.53</total> text after", 124.53)] // <- Maybe this is not a desired effect
public void GivenGetDecimal_WhenElementContainsValidValue_ThenValueIsReturned(string text, decimal expected)
{
var total = new XmlExtractor(text).GetDecimal("total");
output.WriteLine("Total value [{0}]", total);
Assert.Equal(expected, total);
}
public HttpResponseMessage PostCustomer([FromBody] string message)
{
IXmldocs returndoc = null;
XmlExtractor xtract = new XmlExtractor();
XmlExtractor.DocType doctype = xtract.DetectType(message);
string cleanstring = xtract.CleanText(message);
string xmlstring = xtract.ParseText(cleanstring);
switch (doctype)
{
case XmlExtractor.DocType.Expense:
returndoc = (IXmldocs)xtract.GetXMLDocument <Expense>(xmlstring);
break;
case XmlExtractor.DocType.Reservation:
returndoc = (Reservation)xtract.GetXMLDocument <Reservation>(xmlstring);
break;
default:
break;
}
var response = Request.CreateResponse(HttpStatusCode.Created, returndoc);
return(response);
}
public void GivenGetDecimal_WhenEmailContainsValidDecimal_ThenValueIsReturned(string fileName, string elementName, decimal expected)
{
string textFromFile = File.ReadAllText(fileName);
var value = new XmlExtractor(textFromFile, CultureInfo.CreateSpecificCulture("en-US")).GetDecimal(elementName);
Assert.Equal(expected, value);
}
public void GivenGetDecimal_WhenTextContainsInValidValueNonENUSCulture_ThenUnexpectedValueIsReturned(string text, decimal expected)
{
var total = new XmlExtractor(text, CultureInfo.CreateSpecificCulture("da-DK")).GetDecimal("total");
output.WriteLine("Total value [{0}]", total);
Assert.NotEqual(expected, total);
}
public void GivenGetString_WhenTextContainsnValidValue_ThenUnexpectedValueIsReturned(string text, string elementName, string expected)
{
var value = new XmlExtractor(text).GetString(elementName);
output.WriteLine("Element value [{0}]", value);
Assert.Equal(expected, value);
}
public void GivenGetXmlElement_WhenEmailContainsValidXml_ThenValueIsReturned(string fileName, string elementName, string nodePath, string expected)
{
string textFromFile = File.ReadAllText(fileName);
XmlElement xml = new XmlExtractor(textFromFile).GetXmlElement(elementName);
var node = xml.SelectSingleNode(nodePath);
Assert.Equal(expected, node.Value);
}
public void GivenGetXmlElement_WhenTextContainsValidXml_ThenValueIsReturned(string text, string elementName, string nodePath, string expected)
{
XmlElement xml = new XmlExtractor(text).GetXmlElement(elementName);
var node = xml.SelectSingleNode(nodePath);
output.WriteLine($"Result {node.FirstChild.Value}");
Assert.Equal(expected, node.FirstChild.Value);
}
private IList <IRow> ExecuteExtract(string xml, string rowPath, SqlMap <string, string> columnMappings, USqlSchema schema, SqlMap <string, string> namespaces = null)
{
using (var dataStream = new MemoryStream(Encoding.UTF8.GetBytes(xml)))
{
var reader = new USqlStreamReader(dataStream);
var extractor = new XmlExtractor(rowPath, columnMappings, namespaces);
return(extractor.Extract(reader, new USqlRow(schema, null).AsUpdatable()).ToList());
}
}
static void Main(string[] args)
{
try
{
Log.InfoFormat("XML:\n{0}", XmlExtractor.ToXml("<html><body>Hello world</body></html>"));
}
catch (Exception ex)
{
Log.Error("EXCEPTION", ex);
}
}
public void Load_XMLFile_Expect_TwoItemInList()
{
//Arrange
XmlExtractor xmlExtractor = new XmlExtractor();
var xmlFilePath = (@"TestData\ValidXML.xml");
//Act
var testList = xmlExtractor.LoadXml(xmlFilePath);
//Assert
Assert.AreEqual(testList.Count, 2);
}
public void Load_InvalidXMLFile_ExpectExceptionThrown()
{
//Arrange
//Invalid path set
XmlExtractor xmlExtractor = new XmlExtractor();
var xmlFilePath = (@"TestData\InvalidXML.xml");
//Act
var testList = xmlExtractor.LoadXml(xmlFilePath);
//Assert above method - Expected exception is set
}
//This test has for only purpose to check if the the list has been populater correctly from the file
public void Load_XMLFile_Expect_CorrectHorsesNames()
{
//Arrange
XmlExtractor xmlExtractor = new XmlExtractor();
var xmlFilePath = (@"TestData\ValidXML.xml");
//Act
var testList = xmlExtractor.LoadXml(xmlFilePath);
//Assert
Assert.AreEqual(testList[0].Name, "Advancing");
Assert.AreEqual(testList[1].Name, "Coronel");
}
public void Extract_ValidUsersInputFromBoardgames_Succeeds()
{
IUpdatableRow output = GetUserRow().AsUpdatable();
IEnumerable <IRow> result;
using (FileStream fileReader = new FileStream("Input/Board-Games/Users.xml", FileMode.Open, FileAccess.Read))
{
USqlStreamReader streamReader = new USqlStreamReader(fileReader);
XmlExtractor extractor = new XmlExtractor();
result = extractor.Extract(streamReader, output);
Assert.Equal(9352, result.Count());
}
}
public void Extract_ValidCommentsInputFromBoardgames_Succeeds()
{
IUpdatableRow output = GetCommentRow().AsUpdatable();
IEnumerable<IRow> result;
using (FileStream fileReader = new FileStream("Input/Board-Games/Comments.xml", FileMode.Open, FileAccess.Read))
{
USqlStreamReader streamReader = new USqlStreamReader(fileReader);
XmlExtractor extractor = new XmlExtractor();
result = extractor.Extract(streamReader, output);
Assert.Equal(23343, result.Count());
}
}
public void Extract_ValidUsersInputFromCoffee_Succeeds()
{
IUpdatableRow output = GetUserRow().AsUpdatable();
IEnumerable<IRow> result;
using (FileStream fileReader = new FileStream("Input/Coffee/Users.xml", FileMode.Open, FileAccess.Read))
{
USqlStreamReader streamReader = new USqlStreamReader(fileReader);
XmlExtractor extractor = new XmlExtractor();
result = extractor.Extract(streamReader, output);
Assert.Equal(1162, result.Count());
}
}
public void Extract_ValidCommentsInputFromCoffee_Succeeds()
{
IUpdatableRow output = GetCommentRow().AsUpdatable();
IEnumerable <IRow> result;
using (FileStream fileReader = new FileStream("Input/Coffee/Comments.xml", FileMode.Open, FileAccess.Read))
{
USqlStreamReader streamReader = new USqlStreamReader(fileReader);
XmlExtractor extractor = new XmlExtractor();
result = extractor.Extract(streamReader, output);
Assert.Equal(1279, result.Count());
}
}
public void TestCData()
{
const string child = "<![CDATA[<>]]><x:child/>";
const string xml =
"<file xmlns=\"http://example.com\" xmlns:x=\"http://example.com\">" +
"<root>" +
child +
"</root>" +
"</file>";
using (StringReader input = new StringReader(xml))
using (XmlReader reader = XmlReader.Create(input))
{
Assert.True(FindRootNode(reader));
Assert.That(XmlExtractor.FlattenXml(reader), Is.EqualTo("<><x:child />"));
}
}
public void TestNamespaces()
{
const string child = "Root <x:child att=\"hi\">Child Text <empty /></x:child> Text";
const string xml =
"<file xmlns=\"http://example.com\" xmlns:x=\"http://example.com\">" +
"<root>" +
child +
"</root>" +
"</file>";
using (StringReader input = new StringReader(xml))
using (XmlReader reader = XmlReader.Create(input))
{
Assert.True(FindRootNode(reader));
Assert.That(XmlExtractor.FlattenXml(reader), Is.EqualTo(child));
// Make sure it advanced past the last child part
Assert.That(reader.NodeType, Is.EqualTo(XmlNodeType.EndElement));
Assert.That(reader.Name, Is.EqualTo("root"));
}
}
static void Main(string[] args)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var loadDetails = new LoadDetails();
Console.WriteLine("Starting to load files");
//Save structure
var repo = new InMemoryDataStore(PathToDblpXml, PathToBhtFolder);
var saver = new EntityFrameWorkSaver(100);
Console.WriteLine("Starting to save structure");
//saver.SaveConferences(repo.Conferences);
saver.SaveConferencesWithAddedAuthors(repo.Conferences, XmlExtractor.Read(PathToDblpXml).Where(k => (k.Value.StartsWith("<inproceeding")) || k.Value.StartsWith("<proceeding")));
repo = null;
saver = null;
//Add Authors
//Console.WriteLine("Updating datasets with authors");
//saver = new EntityFrameWorkSaver(Settings.Default.BatchSize);
//saver.UpdateStructureSetAuthor(XmlExtractor.Read(PathToDblpXml).Where(k => (k.Value.StartsWith("<inproceeding")) || k.Value.StartsWith("<proceeding")));
//Add rawdata
Console.WriteLine("Starting to load files");
saver = new EntityFrameWorkSaver(Settings.Default.BatchSize);
saver.SaveBibTexEntries(XmlExtractor.Read(PathToDblpXml).Where(k => (k.Value.StartsWith("<inproceeding")) || k.Value.StartsWith("<proceeding")).Select(t => new BibTexEntry()
{
Key = t.Key,
Content = t.Value.ToBibTeX()
}));
stopwatch.Stop();
loadDetails.LoadTime = stopwatch.Elapsed;
loadDetails.SizeOfXml = new FileInfo(PathToDblpXml).Length;
loadDetails.LastLoaded = DateTime.UtcNow;
saver.SaveLoadDetails(loadDetails);
}
static void Main(string[] args)
{
//One extractor per file format
JsonExtractor.JsonExtractor jsonExtractor = new JsonExtractor.JsonExtractor();
XmlExtractor xmlExtractor = new XmlExtractor();
HorseHandler.HorseHandler horseHandler = new HorseHandler.HorseHandler();
//Retrive file from shared folder
// Future development would involve an API to retrieve file and parse extension
var xmlFilePath = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), @"Data\Caulfield_Race1.xml");
var jsonFilePath = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), @"Data\Wolferhampton_Race1.json");
List <HorseDto> SortedHorsesList = new List <HorseDto>();
try
{
Console.WriteLine("Json file extraction:");
SortedHorsesList = jsonExtractor.LoadJson(jsonFilePath);
horseHandler.SortAndDisplayHorseList(SortedHorsesList);
Console.WriteLine("\n------------------------------");
Console.WriteLine("XML file extraction:");
SortedHorsesList = xmlExtractor.LoadXml(xmlFilePath);
horseHandler.SortAndDisplayHorseList(SortedHorsesList);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.WriteLine("\nPress any key to exit");
Console.ReadKey();
}
public void GivenGetXmlElement_WhenTextIsEmpty_ThenNullIsReturned(string text)
{
XmlElement xml = new XmlExtractor(text).GetXmlElement("expense");
Assert.Null(xml);
}
public UIManager()
{
MainWindow = new MainWindow();
WaresWindow = new WaresWindow();
ModManager = new ModManager();
m_XmlExtractor = new XmlExtractor(this);
m_XmlWriter = new XmlWriter(this);
m_ReadWriteConfig = new ReadWriteConfig(this);
m_Calculations = new Calculations(this);
this.UIModel = new UIModel();
MainWindow.DataContext = this.UIModel;
WaresWindow.DataContext = this.UIModel;
VanillaXmlFiles = new List <string>();
Mod1XmlFiles = new List <string>();
Mod2XmlFiles = new List <string>();
Mod3XmlFiles = new List <string>();
Mod4XmlFiles = new List <string>();
Mod5XmlFiles = new List <string>();
Mod6XmlFiles = new List <string>();
m_ModFilesReader = new ModFilesReader(this, m_XmlExtractor);
MainWindow.Closing += OnClosing;
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.ReadAllVanillaFilesCommand, this.ExecuteReadAllVanillaFilesCommand));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.ReadAllModFilesCommand, this.ExecuteReadAllModFilesCommand));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.OpenModPathManager, this.ExecuteOpenModPathManager));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.FilterCommand, this.ExecuteFilterCommand));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.WriteAllChangedFilesCommand, this.ExecuteWriteAllChangedFilesCommand));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.AddToValueCommand, this.ExecuteAddToValueCommand, CanExecuteCalculate));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.SubstractFromValueCommand, this.ExecuteSubstractFromValueCommand, CanExecuteCalculate));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.MultiplyToValueCommand, this.ExecuteMultiplyToValueCommand, CanExecuteCalculate));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.DivideByValueCommand, this.ExecuteDivideByValueCommand, CanExecuteCalculate));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.SetFixedValueCommand, this.ExecuteSetFixedValueCommand, CanExecuteCalculate));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.ShowWaresWindowCommand, this.ExecuteShowWaresWindowCommand));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.OnMainWindowCellRightClick, this.ExecuteOnMainWindowCellRightClick));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.SelectFolderCommand, this.ExecuteSelectFolderCommand));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.SelectMod1FolderCommand, this.ExecuteSelectMod1FolderCommand));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.SelectMod2FolderCommand, this.ExecuteSelectMod2FolderCommand));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.SelectExportFolderCommand, this.ExecuteSelectExportFolderCommand));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.RecalculatePriceCommand, this.ExecuteRecalculatePriceCommand));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.OnWeaponDoubleClick, this.ExecuteOnWeaponDoubleClick));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.OnProjectileDoubleClick, this.ExecuteOnProjectileDoubleClick));
MainWindow.CommandBindings.Add(new CommandBinding(X4Commands.ShowHelp, this.ExecuteShowHelp));
ModManager = new ModManager();
ModManager.DataContext = this.UIModel;
ModManager.CommandBindings.Add(new CommandBinding(X4Commands.SelectFolderCommand, this.ExecuteSelectFolderCommand));
ModManager.CommandBindings.Add(new CommandBinding(X4Commands.SelectMod1FolderCommand, this.ExecuteSelectMod1FolderCommand));
ModManager.CommandBindings.Add(new CommandBinding(X4Commands.SelectMod2FolderCommand, this.ExecuteSelectMod2FolderCommand));
ModManager.CommandBindings.Add(new CommandBinding(X4Commands.SelectMod3FolderCommand, this.ExecuteSelectMod3FolderCommand));
ModManager.CommandBindings.Add(new CommandBinding(X4Commands.SelectMod4FolderCommand, this.ExecuteSelectMod4FolderCommand));
ModManager.CommandBindings.Add(new CommandBinding(X4Commands.SelectMod5FolderCommand, this.ExecuteSelectMod5FolderCommand));
ModManager.CommandBindings.Add(new CommandBinding(X4Commands.SelectMod6FolderCommand, this.ExecuteSelectMod6FolderCommand));
ModManager.CommandBindings.Add(new CommandBinding(X4Commands.CloseModPathManager, this.ExecuteCloseModPathManager));
m_ReadWriteConfig.LoadConfig();
this.TextDictionary = new Dictionary <string, string>();
this.TextDictionary = m_XmlExtractor.ReadTextXml(this.UIModel.Path + this.PathToTexts + @"\0001-l044.xml", this.TextDictionary);
MainWindow.Show();
this.WaresWindow = new WaresWindow();
this.WaresWindow.Owner = this.MainWindow;
this.WaresWindow.DataContext = this.UIModel;
this.WaresWindow.CommandBindings.Add(new CommandBinding(X4Commands.OnWaresWindowCellRightClick, this.ExecuteOnWaresWindowCellRightClick));
this.WaresWindow.CommandBindings.Add(new CommandBinding(X4Commands.RecalculatePriceCommand, this.ExecuteRecalculatePriceCommand));
ModManager.Owner = this.MainWindow;
WaresWindow.Owner = this.MainWindow;
}
public void GivenGetXmlElement_WhenTextContainsNestedElements_ThenValueIsReturned(string text, string elementName, string expected)
{
XmlElement xml = new XmlExtractor(text).GetXmlElement(elementName);
Assert.Equal(expected, xml.InnerXml);
}
static void Main(string[] args)
{
var extractor = new XmlExtractor(File.ReadAllText(@"A_Lion_1952-10-27_OMUL.xml"));
XmlNodeList holdings = extractor.ExtractNodes("Holding");
foreach (XmlNode holding in holdings)
{
var HoldingName = extractor.ExtractString("HoldingName", holding.ChildNodes);
var HoldingTypeCode = extractor.ExtractString("HoldingTypeCode", holding.ChildNodes);
var CurrencyTypeCode = extractor.ExtractString("CurrencyTypeCode", holding.ChildNodes);
XmlNodeList policys = extractor.ExtractNodes("Policy", holding);
foreach (XmlNode policy in policys)
{
var PolNumber = extractor.ExtractString("PolNumber", policy.ChildNodes);
var LineOfBusiness = extractor.ExtractString("LineOfBusiness", policy.ChildNodes);
var ProductType = extractor.ExtractString("ProductType", policy.ChildNodes);
var PolicyStatus = extractor.ExtractString("PolicyStatus", policy.ChildNodes);
var EffDate = extractor.ExtractString("EffDate", policy.ChildNodes);
var TermDate = extractor.ExtractString("TermDate", policy.ChildNodes);
XmlNodeList Lifes = extractor.ExtractNodes("Life", policy);
foreach (XmlNode life in Lifes)
{
var CashValueAmt = extractor.ExtractString("CashValueAmt", life.ChildNodes);
var DeathBenefitAmt = extractor.ExtractString("DeathBenefitAmt", life.ChildNodes);
XmlNodeList Coverages = extractor.ExtractNodes("Coverage", life);
foreach (XmlNode Coverage in Coverages)
{
var PlanName = extractor.ExtractString("PlanName", Coverage.ChildNodes);
var ProductCode = extractor.ExtractString("ProductCode", Coverage.ChildNodes);
var LifeCovStatus = extractor.ExtractString("LifeCovStatus", Coverage.ChildNodes);
var LifeCovTypeCode = extractor.ExtractString("LifeCovTypeCode", Coverage.ChildNodes);
var IndicatorCode = extractor.ExtractString("IndicatorCode", Coverage.ChildNodes);
var CashValue = extractor.ExtractString("CashValue", Coverage.ChildNodes);
var CoverageEffDate = extractor.ExtractString("EffDate", Coverage.ChildNodes);
var CoverageTermDate = extractor.ExtractString("TermDate", Coverage.ChildNodes);
}
}
}
XmlNodeList Investments = extractor.ExtractNodes("Investment", holding);
foreach (XmlNode Investment in Investments)
{
var AcctNum = extractor.ExtractString("AcctNum", Investment.ChildNodes);
var AcctOpenDate = extractor.ExtractString("AcctOpenDate", Investment.ChildNodes);
var CarrierCode = extractor.ExtractString("CarrierCode", Investment.ChildNodes);
var AccountValue = extractor.ExtractString("AccountValue", Investment.ChildNodes);
XmlNodeList SubAccounts = extractor.ExtractNodes("SubAccount", Investment);
foreach (XmlNode SubAccount in SubAccounts)
{
var SubAccountCarrierCode = extractor.ExtractString("CarrierCode", SubAccount.ChildNodes);
var ProductFullName = extractor.ExtractString("ProductFullName", SubAccount.ChildNodes);
var PortfolioFullName = extractor.ExtractString("PortfolioFullName", SubAccount.ChildNodes);
var AsOfDate = extractor.ExtractString("AsOfDate", SubAccount.ChildNodes);
var CurrNumberUnits = extractor.ExtractString("CurrNumberUnits", SubAccount.ChildNodes);
var UnitValue = extractor.ExtractString("UnitValue", SubAccount.ChildNodes);
var TotValue = extractor.ExtractString("TotValue", SubAccount.ChildNodes);
var AllocPercent = extractor.ExtractString("AllocPercent", SubAccount.ChildNodes);
}
}
}
}
public async Task <IActionResult> UploadFile(IFormFile file)
{
if (file == null)
{
return(BadRequest("File required"));
}
var ext = Path.GetExtension(file.FileName).ToLower();
if (!(ext == ".csv" || ext == ".xml"))
{
return(BadRequest("Unknown format"));
}
if (file.Length > (MAX_FILE_SIZE))
{
return(BadRequest($"Invalid File Size (Maximum: {MAX_FILE_SIZE / (1024 * 1024)} MB)"));
}
// Save file into Uploads folder
var transFile = new TransactionFile();
string errormsg = "";
try
{
//throw new Exception();
transFile = await SaveFileAsync(file);
Strategy strategy;
if (ext == ".csv")
{
strategy = new CsvExtractor();
}
else
{
strategy = new XmlExtractor();
}
var entityExtractor = new TransactionExtractor(strategy);
var entities = entityExtractor.ExtractTransaction(file);
if (entities.Where(x => !string.IsNullOrWhiteSpace(x.Errors)).Count() == 0)
{
// Clean records, add to transaction
var cleanEntities = entities.Select(x => new TransactionEntity
{
TransactionId = x.TransactionId,
Amount = x.ValidAmount.Value,
CurrencyCode = x.CurrencyCode,
DateTime = x.ValidTransactionDate.Value.UtcDateTime,
Status = x.ValidStatus
});
_dbcontext.TransactionEntity.AddRange(cleanEntities);
}
else
{
// Dirty records, add to error log
var errors = entities.Select(x => new TransactionErrorLog
{
TransactionId = x.TransactionId,
Amount = x.Amount,
CurrencyCode = x.CurrencyCode,
DateTime = x.TransactionDate,
Status = x.Status,
Error = x.Errors,
FileId = transFile.Id
});
_dbcontext.TransactionErrorLog.AddRange(errors);
errormsg = "Some records in uploaded file is not valid, please check error log for details.";
}
await _dbcontext.SaveChangesAsync();
if (string.IsNullOrWhiteSpace(errormsg))
{
return(Ok("Success"));
}
else
{
return(BadRequest(errormsg));
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
if (System.IO.File.Exists(Path.Combine(_hostingEnvironment.ContentRootPath, "Uploads", transFile.FileName ?? "")))
{
GC.Collect();
GC.WaitForPendingFinalizers();
System.IO.File.Delete(Path.Combine(_hostingEnvironment.ContentRootPath, "Uploads", transFile.FileName ?? ""));
}
// TODO: If db exception in here
if (transFile.Id != 0)
{
_dbcontext.TransactionFile.Remove(transFile);
await _dbcontext.SaveChangesAsync();
}
return(new StatusCodeResult(500));
}
}
[InlineData("<vendor>Viaduct Steakhouse</vendor>", "cost_centre")] // neither opening nor closing tag found
public void GivenGetXmlElement_WhenTextDoesntContainElementWeAreLookingFor_ThenNullIsReturned(string text, string elementName)
{
XmlElement xml = new XmlExtractor(text).GetXmlElement(elementName);
Assert.Null(xml);
}
