void doGenerateTest(string source, string output, string[] exts)
{
Tuple <List <Size>, List <Size> > expected = null;
var pdf = "dvi2pdf.pdf";
using (var fs = new StreamWriter(Path.Combine(WorkDir, testfile + ".tex"))) {
fs.Write(source);
}
using (converter = new Converter(controller, Path.Combine(WorkDir, testfile + ".tex"), Path.Combine(OutputDir, testfile + "-" + output + ".pdf"))) {
tex2dvi_test(testfile + ".tex");
dvi2pdf_test(testfile + ".dvi");
var pageref = new ByRefType(typeof(int));
var versionref = new ByRefType(typeof(int));
CallMethod(converter, "pdfinfo", Path.Combine(OutputDir, pdf), pageref, versionref);
int page = (int)pageref.val, version = (int)versionref.val;
if (Settings.Default.keepPageSize)
{
expected = new Tuple <List <Size>, List <Size> >(
GetPDFBox(pdf, Enumerable.Range(1, page).ToList(), false),
GetPDFBox(pdf, Enumerable.Range(1, page).ToList(), true));
}
else
{
expected = new Tuple <List <Size>, List <Size> >(
GetPDFBB(pdf, 1, page, false),
GetPDFBB(pdf, 1, page, true));
}
File.Delete(Path.Combine(WorkDir, pdf));
File.Move(Path.Combine(OutputDir, pdf), Path.Combine(WorkDir, pdf));
}
foreach (var ext in exts)
{
File.Copy(Path.Combine(WorkDir, pdf), Path.Combine(WorkDir, testfile + ".pdf"), true);
using (converter = new Converter(controller, Path.Combine(WorkDir, testfile + ".pdf"), Path.Combine(OutputDir, testfile + "-" + output + ext))) {
converter.Convert();
if (expected.Item1.Count == 1 || Settings.Default.mergeOutputFiles)
{
Assert.IsTrue(File.Exists(Path.Combine(OutputDir, testfile + "-" + output + ext)));
}
else
{
bool widthpos = (Settings.Default.leftMargin + Settings.Default.rightMargin > 0);
bool heightpos = (Settings.Default.topMargin + Settings.Default.bottomMargin > 0);
for (int i = 0; i < expected.Item1.Count; ++i)
{
if ((expected.Item1[i].width != 0 || widthpos) && (expected.Item1[i].height != 0 || heightpos))
{
Assert.IsTrue(File.Exists(Path.Combine(OutputDir, testfile + "-" + output + "-" + (i + 1).ToString() + ext)));
}
else
{
Assert.IsFalse(File.Exists(Path.Combine(OutputDir, testfile + "-" + output + "-" + (i + 1).ToString() + ext)));
}
}
}
}
}
File.Delete(Path.Combine(WorkDir, pdf));
}
public static bool Equals(TypeDesc type1, TypeDesc type2)
{
if (type1 == type2)
{
return(true);
}
if (type1 == null || type2 == null)
{
return(false);
}
RuntimeDeterminedType runtimeDeterminedType1 = type1 as RuntimeDeterminedType;
RuntimeDeterminedType runtimeDeterminedType2 = type2 as RuntimeDeterminedType;
if (runtimeDeterminedType1 != null || runtimeDeterminedType2 != null)
{
if (runtimeDeterminedType1 == null || runtimeDeterminedType2 == null)
{
return(false);
}
return(runtimeDeterminedType1.RuntimeDeterminedDetailsType.Index == runtimeDeterminedType2.RuntimeDeterminedDetailsType.Index &&
runtimeDeterminedType1.RuntimeDeterminedDetailsType.Kind == runtimeDeterminedType2.RuntimeDeterminedDetailsType.Kind);
}
ArrayType arrayType1 = type1 as ArrayType;
ArrayType arrayType2 = type2 as ArrayType;
if (arrayType1 != null || arrayType2 != null)
{
if (arrayType1 == null || arrayType2 == null)
{
return(false);
}
return(arrayType1.Rank == arrayType2.Rank &&
arrayType1.IsSzArray == arrayType2.IsSzArray &&
Equals(arrayType1.ElementType, arrayType2.ElementType));
}
ByRefType byRefType1 = type1 as ByRefType;
ByRefType byRefType2 = type2 as ByRefType;
if (byRefType1 != null || byRefType2 != null)
{
if (byRefType1 == null || byRefType2 == null)
{
return(false);
}
return(Equals(byRefType1.ParameterType, byRefType2.ParameterType));
}
if (type1.GetTypeDefinition() != type2.GetTypeDefinition() ||
!Equals(type1.Instantiation, type2.Instantiation))
{
return(false);
}
return(true);
}
protected bool IsMethodSignatureSupportedInReflectionInvoke(MethodDesc method)
{
var signature = method.Signature;
for (int i = 0; i < signature.Length; i++)
{
if (signature[i].IsByRef && ((ByRefType)signature[i]).ParameterType.IsPointer)
{
return(false);
}
}
// ----------------------------------------------------------------
// TODO: function pointer types are odd: https://github.com/dotnet/corert/issues/1929
// ----------------------------------------------------------------
if (signature.ReturnType.IsFunctionPointer)
{
return(false);
}
for (int i = 0; i < signature.Length; i++)
{
if (signature[i].IsFunctionPointer)
{
return(false);
}
}
// ----------------------------------------------------------------
// Methods with ByRef returns can't be reflection invoked
// ----------------------------------------------------------------
if (signature.ReturnType.IsByRef)
{
return(false);
}
// ----------------------------------------------------------------
// Methods that return ByRef-like types or take them by reference can't be reflection invoked
// ----------------------------------------------------------------
if (signature.ReturnType.IsByRefLike)
{
return(false);
}
for (int i = 0; i < signature.Length; i++)
{
ByRefType paramType = signature[i] as ByRefType;
if (paramType != null && paramType.ParameterType.IsByRefLike)
{
return(false);
}
}
return(true);
}
public void SetUp()
{
var customAttributes = new[] { CustomAttributeDeclarationObjectMother.Create() };
_elementType = CustomTypeObjectMother.Create(
name: "Abc", @namespace: "MyNs", typeArguments: new[] { typeof(int) }, customAttributeDatas: customAttributes);
_type = new ByRefType(_elementType);
}
public static bool SupportsSignature(MethodSignature signature)
{
for (int i = 0; i < signature.Length; i++)
{
if (signature[i].IsByRef && ((ByRefType)signature[i]).ParameterType.IsPointer)
{
return(false);
}
}
// ----------------------------------------------------------------
// TODO: function pointer types are odd: https://github.com/dotnet/corert/issues/1929
// ----------------------------------------------------------------
if (signature.ReturnType.IsFunctionPointer)
{
return(false);
}
for (int i = 0; i < signature.Length; i++)
{
if (signature[i].IsFunctionPointer)
{
return(false);
}
}
// ----------------------------------------------------------------
// Methods with ByRef returns can't be reflection invoked
// ----------------------------------------------------------------
if (signature.ReturnType.IsByRef)
{
return(false);
}
// ----------------------------------------------------------------
// Methods that return ByRef-like types or take them by reference can't be reflection invoked
// ----------------------------------------------------------------
if (!signature.ReturnType.IsSignatureVariable && signature.ReturnType.IsByRefLike)
{
return(false);
}
for (int i = 0; i < signature.Length; i++)
{
ByRefType paramType = signature[i] as ByRefType;
if (paramType != null && !paramType.ParameterType.IsSignatureVariable && paramType.ParameterType.IsByRefLike)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Marshals a ByRef. Expects the ByRef on the stack. Pushes a pinned
/// unmanaged pointer to the stack.
/// </summary>
/// <returns>Type the ByRef was marshalled into.</returns>
private TypeDesc EmitByRefMarshalling(ByRefType byRefType)
{
ILLocalVariable vPinnedByRef = _emitter.NewLocal(byRefType, true);
_marshallingCodeStream.EmitStLoc(vPinnedByRef);
_marshallingCodeStream.EmitLdLoc(vPinnedByRef);
_marshallingCodeStream.Emit(ILOpcode.conv_i);
return(_context.GetWellKnownType(WellKnownType.IntPtr));
}
void pdfpages_test(string file)
{
Debug.WriteLine("TEST: pdfpages");
var pageref = new ByRefType(typeof(int));
var versionref = new ByRefType(typeof(int));
CallMethod(converter, "pdfinfo", file, pageref, versionref);
int page = (int)pageref.val, version = (int)versionref.val;
System.Diagnostics.Debug.WriteLine("pdfinfo: page = " + page.ToString() + ", version = " + version.ToString());
using (var fs = new StreamWriter(Path.Combine(OutputDir, "pdfpages.txt"))) {
fs.WriteLine(page.ToString());
}
}
/// <summary>
/// Marshals a ByRef. Expects the ByRef on the stack. Pushes a pinned
/// unmanaged pointer to the stack.
/// </summary>
/// <returns>Type the ByRef was marshalled into.</returns>
private TypeDesc EmitByRefMarshalling(ByRefType byRefType)
{
if (!IsSimpleType(byRefType.ParameterType) && !IsBlittableStruct(byRefType.ParameterType))
{
throw new NotSupportedException();
}
int vPinnedByRef = _emitter.NewLocal(byRefType, true);
_marshallingCodeStream.EmitStLoc(vPinnedByRef);
_marshallingCodeStream.EmitLdLoc(vPinnedByRef);
_marshallingCodeStream.Emit(ILOpcode.conv_i);
return(byRefType.Context.GetWellKnownType(WellKnownType.IntPtr));
}
Tuple <List <Size>, List <Size> > GetExpectedSize(string source)
{
tex2dvi_test(source);
dvi2pdf_test(Path.ChangeExtension(source, ".dvi"));
var pdf = "dvi2pdf.pdf";
var pageref = new ByRefType(typeof(int));
var versionref = new ByRefType(typeof(int));
CallMethod(converter, "pdfinfo", Path.Combine(OutputDir, pdf), pageref, versionref);
int page = (int)pageref.val, version = (int)versionref.val;
if (Settings.Default.keepPageSize)
{
return(new Tuple <List <Size>, List <Size> >(
GetPDFBox(pdf, Enumerable.Range(1, page).ToList(), false),
GetPDFBox(pdf, Enumerable.Range(1, page).ToList(), true)));
}
else
{
return(new Tuple <List <Size>, List <Size> >(
GetPDFBB(pdf, 1, page, false),
GetPDFBB(pdf, 1, page, true)));
}
}
//
// Lazily parse the method signature, and construct the call converter data
//
private void EnsureCallConversionInfoLoaded()
{
if (_signatureParsed)
{
return;
}
lock (this)
{
// Check if race was won by another thread and the signature got parsed
if (_signatureParsed)
{
return;
}
TypeSystemContext context = TypeSystemContextFactory.Create();
{
Instantiation typeInstantiation = Instantiation.Empty;
Instantiation methodInstantiation = Instantiation.Empty;
if (_typeArgs != null && _typeArgs.Length > 0)
{
typeInstantiation = context.ResolveRuntimeTypeHandles(_typeArgs);
}
if (_methodArgs != null && _methodArgs.Length > 0)
{
methodInstantiation = context.ResolveRuntimeTypeHandles(_methodArgs);
}
bool hasThis;
TypeDesc[] parameters;
bool[] paramsByRefForced;
if (!TypeLoaderEnvironment.Instance.GetCallingConverterDataFromMethodSignature(context, _methodSignature, typeInstantiation, methodInstantiation, out hasThis, out parameters, out paramsByRefForced))
{
Debug.Assert(false);
Environment.FailFast("Failed to get type handles for parameters in method signature");
}
Debug.Assert(parameters != null && parameters.Length >= 1);
bool[] byRefParameters = new bool[parameters.Length];
RuntimeTypeHandle[] parameterHandles = new RuntimeTypeHandle[parameters.Length];
for (int j = 0; j < parameters.Length; j++)
{
ByRefType parameterAsByRefType = parameters[j] as ByRefType;
if (parameterAsByRefType != null)
{
parameterAsByRefType.ParameterType.RetrieveRuntimeTypeHandleIfPossible();
parameterHandles[j] = parameterAsByRefType.ParameterType.RuntimeTypeHandle;
byRefParameters[j] = true;
}
else
{
parameters[j].RetrieveRuntimeTypeHandleIfPossible();
parameterHandles[j] = parameters[j].RuntimeTypeHandle;
byRefParameters[j] = false;
}
Debug.Assert(!parameterHandles[j].IsNull());
}
// Build thunk data
TypeHandle thReturnType = new TypeHandle(CallConverterThunk.GetByRefIndicatorAtIndex(0, byRefParameters), parameterHandles[0]);
TypeHandle[] thParameters = null;
if (parameters.Length > 1)
{
thParameters = new TypeHandle[parameters.Length - 1];
for (int i = 1; i < parameters.Length; i++)
{
thParameters[i - 1] = new TypeHandle(CallConverterThunk.GetByRefIndicatorAtIndex(i, byRefParameters), parameterHandles[i]);
}
}
_argIteratorData = new ArgIteratorData(hasThis, false, thParameters, thReturnType);
// StandardToStandard thunks don't actually need any parameters to change their ABI
// so don't force any params to be adjusted
if (!StandardToStandardThunk)
{
_paramsByRefForced = paramsByRefForced;
}
}
TypeSystemContextFactory.Recycle(context);
_signatureParsed = true;
}
}
public override void AppendName(StringBuilder sb, ByRefType type)
{
AppendNameWithValueClassPrefix(sb, type.ParameterType);
sb.Append('&');
}
void pdfpages_test(string file) {
Debug.WriteLine("TEST: pdfpages");
var pageref = new ByRefType(typeof(int));
var versionref = new ByRefType(typeof(int));
CallMethod(converter, "pdfinfo", file, pageref, versionref);
int page = (int)pageref.val, version = (int)versionref.val;
System.Diagnostics.Debug.WriteLine("pdfinfo: page = " + page.ToString() + ", version = " + version.ToString());
using(var fs = new StreamWriter(Path.Combine(OutputDir, "pdfpages.txt"))) {
fs.WriteLine(page.ToString());
}
}
public void sizeTest()
{
SetOutputDir("size");
PrepareTest();
using (converter = new Converter(controller, Path.Combine(WorkDir, testfile + ".tex"), Path.Combine(OutputDir, testfile + ".pdf"))) {
BeforeTest();
tex2dvi_test(testfile + ".tex");
dvi2pdf_test(testfile + ".dvi");
var pageref = new ByRefType(typeof(int));
var versionref = new ByRefType(typeof(int));
CallMethod(converter, "pdfinfo", Path.Combine(OutputDir, "dvi2pdf.pdf"), pageref, versionref);
int page = (int)pageref.val, version = (int)versionref.val;
AfterTest();
var orighiresbb = GetPDFBB("dvi2pdf.pdf", 1, page);
var origbb = GetPDFBB("dvi2pdf.pdf", 1, page, false);
var orighiresbox = GetPDFBox("dvi2pdf.pdf", Enumerable.Range(1, page).ToList());
var origbox = GetPDFBox("dvi2pdf.pdf", Enumerable.Range(1, page).ToList(), false);
Settings.Default.keepPageSize = false;
var exts = new string[] { ".pdf", ".eps", ".jpg", ".png" };
foreach (var ext in exts)
{
doGenerateOneTest("dvi2pdf.pdf", testfile + "-not-keep" + ext);
}
Func <string, List <string> > get_output_files_func = (s) => {
if (page == 1)
{
return new List <string>()
{
s
}
}
;
else
{
var basen = Path.GetFileNameWithoutExtension(s);
var ext = Path.GetExtension(s);
return(Enumerable.Range(1, page).Select(i => basen + "-" + i.ToString() + ext).ToList());
}
};
Func <string, List <Size> > get_pdf_box = (s) => {
var rv = new List <Size>();
var files = get_output_files_func(s);
foreach (var file in files)
{
if (File.Exists(Path.Combine(OutputDir, file)))
{
rv.AddRange(GetPDFBox(file, new List <int>()
{
1
}));
}
}
return(rv);
};
Assert.IsTrue(CheckVerctorImageSize(orighiresbb, get_pdf_box(testfile + "-not-keep.pdf")));
Assert.IsTrue(CheckVerctorImageSize(orighiresbb, GetEPSBB(get_output_files_func(testfile + "-not-keep.eps"))));
Assert.IsTrue(CheckBitmapImageSize(orighiresbb, GetBitmapSize(get_output_files_func(testfile + "-not-keep.png"))));
Assert.IsTrue(CheckBitmapImageSize(orighiresbb, GetBitmapSize(get_output_files_func(testfile + "-not-keep.jpg"))));
Settings.Default.keepPageSize = true;
foreach (var ext in exts)
{
doGenerateOneTest("dvi2pdf.pdf", testfile + "-keep" + ext);
}
Assert.IsTrue(CheckVerctorImageSize(orighiresbox, get_pdf_box(testfile + "-keep.pdf")));
Assert.IsTrue(CheckVerctorImageSize(orighiresbox, GetEPSBB(get_output_files_func(testfile + "-keep.eps"))));
Assert.IsTrue(CheckBitmapImageSize(orighiresbox, GetBitmapSize(get_output_files_func(testfile + "-keep.png"))));
Assert.IsTrue(CheckBitmapImageSize(orighiresbox, GetBitmapSize(get_output_files_func(testfile + "-keep.jpg"))));
}
}
/// <summary>
/// Is a method that is reflectable a method which should be placed into the invoke map as invokable?
/// </summary>
public bool IsReflectionInvokable(MethodDesc method)
{
var signature = method.Signature;
// ----------------------------------------------------------------
// TODO: support for methods returning pointer types - https://github.com/dotnet/corert/issues/2113
// ----------------------------------------------------------------
if (signature.ReturnType.IsPointer)
{
return(false);
}
for (int i = 0; i < signature.Length; i++)
{
if (signature[i].IsByRef && ((ByRefType)signature[i]).ParameterType.IsPointer)
{
return(false);
}
}
// ----------------------------------------------------------------
// TODO: function pointer types are odd: https://github.com/dotnet/corert/issues/1929
// ----------------------------------------------------------------
if (signature.ReturnType.IsFunctionPointer)
{
return(false);
}
for (int i = 0; i < signature.Length; i++)
{
if (signature[i].IsFunctionPointer)
{
return(false);
}
}
// ----------------------------------------------------------------
// Methods with ByRef returns can't be reflection invoked
// ----------------------------------------------------------------
if (signature.ReturnType.IsByRef)
{
return(false);
}
// ----------------------------------------------------------------
// Methods that return ByRef-like types or take them by reference can't be reflection invoked
// ----------------------------------------------------------------
if (signature.ReturnType.IsDefType && ((DefType)signature.ReturnType).IsByRefLike)
{
return(false);
}
for (int i = 0; i < signature.Length; i++)
{
ByRefType paramType = signature[i] as ByRefType;
if (paramType != null && paramType.ParameterType.IsDefType && ((DefType)paramType.ParameterType).IsByRefLike)
{
return(false);
}
}
// ----------------------------------------------------------------
// Delegate construction is only allowed through specific IL sequences
// ----------------------------------------------------------------
if (method.OwningType.IsDelegate && method.IsConstructor)
{
return(false);
}
// Everything else should get a stub.
return(true);
}
public void sizeTest() {
SetOutputDir("size");
PrepareTest();
using (converter = new Converter(controller, Path.Combine(WorkDir, testfile + ".tex"), Path.Combine(OutputDir, testfile + ".pdf"))) {
BeforeTest();
tex2dvi_test(testfile + ".tex");
dvi2pdf_test(testfile + ".dvi");
var pageref = new ByRefType(typeof(int));
var versionref = new ByRefType(typeof(int));
CallMethod(converter, "pdfinfo", Path.Combine(OutputDir, "dvi2pdf.pdf"), pageref, versionref);
int page =(int)pageref.val, version =(int)versionref.val;
AfterTest();
var orighiresbb = GetPDFBB("dvi2pdf.pdf", 1, page);
var origbb = GetPDFBB("dvi2pdf.pdf", 1, page, false);
var orighiresbox = GetPDFBox("dvi2pdf.pdf", Enumerable.Range(1, page).ToList());
var origbox = GetPDFBox("dvi2pdf.pdf", Enumerable.Range(1, page).ToList(), false);
Settings.Default.keepPageSize = false;
var exts = new string[] { ".pdf", ".eps", ".jpg", ".png" };
foreach (var ext in exts) {
doGenerateOneTest("dvi2pdf.pdf", testfile + "-not-keep" + ext);
}
Func<string, List<string>> get_output_files_func = (s) => {
if (page == 1) return new List<string>() { s };
else {
var basen = Path.GetFileNameWithoutExtension(s);
var ext = Path.GetExtension(s);
return Enumerable.Range(1, page).Select(i => basen + "-" + i.ToString() + ext).ToList();
}
};
Func<string, List<Size>> get_pdf_box = (s) => {
var rv = new List<Size>();
var files = get_output_files_func(s);
foreach (var file in files) {
if (File.Exists(Path.Combine(OutputDir, file))) {
rv.AddRange(GetPDFBox(file, new List<int>() { 1 }));
}
}
return rv;
};
Assert.IsTrue(CheckVerctorImageSize(orighiresbb, get_pdf_box(testfile + "-not-keep.pdf")));
Assert.IsTrue(CheckVerctorImageSize(orighiresbb, GetEPSBB(get_output_files_func(testfile + "-not-keep.eps"))));
Assert.IsTrue(CheckBitmapImageSize(orighiresbb, GetBitmapSize(get_output_files_func(testfile + "-not-keep.png"))));
Assert.IsTrue(CheckBitmapImageSize(orighiresbb, GetBitmapSize(get_output_files_func(testfile + "-not-keep.jpg"))));
Settings.Default.keepPageSize = true;
foreach (var ext in exts) {
doGenerateOneTest("dvi2pdf.pdf", testfile + "-keep" + ext);
}
Assert.IsTrue(CheckVerctorImageSize(orighiresbox, get_pdf_box(testfile + "-keep.pdf")));
Assert.IsTrue(CheckVerctorImageSize(orighiresbox, GetEPSBB(get_output_files_func(testfile + "-keep.eps"))));
Assert.IsTrue(CheckBitmapImageSize(orighiresbox, GetBitmapSize(get_output_files_func(testfile + "-keep.png"))));
Assert.IsTrue(CheckBitmapImageSize(orighiresbox, GetBitmapSize(get_output_files_func(testfile + "-keep.jpg"))));
}
}
Tuple<List<Size>,List<Size>> GetExpectedSize(string source) {
tex2dvi_test(source);
dvi2pdf_test(Path.ChangeExtension(source, ".dvi"));
var pdf = "dvi2pdf.pdf";
var pageref = new ByRefType(typeof(int));
var versionref = new ByRefType(typeof(int));
CallMethod(converter, "pdfinfo", Path.Combine(OutputDir, pdf), pageref, versionref);
int page = (int)pageref.val, version = (int)versionref.val;
if(Settings.Default.keepPageSize) {
return new Tuple<List<Size>, List<Size>>(
GetPDFBox(pdf, Enumerable.Range(1, page).ToList(), false),
GetPDFBox(pdf, Enumerable.Range(1, page).ToList(), true));
} else {
return new Tuple<List<Size>, List<Size>>(
GetPDFBB(pdf, 1, page, false),
GetPDFBB(pdf, 1, page, true));
}
}
public override void AppendName(StringBuilder builder, ByRefType type)
{
AppendName(builder, type.ParameterType);
builder.Append('@');
}
public override void AppendName(StringBuilder sb, ByRefType type)
{
AppendName(sb, type.ParameterType);
sb.Append('&');
}
private void EmitByRefTypeSignature(ByRefType type, SignatureContext context)
{
EmitElementType(CorElementType.ELEMENT_TYPE_BYREF);
EmitTypeSignature(type.ParameterType, context);
}
void doGenerateTest(string source, string output, string[] exts) {
Tuple<List<Size>, List<Size>> expected = null;
var pdf = "dvi2pdf.pdf";
using (var fs = new StreamWriter(Path.Combine(WorkDir, testfile + ".tex"))) {
fs.Write(source);
}
using (converter = new Converter(controller, Path.Combine(WorkDir, testfile + ".tex"), Path.Combine(OutputDir, testfile + "-" + output + ".pdf"))) {
tex2dvi_test(testfile + ".tex");
dvi2pdf_test(testfile + ".dvi");
var pageref = new ByRefType(typeof(int));
var versionref = new ByRefType(typeof(int));
CallMethod(converter, "pdfinfo", Path.Combine(OutputDir, pdf), pageref, versionref);
int page = (int)pageref.val, version = (int)versionref.val;
if (Settings.Default.keepPageSize) {
expected = new Tuple<List<Size>, List<Size>>(
GetPDFBox(pdf, Enumerable.Range(1, page).ToList(), false),
GetPDFBox(pdf, Enumerable.Range(1, page).ToList(), true));
} else {
expected = new Tuple<List<Size>, List<Size>>(
GetPDFBB(pdf, 1, page, false),
GetPDFBB(pdf, 1, page, true));
}
File.Delete(Path.Combine(WorkDir, pdf));
File.Move(Path.Combine(OutputDir,pdf),Path.Combine(WorkDir,pdf));
}
foreach (var ext in exts) {
File.Copy(Path.Combine(WorkDir, pdf), Path.Combine(WorkDir, testfile + ".pdf"), true);
using (converter = new Converter(controller, Path.Combine(WorkDir, testfile + ".pdf"), Path.Combine(OutputDir, testfile + "-" + output + ext))) {
converter.Convert();
if (expected.Item1.Count == 1 || Settings.Default.mergeOutputFiles) {
Assert.IsTrue(File.Exists(Path.Combine(OutputDir, testfile + "-" + output + ext)));
} else {
bool widthpos = (Settings.Default.leftMargin + Settings.Default.rightMargin > 0);
bool heightpos = (Settings.Default.topMargin + Settings.Default.bottomMargin > 0);
for (int i = 0; i < expected.Item1.Count; ++i) {
if ((expected.Item1[i].width != 0 || widthpos) && (expected.Item1[i].height != 0 || heightpos)) {
Assert.IsTrue(File.Exists(Path.Combine(OutputDir, testfile + "-" + output + "-" + (i + 1).ToString() + ext)));
} else {
Assert.IsFalse(File.Exists(Path.Combine(OutputDir, testfile + "-" + output + "-" + (i + 1).ToString() + ext)));
}
}
}
}
}
File.Delete(Path.Combine(WorkDir,pdf));
}
