public string ToString01([PexAssumeUnderTest] ExportFunction target)
{
var result = target.ToString();
return(result);
// TODO: add assertions to method ExportFunctionTest.ToString01(ExportFunction)
}
static void CreateExportPlan(GameObject go,
SampleBase sample,
ExportFunction exportFunc,
ExportContext context,
string pathSuffix = null,
object data = null,
bool insertFirst = true) {
// This is an exportable object.
Transform expRoot = context.exportRoot;
string path = UnityTypeConverter.GetPath(go.transform, expRoot);
if (!string.IsNullOrEmpty(pathSuffix)) {
path += pathSuffix;
}
if (!context.plans.ContainsKey(go)) {
context.plans.Add(go, new ExportPlan());
}
var exp = new Exporter { exportFunc = exportFunc, sample = sample, path = path, data = data };
if (insertFirst) {
context.plans[go].exporters.Insert(0, exp);
} else {
context.plans[go].exporters.Add(exp);
}
// Include the parent xform hierarchy.
// Note that the parent hierarchy is memoised, so despite looking expensive, the time
// complexity is linear.
Transform xf = go.transform.parent;
if (xf != context.exportRoot && !context.plans.ContainsKey(xf.gameObject)) {
// Since all GameObjects have a Transform, export all un-exported parents as transform.
CreateExportPlan(xf.gameObject, CreateSample<XformSample>(context), XformExporter.ExportXform, context);
CreateExportPlan(xf.gameObject, CreateSample<XformSample>(context), NativeExporter.ExportObject, context, insertFirst: false);
}
}
protected override ExportFunction[] ParseTarget()
{
if (_exportDirectory == null || _exportDirectory.AddressOfFunctions == 0)
{
return(null);
}
var expFuncs = new ExportFunction[_exportDirectory.NumberOfFunctions];
var funcOffsetPointer = _exportDirectory.AddressOfFunctions.RVAtoFileMapping(_sectionHeaders);
var ordOffset = _exportDirectory.NumberOfNames == 0 ? 0 : _exportDirectory.AddressOfNameOrdinals.RVAtoFileMapping(_sectionHeaders);
var nameOffsetPointer = _exportDirectory.NumberOfNames == 0 ? 0 : _exportDirectory.AddressOfNames.RVAtoFileMapping(_sectionHeaders);
//Get addresses
for (uint i = 0; i < expFuncs.Length; i++)
{
var address = Buff.BytesToUInt32(funcOffsetPointer + sizeof(uint) * i);
expFuncs[i] = new ExportFunction(null, address);
}
//Associate names
for (uint i = 0; i < _exportDirectory.NumberOfNames; i++)
{
var namePtr = Buff.BytesToUInt32(nameOffsetPointer + sizeof(uint) * i);
var nameAdr = namePtr.RVAtoFileMapping(_sectionHeaders);
var name = Buff.GetCString(nameAdr);
var ordinalIndex = Buff.GetOrdinal(ordOffset + sizeof(ushort) * i);
expFuncs[ordinalIndex].Name = name;
}
return(expFuncs);
}
public ExportFunction Constructor(
string name,
uint address,
ushort ordinal
)
{
var target = new ExportFunction(name, address, ordinal);
return target;
// TODO: add assertions to method ExportFunctionTest.Constructor(String, UInt32, UInt16)
}
public ExportFunction Constructor(
string name,
uint address,
ushort ordinal
)
{
var target = new ExportFunction(name, address, ordinal);
return(target);
// TODO: add assertions to method ExportFunctionTest.Constructor(String, UInt32, UInt16)
}
public oTabExportFunction(oTabManager parent, ToolStrip toolStrip, Panel panelMain, ToolStrip mainToolStrip,
string tabTitle, oFunction function)
: base(parent, toolStrip, panelMain, mainToolStrip, tabTitle)
{
ExportFunction exportFunction = new ExportFunction(function)
{
Dock = DockStyle.Fill
};
workingPage.Controls.Add(exportFunction);
}
protected override ExportFunction[] ParseTarget()
{
if (_exportDirectory == null || _exportDirectory.AddressOfFunctions == 0)
{
return(null);
}
var expFuncs = new ExportFunction[_exportDirectory.NumberOfFunctions];
var funcOffsetPointer = _exportDirectory.AddressOfFunctions.RVAtoFileMapping(_sectionHeaders);
var ordOffset = _exportDirectory.AddressOfNameOrdinals.RVAtoFileMapping(_sectionHeaders);
var nameOffsetPointer = _exportDirectory.AddressOfNames.RVAtoFileMapping(_sectionHeaders);
//Get addresses
for (uint i = 0; i < expFuncs.Length; i++)
{
var ordinal = i + _exportDirectory.Base;
var address = _buff.BytesToUInt32(funcOffsetPointer + sizeof(uint) * i);
expFuncs[i] = new ExportFunction(null, address, (ushort)ordinal);
}
//Associate names
for (uint i = 0; i < _exportDirectory.NumberOfNames; i++)
{
var namePtr = _buff.BytesToUInt32(nameOffsetPointer + sizeof(uint) * i);
var nameAdr = namePtr.RVAtoFileMapping(_sectionHeaders);
var name = _buff.GetCString(nameAdr);
var ordinalIndex = (uint)_buff.GetOrdinal(ordOffset + sizeof(ushort) * i);
if (IsForwardedExport(expFuncs[ordinalIndex].Address))
{
var forwardNameAdr = expFuncs[ordinalIndex].Address.RVAtoFileMapping(_sectionHeaders);
var forwardName = _buff.GetCString(forwardNameAdr);
expFuncs[ordinalIndex] = new ExportFunction(
name,
expFuncs[ordinalIndex].Address,
expFuncs[ordinalIndex].Ordinal,
forwardName);
}
else
{
expFuncs[ordinalIndex] = new ExportFunction(
name,
expFuncs[ordinalIndex].Address,
expFuncs[ordinalIndex].Ordinal);
}
}
return(expFuncs);
}
public void ToString01606()
{
string s;
ExportFunction s0 = new ExportFunction((string)null, 0u, (ushort)0);
s = this.ToString01(s0);
Assert.AreEqual <string>
("ExportFunction\nName :\t \nAddress :\t 0\nOrdinal :\t 0\n",
s);
Assert.IsNotNull((object)s0);
Assert.AreEqual <string>((string)null, s0.Name);
Assert.AreEqual <uint>(0u, s0.Address);
Assert.AreEqual <ushort>((ushort)0, s0.Ordinal);
}
void InitExportableObjects(GameObject go)
{
SampleBase sample = null;
ExportFunction exportFunc = null;
if (go.GetComponent <MeshFilter>() != null && go.GetComponent <MeshRenderer>() != null)
{
sample = new MeshSample();
exportFunc = ExportMesh;
foreach (var mat in go.GetComponent <MeshRenderer>().materials)
{
if (!m_materialMap.ContainsKey(mat))
{
string usdPath = "/World/Materials/" + pxr.UsdCs.TfMakeValidIdentifier(mat.name);
m_materialMap.Add(mat, usdPath);
}
}
}
else if (go.GetComponent <Camera>())
{
sample = new CameraSample();
exportFunc = ExportCamera;
}
else
{
return;
}
// This is an exportable object.
string path = Unity.UnityTypeConverter.GetPath(go.transform);
m_primMap.Add(go, new ExportPlan {
path = path, sample = sample, exportFunc = exportFunc
});
Debug.Log(path + " " + sample.GetType().Name);
// Include the parent xform hierarchy.
// Note that the parent hierarchy is memoised, so despite looking expensive, the time
// complexity is linear.
Transform xf = go.transform.parent;
while (xf)
{
if (!InitExportableParents(xf.gameObject))
{
break;
}
xf = xf.parent;
}
}
internal override IEnumerable <Element> GetElements()
{
// ****************************************************************
List <ExportFunction> functions = new List <ExportFunction>(m_functions.Values);
functions.Sort();
ElementCollection content = new ElementCollection();
ElementCollection header = content.ElementCollection();
ElementCollection functionAddresses = content.ElementCollection();
ElementCollection functionNames = content.ElementCollection();
ElementCollection functionOrdinals = content.ElementCollection();
ElementCollection names = content.ElementCollection();
header.UInt32(0); // Export flags
header.UInt32(0); // date
header.UInt16(0); // major version
header.UInt16(0); // minor version
header.RelativeMemoryAddress32(m_moduleNameElement); // module name
header.UInt32(1); // ordinal base
header.UInt32((UInt32)functions.Count); // address table entries
header.UInt32((UInt32)functions.Count); // number of name pointers
header.RelativeMemoryAddress32(functionAddresses); // function addresses
header.RelativeMemoryAddress32(functionNames); // function names
header.RelativeMemoryAddress32(functionOrdinals); // function ordinals
// Module name
names.Elements.Add(m_moduleNameElement);
for (int i = 0; i < functions.Count; i++)
{
ExportFunction function = functions[i];
functionAddresses.RelativeMemoryAddress32(function.Function);
functionNames.RelativeMemoryAddress32(function.NameElement);
functionOrdinals.UInt16((UInt16)i);
names.Elements.Add(function.NameElement);
}
return(content.Elements);
}
private RemoteFunction ExportToRemote(ExportFunction func)
{
return(new RemoteFunction(m_Process, BaseAddress + func.RelativeAddress, func.Name));
}
public string ExportToExcel(string serverCName, string startDate, string endDate)
{
var multipleServer = new List <string>();
var queryResults = new Dictionary <string, IOrderedEnumerable <SummarizedDataDto> >();
var returnList = new List <ExpandoObject>();
if (serverCName.Contains(","))
{
multipleServer.AddRange(serverCName.Split(','));
}
else
{
multipleServer.Add(serverCName);
}
foreach (var server in multipleServer)
{
var serverResults = summarizedDataService.GetQueryResult(server, Convert.ToDateTime(startDate), Convert.ToDateTime(endDate)).OrderBy(s => s.HourCategory);
queryResults.Add(server, serverResults);
}
var rows = new Dictionary <string, List <string> >();
var ExcelFile = string.Empty;
var exportProvinceData = new List <List <List <string> > >();
var exportIspData = new List <List <List <string> > >();
var exportHighestData = new List <List <List <string> > >();
var exportOver3Data = new List <List <List <string> > >();
var exportOver5Data = new List <List <List <string> > >();
var exportOver10Data = new List <List <List <string> > >();
var exportTestData = new List <List <List <string> > >();
foreach (var x in queryResults)
{
var provinceData = this.ProvinceIspResult(x.Value);
var ispData = this.IspResult(x.Value);
var highestData = this.HighestResponseResults(x.Value);
var over3Data = this.CountOver3Results(x.Value);
var over5Data = this.CountOver5Results(x.Value);
var over10Data = this.CountOver10Results(x.Value);
var totalTest = this.TotalTest(x.Value);
exportProvinceData.Add(provinceData);
exportIspData.Add(ispData);
exportHighestData.Add(highestData);
exportOver3Data.Add(over3Data);
exportOver5Data.Add(over5Data);
exportOver10Data.Add(over10Data);
exportTestData.Add(totalTest);
}
var exportData = new List <List <List <List <string> > > >
{
exportProvinceData,
exportIspData,
exportHighestData,
exportOver3Data,
exportOver5Data,
exportOver10Data,
exportTestData
};
ExportFunction _documentExport = new ExportFunction();
ExcelFile = _documentExport.ExcelExportFunction(serverCName, exportData);
return(JsonConvert.SerializeObject(new { filedownload = ExcelFile }));
//return ExcelFile;
}
public Export(ExportFunction fce)
: this(fce.Name, fce.Address)
{
}
