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)); }