protected override IList <IStructuralNode> CreateChildNodes()
{
var data = _provider.Data;
var offset = _provider.MetaDataOffset;
var length = data.Read <int>(offset + 12);
var headerTemplate = new CompoundNodeTemplate()
{
{ "Signature", StandardTemplates.UInt32 },
{ "Major Version", StandardTemplates.UInt16 },
{ "Minor Version", StandardTemplates.UInt16 },
{ "Reserved", StandardTemplates.UInt32 },
{ "Length", StandardTemplates.UInt32 },
{ "Version", StandardTemplates.Text(length, Encoding.UTF8) },
{ "Flags", StandardTemplates.UInt16 },
{ "Streams", StandardTemplates.UInt16 },
};
return(new IStructuralNode[]
{
new TemplatedStructuralNode(_provider.Data, this, "Header", headerTemplate, _provider.MetaDataOffset),
new StreamHeaderListNode(_provider, this),
new StreamListNode(_provider, this),
});
}
public void PositionOverride()
{
var mockChild1 = new Mock <IStructuralNodeTemplate>(MockBehavior.Strict);
mockChild1.Setup(x => x.Width).Returns(4);
var mockChild2 = new Mock <IStructuralNodeTemplate>(MockBehavior.Strict);
mockChild2.Setup(x => x.Width).Returns(2);
var mockChild3 = new Mock <IStructuralNodeTemplate>(MockBehavior.Strict);
mockChild3.Setup(x => x.Width).Returns(2);
var template = new CompoundNodeTemplate()
{
{ "A", mockChild1.Object },
{ PositionMode.RelativeToParent, 16, "B", mockChild2.Object },
{ PositionMode.RelativeToLast, 2, "C", mockChild3.Object },
};
Assert.That(template.Width, Is.EqualTo(22));
Assert.That(template.Components.Select(x => x.Name), Is.EqualTo(new[] { "A", "B", "C" }));
Assert.That(template.Components.Select(x => x.Offset), Is.EqualTo(new[] { 0, 16, 20 }));
Assert.That(template.Components.Select(x => x.Template), Is.EqualTo(new[] { mockChild1.Object, mockChild2.Object, mockChild3.Object }));
}
IStructuralNodeTemplate CreateTableListNode(MetaDataTableCodes[] codes, HeapSizeFlags heapSizes)
{
var tables = new CompoundNodeTemplate();
var statistics = new MetaDataTableStatistics(GetRowCounts(codes), heapSizes);
for (var i = 0; i < codes.Length; i++)
{
var code = codes[i];
var rowCount = statistics.GetRowCount(code);
if (rowCount <= 0)
{
continue;
}
var rowTemplate = CreateRowTemplate(statistics, code);
if (rowTemplate == null)
{
tables.Add(code + " Not Yet Implemented", StandardTemplates.UInt8);
return(tables);
}
tables.Add(code.ToString(), new RepeatingNodeTemplate(rowTemplate, rowCount, GetMetaDataTokenFormatter(code)));
}
return(tables);
}
public void Children()
{
var mockChild1 = new Mock <IStructuralNodeTemplate>(MockBehavior.Strict);
mockChild1.Setup(x => x.Width).Returns(4);
var mockChild2 = new Mock <IStructuralNodeTemplate>(MockBehavior.Strict);
mockChild2.Setup(x => x.Width).Returns(2);
var mockChild3 = new Mock <IStructuralNodeTemplate>(MockBehavior.Strict);
mockChild3.Setup(x => x.Width).Returns(2);
var template = new CompoundNodeTemplate()
{
{ "A", mockChild1.Object },
{ "B", mockChild2.Object },
{ "C", mockChild3.Object },
};
Assert.That(template.Width, Is.EqualTo(8));
Assert.That(template.Components.Select(x => x.Name), Is.EqualTo(new[] { "A", "B", "C" }));
Assert.That(template.Components.Select(x => x.Offset), Is.EqualTo(new[] { 0, 4, 6 }));
Assert.That(template.Components.Select(x => x.Template), Is.EqualTo(new[] { mockChild1.Object, mockChild2.Object, mockChild3.Object }));
}
static IStructuralNodeTemplate CreateRowHeader(MetaDataTableCodes[] codes)
{
var result = new CompoundNodeTemplate();
for (var i = 0; i < codes.Length; i++)
{
result.Add(codes[i].ToString(), StandardTemplates.UInt32);
}
return(result);
}
protected override IStructuralNode CreateChildNode(int index)
{
var pair = _provider.StreamHeaderOffsets[index];
var nameLen = pair.Key.Length;
var stringBytes = nameLen < 32 ? nameLen + 1 : 32;
var template = new CompoundNodeTemplate()
{
{ "Offset", StandardTemplates.UInt32 },
{ "Size", StandardTemplates.UInt32 },
{ "Name", StandardTemplates.Text(stringBytes, Encoding.ASCII) },
};
template.RoundWidthUpToBoundary(4);
return(new TemplatedStructuralNode(_provider.Data, this, pair.Key, template, _provider.MetaDataOffset + pair.Value));
}
public void GetValue()
{
var mockData = new Mock <IDataSource>(MockBehavior.Strict);
var mockChild = new Mock <IStructuralNodeTemplate>(MockBehavior.Strict);
mockChild.Setup(x => x.Width).Returns(1);
var template = new CompoundNodeTemplate()
{
{ "A", mockChild.Object },
};
template.OverrideWidth(4);
Assert.That(template.GetValue(mockData.Object, 100), Is.Null);
}
public void OverrideWidth()
{
var mockChild1 = new Mock <IStructuralNodeTemplate>(MockBehavior.Strict);
mockChild1.Setup(x => x.Width).Returns(1);
var template = new CompoundNodeTemplate()
{
{ "A", mockChild1.Object },
};
template.OverrideWidth(4);
Assert.That(template.Width, Is.EqualTo(4));
Assert.That(template.Components.Select(x => x.Name), Is.EqualTo(new[] { "A" }));
Assert.That(template.Components.Select(x => x.Offset), Is.EqualTo(new[] { 0 }));
Assert.That(template.Components.Select(x => x.Template), Is.EqualTo(new[] { mockChild1.Object }));
}
public void RoundToMultiple()
{
var mockChild1 = new Mock <IStructuralNodeTemplate>(MockBehavior.Strict);
mockChild1.Setup(x => x.Width).Returns(1);
var mockChild2 = new Mock <IStructuralNodeTemplate>(MockBehavior.Strict);
mockChild2.Setup(x => x.Width).Returns(4);
var template = new CompoundNodeTemplate()
{
{ "A", mockChild1.Object },
{ "B", mockChild2.Object },
};
template.RoundWidthUpToBoundary(4);
Assert.That(template.Width, Is.EqualTo(8));
Assert.That(template.Components.Select(x => x.Name), Is.EqualTo(new[] { "A", "B" }));
Assert.That(template.Components.Select(x => x.Offset), Is.EqualTo(new[] { 0, 1 }));
Assert.That(template.Components.Select(x => x.Template), Is.EqualTo(new[] { mockChild1.Object, mockChild2.Object }));
}
