public void ReadConstantPool_ConstantCountIsCorrect()
{
var constantPool = ConstantPool.FromReader(_reader);
// Class file has constant pool size of 98, index 0 is reserved, 2 indices are skipped due to large constants.
Assert.Equal(95, constantPool.Constants.Count);
}
public void ReadConstantPool_ClassInfoIsCorrect()
{
var constantPool = ConstantPool.FromReader(_reader);
var constant = (ClassInfo)constantPool.ResolveConstant(2);
Assert.Equal(48, constant.NameIndex);
}
public void ReadConstantPool_MethodTypeInfoIsCorrect()
{
var constantPool = ConstantPool.FromReader(_reader);
var constant = (MethodTypeInfo)constantPool.ResolveConstant(57);
Assert.Equal(33, constant.DescriptorIndex);
}
public void ReadConstantPool_Utf8InfoIsCorrect()
{
var constantPool = ConstantPool.FromReader(_reader);
var constant = (Utf8Info)constantPool.ResolveConstant(15);
Assert.Equal("IntValue", constant.Value);
}
public void ReadConstantPool_FloatInfoIsCorrect()
{
var constantPool = ConstantPool.FromReader(_reader);
var constant = (PrimitiveInfo)constantPool.ResolveConstant(25);
Assert.IsType <float>(constant.Value);
Assert.Equal(42f, constant.Value);
}
public void ReadConstantPool_IntegerInfoIsCorrect()
{
var constantPool = ConstantPool.FromReader(_reader);
var constant = (PrimitiveInfo)constantPool.ResolveConstant(18);
Assert.IsType <int>(constant.Value);
Assert.Equal(42, constant.Value);
}
public void ReadConstantPool_InterfaceMethodRefInfoIsCorrect()
{
var constantPool = ConstantPool.FromReader(_reader);
var constant = (InterfaceMethodRefInfo)constantPool.ResolveConstant(6);
Assert.Equal(52, constant.ClassIndex);
Assert.Equal(53, constant.NameAndTypeIndex);
}
public void ReadConstantPool_MethodRefInfoIsCorrect()
{
var constantPool = ConstantPool.FromReader(_reader);
var constant = (MethodRefInfo)constantPool.ResolveConstant(1);
Assert.Equal(14, constant.ClassIndex);
Assert.Equal(47, constant.NameAndTypeIndex);
}
public void ReadConstantPool_FieldRefInfoIsCorrect()
{
var constantPool = ConstantPool.FromReader(_reader);
var constant = (FieldRefInfo)constantPool.ResolveConstant(11);
Assert.Equal(62, constant.ClassIndex);
Assert.Equal(63, constant.NameAndTypeIndex);
}
public void ReadConstantPool_InvokeDynamicInfoIsCorrect()
{
var constantPool = ConstantPool.FromReader(_reader);
var constant = (InvokeDynamicInfo)constantPool.ResolveConstant(8);
Assert.Equal(59, constant.NameAndTypeIndex);
Assert.Equal(0, constant.BootstrapMethodIndex);
}
public void ReadConstantPool_MethodHandleInfoIsCorrect()
{
var constantPool = ConstantPool.FromReader(_reader);
var constant = (MethodHandleInfo)constantPool.ResolveConstant(56);
Assert.Equal(MethodReferenceKind.InvokeStatic, constant.ReferenceKind);
Assert.Equal(74, constant.ReferenceIndex);
}
public void ReadConstantPool_DoubleInfoIsCorrect()
{
var constantPool = ConstantPool.FromReader(_reader);
var constant = (PrimitiveInfo)constantPool.ResolveConstant(28);
Assert.IsType <double>(constant.Value);
Assert.Equal(42d, constant.Value);
}
public void ReadConstantPool_LongInfoIsCorrect()
{
var constantPool = ConstantPool.FromReader(_reader);
var constant = (PrimitiveInfo)constantPool.ResolveConstant(21);
Assert.IsType <long>(constant.Value);
Assert.Equal(42L, constant.Value);
}
public void ReadConstantPool_ConstantsHaveProperIndices()
{
var constantPool = ConstantPool.FromReader(_reader);
// A constant before large pool entries where indices are sequential.
var constant1 = constantPool.ResolveString(15);
// A constant after large pool entries, with indices skipped.
var constant2 = constantPool.ResolveString(30);
Assert.Equal("IntValue", constant1);
Assert.Equal("StringValue", constant2);
}
/// <summary>
/// Parses a class file from a binary reader.
/// </summary>
/// <param name="reader">The reader to read from.</param>
/// <returns>The parsed class file.</returns>
/// <exception cref="BadImageFormatException">Occurs when the file does not provide a valid signature of
/// a class file.</exception>
public static JavaClassFile FromReader(IBigEndianReader reader)
{
uint magic = reader.ReadUInt32();
if (magic != Magic)
{
throw new BadImageFormatException("Image does not contain a valid class file.");
}
var file = new JavaClassFile
{
MinorVersion = reader.ReadUInt16(),
MajorVersion = reader.ReadUInt16(),
ConstantPool = ConstantPool.FromReader(reader),
AccessFlags = (ClassAccessFlags)reader.ReadUInt16(),
ThisClass = reader.ReadUInt16(),
SuperClass = reader.ReadUInt16(),
};
ushort interfaceCount = reader.ReadUInt16();
for (int i = 0; i < interfaceCount; i++)
{
file.Interfaces.Add(reader.ReadUInt16());
}
ushort fieldCount = reader.ReadUInt16();
for (int i = 0; i < fieldCount; i++)
{
file.Fields.Add(FieldInfo.FromReader(reader));
}
ushort methodCount = reader.ReadUInt16();
for (int i = 0; i < methodCount; i++)
{
file.Methods.Add(MethodInfo.FromReader(reader));
}
ushort attributeCount = reader.ReadUInt16();
for (int i = 0; i < attributeCount; i++)
{
file.Attributes.Add(AttributeInfo.FromReader(reader));
}
return(file);
}
public void WriteConstantPool_ByteAreEqual()
{
var constantPool = ConstantPool.FromReader(_reader);
var stream = new MemoryStream();
var writingContext = new WritingContext(new BigEndianStreamWriter(stream));
constantPool.Write(writingContext);
var constantPoolLength = (int)_reader.Position - ConstantPoolOffset;
Assert.Equal(constantPoolLength, stream.Length);
Assert.Equal(
new ArraySegment <byte>(Resources.ConstantPoolExample, ConstantPoolOffset, constantPoolLength),
new ArraySegment <byte>(stream.ToArray()));
}
