public void TestMultidimStringArray()
{
string[,] x;
x = (string[, ])Array.CreateInstance(typeof(string), new int[] { 2, 2 }, new int[] { 5, 9 });
x[5, 9] = "first";
x[5, 10] = "second";
x[6, 9] = "third";
x[6, 10] = "fourth";
var c = new CSerializationContext();
c.SetConcise();
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(1, elem.ChildNodes.Count, "Should be one child (an XmlText node)");
Assert.AreEqual("2,2",
XmlExtensions.GetAttributeValue(elem, c.ArrayAttributeName),
"Array Lengths are wrong");
Assert.AreEqual("5,9",
XmlExtensions.GetAttributeValue(elem, c.ArrayLowerBoundAttribute),
"Array Lowerbounds are wrong");
Assert.AreEqual("first,second,third,fourth", elem.InnerText, "The text for the multidim array is wrong");
}
public static JobResponse ParseResponseContent(Stream content)
{
var masterObjectList = XmlExtensions.ReadDocument(content).ElementOrThrow("MasterObjectList");
return(new JobResponse(
bucketName: masterObjectList.AttributeText("BucketName"),
jobId: Guid.Parse(masterObjectList.AttributeText("JobId")),
priority: masterObjectList.AttributeText("Priority"),
requestType: masterObjectList.AttributeText("RequestType"),
startDate: DateTime.Parse(masterObjectList.AttributeText("StartDate")),
chunkOrder: ParseChunkOrdering(masterObjectList.AttributeText("ChunkClientProcessingOrderGuarantee")),
nodes: (
from nodesElement in masterObjectList.Elements("Nodes")
from nodeElement in nodesElement.Elements("Node")
select new Node(
Guid.Parse(nodeElement.AttributeText("Id")),
nodeElement.AttributeText("EndPoint"),
ParseIntOrNull(nodeElement.AttributeTextOrNull("HttpPort")),
ParseIntOrNull(nodeElement.AttributeTextOrNull("HttpsPort"))
)
).ToList(),
objectLists: masterObjectList
.Elements("Objects")
.Select(ParseObjectList)
.ToList(),
status: ResponseParseUtilities.ParseJobStatus(masterObjectList.AttributeTextOrNull("Status"))
));
}
public void TestExternalSurrogate()
{
var x = new CStdBaseObject
{
Name = "Alyssa",
Age = 21
};
var c = new CSerializationContext();
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(2, elem.ChildNodes.Count, "Child Node Count is wrong");
Assert.AreEqual(x.Name, XmlExtensions.GetElementValue(elem, "Name"), "Name");
Assert.AreEqual(x.Age.ToString(), XmlExtensions.GetElementValue(elem, "Age"), "Age");
Console.WriteLine(
"\r\n\r\n-----------------------------------------------------------------------------\r\n\r\n");
c.RegisterExternalSurrogate(typeof(CStdBaseObject), new CStdExternalSurrogate());
doc = s.Serialize(x);
Print(doc);
elem = doc.DocumentElement;
Assert.AreEqual(0, elem.ChildNodes.Count, "Child Node Count is wrong");
Assert.AreEqual(x.Name, XmlExtensions.GetAttributeValue(elem, "NAME"), "Name");
Assert.AreEqual(x.Age.ToString(), XmlExtensions.GetAttributeValue(elem, "AGE"), "Age");
}
private void InitializePublicKeyTokens()
{
this._knownPublicKeyTokens = new Dictionary <int, byte[]>();
var keysNode = this.XmlNode.DocumentElement.SelectSingleNode("./vre:PublicKeys", this.XmlNamespaceManager);
if (keysNode != null)
{
var xnlKeys = keysNode.SelectNodes("./vre:PublicKey", this.XmlNamespaceManager);
if (xnlKeys != null && xnlKeys.Count > 0)
{
foreach (XmlElement element in xnlKeys)
{
int id = XmlExtensions.ParseAttribute(element, "Id");
if (id != -1)
{
byte[] token = XmlExtensions.ParseAttribute <byte[]>(element, "Token", (str, def) =>
{
try
{
return(StringHandling.FromFormatHexadecimal(str));
}
catch (Exception e)
{
return(def);
}
}, new byte[0]);
if (token != null && token.Length == 8)
{
this._knownPublicKeyTokens.Add(id, token);
}
}
}
}
}
}
public override IScope Render(IReportContext context, IScope scope, object item)
{
scope = scope ?? context.Scope;
Template = Template ?? XmlExtensions.Load(FileName, BxlParserOptions.ExtractSingle);
Xi = Xi ?? new XmlInterpolation {
UseExtensions = true, XmlIncludeProvider = new XmlIncludeProvider {
Container = _container
}
};
IScope ws = null;
if (null == context)
{
ws = scope;
}
else
{
ws = new Scope(context.Data);
ws["data"] = context.Data;
ws["context"] = context;
ws["scope"] = scope;
ws["item"] = item;
ws["reportcode"] = context.Report.Id;
ws["reportname"] = context.Report.Name;
}
var result = Xi.Interpolate(Template, ws);
RemoveDebugInfo(scope, result);
Finalize(context, scope, result);
return(scope);
}
public void MySerialize(CSerializer _framework, XmlNode _node)
{
XmlExtensions.AddAttribute(_node, "NAME", Name);
XmlExtensions.AddAttribute(_node, "AGE", Age);
STATUS = ETestStatus.IMPLICIT_SERIALIZER_VOID;
}
public void TestNullableType()
{
int?x = null;
var s = new CSerializer();
CSerializationContext.Global.SetVerbose();
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(CSerializationContext.Global.NullAttributeValue,
XmlExtensions.GetAttributeValue(elem, CSerializationContext.Global.NullAttributeName),
"Should be null");
Assert.AreEqual("", elem.InnerText, "Should be no innerText");
PrintLine();
x = 69;
doc = s.Serialize(x);
Print(doc);
elem = doc.DocumentElement;
Assert.AreEqual(x.GetType().AssemblyQualifiedName,
XmlExtensions.GetAttributeValue(elem, CSerializationContext.Global.TypeAttributeName),
"The Type is wrong");
}
public AllocateJobChunkResponse Parse(AllocateJobChunkRequest request, IWebResponse response)
{
using (response)
{
ResponseParseUtilities.HandleStatusCode(response, HttpStatusCode.OK, HttpStatusCode.ServiceUnavailable, HttpStatusCode.NotFound);
using (var responseStream = response.GetResponseStream())
{
switch (response.StatusCode)
{
case HttpStatusCode.OK:
return(AllocateJobChunkResponse.Success(
JobResponseParser <AllocateJobChunkRequest> .ParseObjectList(
XmlExtensions
.ReadDocument(responseStream)
.ElementOrThrow("Objects")
)
));
case HttpStatusCode.ServiceUnavailable:
return(AllocateJobChunkResponse.RetryAfter(TimeSpan.FromSeconds(int.Parse(response.Headers["retry-after"]))));
case HttpStatusCode.NotFound:
return(AllocateJobChunkResponse.ChunkGone);
default:
throw new NotSupportedException(Resources.InvalidEnumValueException);
}
}
}
}
public override void OnApplyTemplate()
{
DebugHelper.AssertUIThread();
base.OnApplyTemplate();
if (this.ViewSettings != null)
{
XElement viewSettingsElement = this.ViewSettings.ViewSettingsElement;
this.IsZoomToFit = XmlExtensions.GetAttribute(viewSettingsElement, "zoomToFit", true);
if (!this.IsZoomToFit)
{
this.Zoom = XmlExtensions.GetAttribute(viewSettingsElement, "zoomLevel", 100);
}
}
this.scrollViewer = GetTemplateChild("PART_ScrollViewer") as ScrollViewer;
if (this.scrollViewer != null)
{
this.scrollViewer.PreviewMouseWheel += (source, e) => this.OnMouseWheel(e);
}
this.scaleTransform = GetTemplateChild("PART_ScaleTransform") as ScaleTransform;
}
public void TestArraySurrogate()
{
var x = new int[] { 1, 3, 5, 7, 9 };
var c = new CSerializationContext();
c.SetConcise();
var helper = new CIntArraySurrogate();
c.RegisterExternalSurrogate(typeof(int[]), helper);
var s = new CSerializer(c);
var doc = s.Serialize(x);
Console.WriteLine("Depth of resulting XML: " + XmlExtensions.Depth(doc));
Console.WriteLine("Length of resulting XML String: " + doc.OuterXml.Length);
Console.WriteLine("Number of resulting XmlElements: " + XmlExtensions.ElementCount(doc));
Print(doc);
var d = new CDeserializer(c);
var y = (int[])d.Deserialize(doc);
Assert.AreEqual(x.Length, y.Length - 1, "Length of resulting array is wrong");
for (var i = 0; i < x.Length; i++)
{
Assert.AreEqual(x[i], y[i], "Invalid element at: " + i);
}
}
public GetJobListResponse Parse(GetJobListRequest request, IWebResponse response)
{
using (response)
{
ResponseParseUtilities.HandleStatusCode(response, HttpStatusCode.OK);
using (var stream = response.GetResponseStream())
{
return(new GetJobListResponse(
jobs: XmlExtensions
.ReadDocument(stream)
.ElementOrThrow("Jobs")
.Elements("Job")
.Select(jobElement => new JobInfo(
jobElement.AttributeText("BucketName"),
jobElement.AttributeText("StartDate"),
Guid.Parse(jobElement.AttributeText("JobId")),
jobElement.AttributeText("Priority"),
jobElement.AttributeText("RequestType"),
ResponseParseUtilities.ParseJobStatus(jobElement.AttributeText("Status"))
))
.ToList()
));
}
}
}
public void TestStringCounter()
{
var x = new CTypeCounter();
var c = new CSerializationContext();
c.SetConcise();
c.RegisterExternalSurrogate(typeof(string), x);
var s = new CSerializer(c);
var doc = s.Serialize(x);
Assert.AreEqual(3, x.Count, "There should have been 3 strings counted.");
Console.WriteLine("Depth of resulting XML: " + XmlExtensions.Depth(doc));
Console.WriteLine("Length of resulting XML String: " + doc.OuterXml.Length);
Console.WriteLine("Number of resulting XmlElements: " + XmlExtensions.ElementCount(doc));
Print(doc);
var d = new CDeserializer(c);
var y = d.Deserialize <CTypeCounter>(doc);
Assert.AreEqual(0, y.Count, "The new object should have no counted strings");
Assert.AreEqual(6, x.Count, "The initial object should have strings counted for 2 actions");
}
public bool Serialize(object _object, Type _useType, XmlElement _parentNode, CSerializer _serializer)
{
var array = (int[])_object;
XmlExtensions.AddAttribute(_parentNode, "MYLEN", array.Length);
return(false);
}
public void TestExternalSurrogate()
{
CBigPerson.GenerateData(100);
var c = new CSerializationContext();
c.SetConcise();
var helper = new CFriendSerializer();
c.RegisterExternalSurrogate(typeof(CFriend), helper);
var s = new CSerializer(c);
var doc = s.Serialize(CBigPerson.People);
Console.WriteLine("Depth of resulting XML: " + XmlExtensions.Depth(doc));
Console.WriteLine("Length of resulting XML String: " + doc.OuterXml.Length);
Console.WriteLine("Number of resulting XmlElements: " + XmlExtensions.ElementCount(doc));
Print(doc);
var d = new CDeserializer(c);
var x2 = d.Deserialize <CBigPerson[]>(doc);
helper.FinishDeserializing(x2);
CDeserializeTest.AssertEqualBigPeopleArray(CBigPerson.People, x2);
}
public static void LoadRepositoryXml(string filePath, ContentManager content)
{
XmlDocument document = new XmlDocument();
document.Load(filePath);
foreach (XmlNode itemNode in document.SelectNodes("ItemRepository/Item"))
{
Item item = new Item();
item.Name = XmlExtensions.GetAttributeValue(itemNode, "Name", null, true);
item.FriendlyName = itemNode.SelectSingleNode("FriendlyName").InnerText;
item.Description = itemNode.SelectSingleNode("Description").InnerText;
item.Weight = XmlExtensions.GetAttributeValue <float>(itemNode, "Weight", 0);
item.ItemType = (ItemType)Enum.Parse(typeof(ItemType), XmlExtensions.GetAttributeValue(itemNode, "ItemType", null, true));
foreach (XmlNode drawableSetNode in itemNode.SelectNodes("Drawables/Drawable"))
{
string src = XmlExtensions.GetAttributeValue(drawableSetNode, "src");
DrawableSet.LoadDrawableSetXml(item.Drawables, src, content);
}
GameItems.Add(item.Name, item);
}
}
/// <summary>
/// 从请求流中反序列化构造参数值
/// </summary>
/// <param name="p"></param>
/// <param name="requst"></param>
/// <returns></returns>
public virtual object FromBodyDeserializeObject(ParameterInfo p, HttpRequest requst)
{
// 从请求流中反序列化对象中，要注意三点：
// 1、忽略参数的名称
// 2、直接使用参数类型，不做可空类型处理
// 3、仅支持 JSON, XML 的数据格式
SerializeFormat format = RequestContentType.GetFormat(requst.ContentType);
if (format == SerializeFormat.Json)
{
string text = requst.GetPostText();
return(JsonExtensions.FromJson(text, p.ParameterType));
}
if (format == SerializeFormat.Xml)
{
string text = requst.GetPostText();
return(XmlExtensions.FromXml(text, p.ParameterType));
}
// 仅仅是需要读取整个请求流字符串，
// 而且目标类型已经是字符串，就没有必要反序列化了，所以就直接以字符串返回
if (p.ParameterType == typeof(string))
{
return(requst.GetPostText());
}
throw new NotSupportedException("[FromBody]标记只能配合 JSON/XML 数据格式来使用。");
}
public void TestSuperclassedArray()
{
var x = new CSuperArray
{
Arr = new int[] { 1, 3, 5 }
};
var s = new CSerializer();
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(typeof(CSuperArray).AssemblyQualifiedName,
XmlExtensions.GetAttributeValue(elem, s.Context.TypeAttributeName),
"Type of the root node is wrong");
var e = (XmlElement)elem.SelectSingleNode("Arr");
Assert.IsNotNull(e, "Missing Arr element");
Assert.AreEqual(x.Arr.GetType().AssemblyQualifiedName,
XmlExtensions.GetAttributeValue(e, s.Context.TypeAttributeName),
"Type Attribute Error");
Assert.AreEqual(x.Arr.Length.ToString(),
XmlExtensions.GetAttributeValue(e, s.Context.ArrayAttributeName),
"Length of Array Attribute is wrong");
Assert.AreEqual("1,3,5", elem.InnerText, "Inner Text for the array");
}
public DeleteObjectListResponse Parse(DeleteObjectListRequest request, IWebResponse response)
{
using (response)
{
ResponseParseUtilities.HandleStatusCode(response, HttpStatusCode.OK);
using (var content = response.GetResponseStream())
{
var deleteResult = XmlExtensions
.ReadDocument(content)
.ElementOrThrow("DeleteResult");
return(new DeleteObjectListResponse(
deletedObjects: deleteResult
.Elements("Deleted")
.Select(el => el.TextOf("Key"))
.ToList(),
deleteErrors: deleteResult
.Elements("Error")
.Select(el => new DeleteDs3ObjectError(
el.TextOf("Key"),
el.TextOf("Code"),
el.TextOf("Message")
))
.ToList()
));
}
}
}
public bool MySerialize(CSerializer _framework, XmlNode _node)
{
XmlExtensions.AddAttribute(_node, "Incomplete", "Yes");
STATUS = ETestStatus.IMPLICIT_SERIALIZER_INCOMPLETE;
return(false);
}
public void TestExternalBaseSurrogate()
{
var x = new CMySuperStd
{
Name = "Alyssa",
Age = 21,
Sex = "Yes"
};
var c = new CSerializationContext();
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(3, elem.ChildNodes.Count, "Child Node Count is wrong");
Assert.AreEqual(x.Name, XmlExtensions.GetElementValue(elem, "Name"), "Name");
Assert.AreEqual(x.Age.ToString(), XmlExtensions.GetElementValue(elem, "Age"), "Age");
Assert.AreEqual(x.Sex, XmlExtensions.GetElementValue(elem, "Sex"), "Sex");
PrintLine();
c.RegisterExternalSurrogate(typeof(CStdBaseObject), new CStdExternalSurrogate());
doc = s.Serialize(x);
Print(doc);
elem = doc.DocumentElement;
Assert.AreEqual(1, elem.ChildNodes.Count, "Child Node Count is wrong");
Assert.AreEqual(x.Name, XmlExtensions.GetAttributeValue(elem, "NAME"), "Name");
Assert.AreEqual(x.Age.ToString(), XmlExtensions.GetAttributeValue(elem, "AGE"), "Age");
Assert.AreEqual(x.Sex, XmlExtensions.GetElementValue(elem, "Sex"), "Sex");
}
Hashtable Transform(RestResponse restResponse)
{
var result = XmlExtensions.ToHash(restResponse.Content);
result[DefensioResult.HttpStatusCodeKey] = restResponse.HttpStatusCode;
return(result);
}
public void SignXml()
{
var path = AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
var dataPath = Path.Combine(path, "Data", "test.xml");
try
{
SetupCertificate();
new XElement(nameof(SignXml)).Save(dataPath);
var xmlDoc = new XmlDocument();
xmlDoc.PreserveWhitespace = true;
xmlDoc.Load(dataPath);
var cert = XmlExtensions.GetCertificate("CN=Gnu.Licensing", StoreName.My, StoreLocation.CurrentUser);
XmlExtensions.SignXml(xmlDoc, cert);
bool result = XmlExtensions.VerifyXmlFile(xmlDoc);
Assert.True(result);
}
finally
{
File.Delete(dataPath);
}
}
public static void Test()
{
var request = new Request
{
SName = "Hi",
Message = new Message
{
AddO = new AddO
{
CaseD = new CaseD {
CaseA = new CaseA {
Value = "Test Value"
}
},
}
}
};
var xml = request.GetXml(XmlExtensions.NoStandardXmlNamespaces(), true);
Debug.WriteLine(xml);
var request2 = xml.LoadFromXML <Request>();
Debug.WriteLine(request2.GetXml(XmlExtensions.NoStandardXmlNamespaces(), true));
Debug.Assert(request.Message.AddO.CaseD.CaseA.Value == request2.Message.AddO.CaseD.CaseA.Value); // No assert.
}
public bool MySerialize(CSerializer _serializer, XmlNode _node)
{
XmlExtensions.AddAttribute(_node, "NAME", Name);
XmlExtensions.AddAttribute(_node, "AGE", Age);
STATUS = ETestStatus.IMPLICIT_SERIALIZER;
return(true);
}
public override void LoadViewState(XElement state)
{
DebugHelper.AssertUIThread();
if (state != null)
{
this.sideBarExpanded = XmlExtensions.GetAttribute(state, "sidebarExpanded", this.sideBarExpanded);
}
}
public ConfigService(SystemResourcesService systemResources)
{
this.systemResources = systemResources;
configPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
dir,
"config.xml");
xmlExtensions = new XmlExtensions(configPath);
oldOptions_ = new OptionsModel();
}
public void TestStripInvalid()
{
Assert.AreEqual(null, XmlExtensions.StripInvalidCharsFromXml(null));
Assert.AreEqual("", "".StripInvalidCharsFromXml());
Assert.AreEqual("<normal>XML!</normal>", "<normal>XML!</normal>".StripInvalidCharsFromXml());
Assert.AreEqual("spaces\tabs\rand\n.~ all OK", "spaces\tabs\rand\n.~ all OK".StripInvalidCharsFromXml());
Assert.AreEqual("now try and or and how about ?", "now try \a and \0 or \v and how about \xFFFF?".StripInvalidCharsFromXml());
Assert.AreEqual("and of course", "\0and\xc of course\0".StripInvalidCharsFromXml());
}
public void DepthTest()
{
var actual = XmlExtensions.Depth(m_xml);
Assert.AreEqual <int>(4, actual, "Depth is not right");
actual = XmlExtensions.Depth(null);
Assert.AreEqual <int>(0, actual, "Null should have zero depth");
}
private void CheckInitialization()
{
if (!this.initialized)
{
initialized = true;
var libraries = XmlExtensions.ParseDictionary <Dictionary <string, IVreLibrary <TEnvironment, TVersion, TIdentityManager> >, string, IVreLibrary <TEnvironment, TVersion, TIdentityManager>, XmlElement>(this.Environment.XmlNode.DocumentElement, this.Environment.XmlNamespaceManager, "Libraries", "Library", GetLibraryFromDetail, keyDetail => keyDetail.Extra.Item2.Name);
base._AddRange(libraries);
}
}
public void GetElementValueTest()
{
var actual = XmlExtensions.GetElementValue(m_xml, "/a/b");
Assert.AreEqual <string>("Bear", actual, "The value of /a/b is wrong");
var shouldBeNull = XmlExtensions.GetElementValue(m_xml, "/a/ff");
Assert.IsNull(shouldBeNull, "Should be null when the element can't be found");
}
/// <summary>
/// Makeerrors the specified r.
/// </summary>
/// <param name="r"> The r. </param>
/// <param name="t"> The t. </param>
/// <param name="ic"> The ic. </param>
/// <param name="desc"> The desc. </param>
/// <param name="error"> The error. </param>
/// <param name="code"> The code. </param>
/// <returns> </returns>
/// <remarks>
/// </remarks>
private bool Makeerror(XNode r, ThemaDescriptor t, string ic, XmlExtensions.XmlElementDescriptor desc, string error,
int code) {
r.Remove();
var message = string.Format("error in uselib resolution in {0}/{1} {2}:{3} - {4}", t.Code, ic, desc.File,
desc.Line,
error);
var ecprefix = "WRLIBR0";
var level = ErrorLevel.Warning;
if (Context.Project.NonResolvedLibraryIsError) {
ecprefix = "ERLIBR0";
level = ErrorLevel.Error;
}
var ecode = ecprefix + code;
AddError(level, message, ecode, null, desc.File, desc.Line);
if (ErrorLevel.Error == level) {
UserLog.Error(message);
}
else {
UserLog.Warn(message);
}
return ErrorLevel.Error == level;
}