You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@pdfbox.apache.org by ti...@apache.org on 2024/02/09 10:34:39 UTC

svn commit: r1915687 - /pdfbox/branches/2.0/pdfbox/src/test/java/org/apache/pdfbox/multipdf/PDFMergerUtilityTest.java

Author: tilman
Date: Fri Feb  9 10:34:38 2024
New Revision: 1915687

URL: http://svn.apache.org/viewvc?rev=1915687&view=rev
Log:
PDFBOX-5762: keep valid page destinations when splitting

Added:
    pdfbox/branches/2.0/pdfbox/src/test/java/org/apache/pdfbox/multipdf/PDFMergerUtilityTest.java   (with props)

Added: pdfbox/branches/2.0/pdfbox/src/test/java/org/apache/pdfbox/multipdf/PDFMergerUtilityTest.java
URL: http://svn.apache.org/viewvc/pdfbox/branches/2.0/pdfbox/src/test/java/org/apache/pdfbox/multipdf/PDFMergerUtilityTest.java?rev=1915687&view=auto
==============================================================================
--- pdfbox/branches/2.0/pdfbox/src/test/java/org/apache/pdfbox/multipdf/PDFMergerUtilityTest.java (added)
+++ pdfbox/branches/2.0/pdfbox/src/test/java/org/apache/pdfbox/multipdf/PDFMergerUtilityTest.java Fri Feb  9 10:34:38 2024
@@ -0,0 +1,1044 @@
+/*
+ * Copyright 2014 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.pdfbox.multipdf;
+
+import java.awt.image.BufferedImage;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import junit.framework.TestCase;
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.fail;
+import org.apache.pdfbox.cos.COSArray;
+import org.apache.pdfbox.cos.COSBase;
+import org.apache.pdfbox.cos.COSDictionary;
+import org.apache.pdfbox.cos.COSName;
+import org.apache.pdfbox.cos.COSObject;
+
+import org.apache.pdfbox.io.MemoryUsageSetting;
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDDocumentCatalog;
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.apache.pdfbox.pdmodel.PDPageTree;
+import org.apache.pdfbox.pdmodel.common.COSObjectable;
+import org.apache.pdfbox.pdmodel.common.PDNameTreeNode;
+import org.apache.pdfbox.pdmodel.common.PDNumberTreeNode;
+import org.apache.pdfbox.pdmodel.documentinterchange.logicalstructure.PDStructureElement;
+import org.apache.pdfbox.pdmodel.documentinterchange.logicalstructure.PDStructureTreeRoot;
+import org.apache.pdfbox.pdmodel.interactive.action.PDActionGoTo;
+import org.apache.pdfbox.pdmodel.interactive.annotation.PDAnnotation;
+import org.apache.pdfbox.pdmodel.interactive.annotation.PDAnnotationLink;
+import org.apache.pdfbox.pdmodel.interactive.annotation.PDAnnotationWidget;
+import org.apache.pdfbox.pdmodel.interactive.documentnavigation.destination.PDPageDestination;
+import org.apache.pdfbox.pdmodel.interactive.documentnavigation.destination.PDPageFitDestination;
+import org.apache.pdfbox.pdmodel.interactive.form.PDAcroForm;
+import org.apache.pdfbox.pdmodel.interactive.form.PDField;
+import org.apache.pdfbox.rendering.PDFRenderer;
+import org.junit.Assert;
+
+/**
+ * Test suite for PDFMergerUtility.
+ *
+ * @author Maruan Sahyoun (PDF files)
+ * @author Tilman Hausherr (code)
+ */
+public class PDFMergerUtilityTest extends TestCase
+{
+    final String SRCDIR = "src/test/resources/input/merge/";
+    final String TARGETTESTDIR = "target/test-output/merge/";
+    private static final File TARGETPDFDIR = new File("target/pdfs");
+    final int DPI = 96;
+
+    @Override
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+
+        new File(TARGETTESTDIR).mkdirs();
+        if (!new File(TARGETTESTDIR).exists())
+        {
+            throw new IOException("could not create output directory");
+        }
+    }
+    
+    
+
+    /**
+     * Tests whether the merge of two PDF files with identically named but
+     * different global resources works. The two PDF files have two fonts each
+     * named /TT1 and /TT0 that are Arial and Courier and vice versa in the
+     * second file. Revisions before 1613017 fail this test because global
+     * resources were merged which made trouble when resources of the same kind
+     * had the same name.
+     *
+     * @throws IOException if something goes wrong.
+     */
+    public void testPDFMergerUtility() throws IOException
+    {
+        checkMergeIdentical("PDFBox.GlobalResourceMergeTest.Doc01.decoded.pdf",
+                "PDFBox.GlobalResourceMergeTest.Doc02.decoded.pdf",
+                "GlobalResourceMergeTestResult.pdf", 
+                MemoryUsageSetting.setupMainMemoryOnly());
+        
+        // once again, with scratch file
+        checkMergeIdentical("PDFBox.GlobalResourceMergeTest.Doc01.decoded.pdf",
+                "PDFBox.GlobalResourceMergeTest.Doc02.decoded.pdf",
+                "GlobalResourceMergeTestResult2.pdf", 
+                MemoryUsageSetting.setupTempFileOnly());
+    }
+
+    /**
+     * Tests whether the merge of two PDF files with JPEG and CCITT works. A few revisions before
+     * 1704911 this test failed because the clone utility attempted to decode and re-encode the
+     * streams, see PDFBOX-2893 on 23.9.2015.
+     *
+     * @throws IOException if something goes wrong.
+     */
+    public void testJpegCcitt() throws IOException
+    {
+        checkMergeIdentical("jpegrgb.pdf",
+                "multitiff.pdf",
+                "JpegMultiMergeTestResult.pdf",
+                MemoryUsageSetting.setupMainMemoryOnly());
+
+        // once again, with scratch file
+        checkMergeIdentical("jpegrgb.pdf",
+                "multitiff.pdf",
+                "JpegMultiMergeTestResult.pdf",
+                MemoryUsageSetting.setupTempFileOnly());
+    }
+
+    // see PDFBOX-2893
+    public void testPDFMergerUtility2() throws IOException
+    {
+        checkMergeIdentical("PDFBox.GlobalResourceMergeTest.Doc01.pdf",
+                "PDFBox.GlobalResourceMergeTest.Doc02.pdf",
+                "GlobalResourceMergeTestResult.pdf",
+                MemoryUsageSetting.setupMainMemoryOnly());
+
+        // once again, with scratch file
+        checkMergeIdentical("PDFBox.GlobalResourceMergeTest.Doc01.pdf",
+                "PDFBox.GlobalResourceMergeTest.Doc02.pdf",
+                "GlobalResourceMergeTestResult2.pdf",
+                MemoryUsageSetting.setupTempFileOnly());
+    }
+
+    /**
+     * PDFBOX-3972: Test that OpenAction page destination isn't lost after merge.
+     * 
+     * @throws IOException 
+     */
+    public void testPDFMergerOpenAction() throws IOException
+    {
+        PDDocument doc1 = new PDDocument();
+        doc1.addPage(new PDPage());
+        doc1.addPage(new PDPage());
+        doc1.addPage(new PDPage());
+        doc1.save(new File(TARGETTESTDIR,"MergerOpenActionTest1.pdf"));
+        doc1.close();
+
+        PDDocument doc2 = new PDDocument();
+        doc2.addPage(new PDPage());
+        doc2.addPage(new PDPage());
+        doc2.addPage(new PDPage());
+        PDPageDestination dest = new PDPageFitDestination();
+        dest.setPage(doc2.getPage(1));
+        doc2.getDocumentCatalog().setOpenAction(dest);
+        doc2.save(new File(TARGETTESTDIR,"MergerOpenActionTest2.pdf"));
+        doc2.close();
+
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        pdfMergerUtility.addSource(new File(TARGETTESTDIR, "MergerOpenActionTest1.pdf"));
+        pdfMergerUtility.addSource(new File(TARGETTESTDIR, "MergerOpenActionTest2.pdf"));
+        pdfMergerUtility.setDestinationFileName(TARGETTESTDIR + "MergerOpenActionTestResult.pdf");
+        pdfMergerUtility.mergeDocuments(MemoryUsageSetting.setupMainMemoryOnly());
+
+        PDDocument mergedDoc = PDDocument.load(new File(TARGETTESTDIR, "MergerOpenActionTestResult.pdf"));
+        PDDocumentCatalog documentCatalog = mergedDoc.getDocumentCatalog();
+        dest = (PDPageDestination) documentCatalog.getOpenAction();
+        assertEquals(4, documentCatalog.getPages().indexOf(dest.getPage()));
+        mergedDoc.close();
+    }
+
+    /**
+     * PDFBOX-3999: check that page entries in the structure tree only reference pages from the page
+     * tree, i.e. that no orphan pages exist.
+     * 
+     * @throws IOException 
+     */
+    public void testStructureTreeMerge() throws IOException
+    {
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        PDDocument src = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-3999-GeneralForbearance.pdf"));
+
+        ElementCounter elementCounter = new ElementCounter();
+        elementCounter.walk(src.getDocumentCatalog().getStructureTreeRoot().getK());
+        int singleCnt = elementCounter.cnt;
+        int singleSetSize = elementCounter.set.size();
+        assertEquals(134, singleCnt);
+        assertEquals(134, singleSetSize);
+
+        PDDocument dst = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-3999-GeneralForbearance.pdf"));
+        pdfMergerUtility.appendDocument(dst, src);
+        src.close();
+        dst.save(new File(TARGETTESTDIR, "PDFBOX-3999-GeneralForbearance-merged.pdf"));
+        dst.close();
+
+        PDDocument doc = PDDocument.load(new File(TARGETTESTDIR, "PDFBOX-3999-GeneralForbearance-merged.pdf"));
+
+        // Assume that the merged tree has double element count
+        elementCounter = new ElementCounter();
+        elementCounter.walk(doc.getDocumentCatalog().getStructureTreeRoot().getK());
+        assertEquals(singleCnt * 2, elementCounter.cnt);
+        assertEquals(singleSetSize * 2, elementCounter.set.size());
+        checkForPageOrphans(doc);
+
+        doc.close();
+    }
+
+    /**
+     * PDFBOX-3999: check that no streams are kept from the source document by the destination
+     * document, despite orphan annotations remaining in the structure tree.
+     *
+     * @throws IOException
+     */
+    public void testStructureTreeMerge2() throws IOException
+    {
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        PDDocument doc = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-3999-GeneralForbearance.pdf"));
+        doc.getDocumentCatalog().getAcroForm().flatten();
+        doc.save(new File(TARGETTESTDIR, "PDFBOX-3999-GeneralForbearance-flattened.pdf"));
+
+        ElementCounter elementCounter = new ElementCounter();
+        elementCounter.walk(doc.getDocumentCatalog().getStructureTreeRoot().getK());
+        int singleCnt = elementCounter.cnt;
+        int singleSetSize = elementCounter.set.size();
+        assertEquals(134, singleCnt);
+        assertEquals(134, singleSetSize);
+
+        doc.close();
+
+        PDDocument src = PDDocument.load(new File(TARGETTESTDIR, "PDFBOX-3999-GeneralForbearance-flattened.pdf"));
+        PDDocument dst = PDDocument.load(new File(TARGETTESTDIR, "PDFBOX-3999-GeneralForbearance-flattened.pdf"));
+        pdfMergerUtility.appendDocument(dst, src);
+        // before solving PDFBOX-3999, the close() below brought
+        // IOException: COSStream has been closed and cannot be read.
+        src.close();
+        dst.save(new File(TARGETTESTDIR, "PDFBOX-3999-GeneralForbearance-flattened-merged.pdf"));
+        dst.close();
+
+        doc = PDDocument.load(new File(TARGETTESTDIR, "PDFBOX-3999-GeneralForbearance-flattened-merged.pdf"));
+
+        checkForPageOrphans(doc);
+
+        // Assume that the merged tree has double element count
+        elementCounter = new ElementCounter();
+        elementCounter.walk(doc.getDocumentCatalog().getStructureTreeRoot().getK());
+        assertEquals(singleCnt * 2, elementCounter.cnt);
+        assertEquals(singleSetSize * 2, elementCounter.set.size());
+
+        doc.close();
+    }
+
+    /**
+     * PDFBOX-4408: Check that /StructParents values from pages and /StructParent values from
+     * annotations are found in the /ParentTree.
+     *
+     * @throws IOException
+     */
+    public void testStructureTreeMerge3() throws IOException
+    {
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        PDDocument src = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-4408.pdf"));
+
+        ElementCounter elementCounter = new ElementCounter();
+        elementCounter.walk(src.getDocumentCatalog().getStructureTreeRoot().getK());
+        int singleCnt = elementCounter.cnt;
+        int singleSetSize = elementCounter.set.size();
+        assertEquals(25, singleCnt);
+        assertEquals(25, singleSetSize);
+
+        PDDocument dst = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-4408.pdf"));
+        pdfMergerUtility.appendDocument(dst, src);
+        src.close();
+        dst.save(new File(TARGETTESTDIR, "PDFBOX-4408-merged.pdf"));
+        dst.close();
+
+        dst = PDDocument.load(new File(TARGETTESTDIR, "PDFBOX-4408-merged.pdf"));
+
+        // Assume that the merged tree has double element count
+        elementCounter = new ElementCounter();
+        elementCounter.walk(dst.getDocumentCatalog().getStructureTreeRoot().getK());
+        assertEquals(singleCnt * 2, elementCounter.cnt);
+        assertEquals(singleSetSize * 2, elementCounter.set.size());
+
+        checkWithNumberTree(dst);
+        checkForPageOrphans(dst);
+        dst.close();
+        checkStructTreeRootCount(new File(TARGETTESTDIR, "PDFBOX-4408-merged.pdf"));
+    }
+
+    /**
+     * PDFBOX-4417: Same as the previous tests, but this one failed when the previous tests
+     * succeeded because of more bugs with cloning.
+     *
+     * @throws IOException
+     */
+    public void testStructureTreeMerge4() throws IOException
+    {
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        PDDocument src = PDDocument.load(new File(SRCDIR, "PDFBOX-4417-001031.pdf"));
+
+        ElementCounter elementCounter = new ElementCounter();
+        elementCounter.walk(src.getDocumentCatalog().getStructureTreeRoot().getK());
+        int singleCnt = elementCounter.cnt;
+        int singleSetSize = elementCounter.set.size();
+        assertEquals(104, singleCnt);
+        assertEquals(104, singleSetSize);
+
+        PDDocument dst = PDDocument.load(new File(SRCDIR, "PDFBOX-4417-001031.pdf"));
+        pdfMergerUtility.appendDocument(dst, src);
+        src.close();
+        dst.save(new File(TARGETTESTDIR, "PDFBOX-4417-001031-merged.pdf"));
+        dst.close();
+        dst = PDDocument.load(new File(TARGETTESTDIR, "PDFBOX-4417-001031-merged.pdf"));
+
+        // Assume that the merged tree has double element count
+        elementCounter = new ElementCounter();
+        elementCounter.walk(dst.getDocumentCatalog().getStructureTreeRoot().getK());
+        assertEquals(singleCnt * 2, elementCounter.cnt);
+        assertEquals(singleSetSize * 2, elementCounter.set.size());
+
+        checkWithNumberTree(dst);
+        checkForPageOrphans(dst);
+        dst.close();
+        checkStructTreeRootCount(new File(TARGETTESTDIR, "PDFBOX-4417-001031-merged.pdf"));
+    }
+
+    /**
+     * PDFBOX-4417: Same as the previous tests, but this one failed when the previous tests
+     * succeeded because the /K tree started with two dictionaries and not with an array.
+     *
+     * @throws IOException 
+     */
+    public void testStructureTreeMerge5() throws IOException
+    {
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        PDDocument src = PDDocument.load(new File(SRCDIR, "PDFBOX-4417-054080.pdf"));
+
+        ElementCounter elementCounter = new ElementCounter();
+        elementCounter.walk(src.getDocumentCatalog().getStructureTreeRoot().getK());
+        int singleCnt = elementCounter.cnt;
+        int singleSetSize = elementCounter.set.size();
+
+        PDDocument dst = PDDocument.load(new File(SRCDIR, "PDFBOX-4417-054080.pdf"));
+        pdfMergerUtility.appendDocument(dst, src);
+        src.close();
+        dst.save(new File(TARGETTESTDIR, "PDFBOX-4417-054080-merged.pdf"));
+        dst.close();
+        dst = PDDocument.load(new File(TARGETTESTDIR, "PDFBOX-4417-054080-merged.pdf"));
+        checkWithNumberTree(dst);
+        checkForPageOrphans(dst);
+
+        // Assume that the merged tree has double element count
+        elementCounter = new ElementCounter();
+        elementCounter.walk(dst.getDocumentCatalog().getStructureTreeRoot().getK());
+        assertEquals(singleCnt * 2, elementCounter.cnt);
+        assertEquals(singleSetSize * 2, elementCounter.set.size());
+
+        dst.close();
+        
+        checkStructTreeRootCount(new File(TARGETTESTDIR, "PDFBOX-4417-054080-merged.pdf"));
+    }
+
+    /**
+     * PDFBOX-4418: test merging PDFs where ParentTree have a hierarchy.
+     * 
+     * @throws IOException 
+     */
+    public void testStructureTreeMerge6() throws IOException
+    {
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        PDDocument src = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-4418-000671.pdf"));
+
+        PDStructureTreeRoot structureTreeRoot = src.getDocumentCatalog().getStructureTreeRoot();
+        PDNumberTreeNode parentTree = structureTreeRoot.getParentTree();
+        Map<Integer, COSObjectable> numberTreeAsMap = PDFMergerUtility.getNumberTreeAsMap(parentTree);
+        assertEquals(381, numberTreeAsMap.size());
+        assertEquals(743, Collections.max(numberTreeAsMap.keySet()) + 1);
+        assertEquals(0, (int) Collections.min(numberTreeAsMap.keySet()));
+        assertEquals(743, structureTreeRoot.getParentTreeNextKey());        
+
+        PDDocument dst = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-4418-000314.pdf"));
+
+        structureTreeRoot = dst.getDocumentCatalog().getStructureTreeRoot();
+        parentTree = structureTreeRoot.getParentTree();
+        numberTreeAsMap = PDFMergerUtility.getNumberTreeAsMap(parentTree);
+        assertEquals(7, numberTreeAsMap.size());
+        assertEquals(328, Collections.max(numberTreeAsMap.keySet()) + 1);
+        assertEquals(321, (int) Collections.min(numberTreeAsMap.keySet()));
+        // ParentTreeNextKey should be 321 but PDF has a higher value
+        assertEquals(408, structureTreeRoot.getParentTreeNextKey());
+
+        pdfMergerUtility.appendDocument(dst, src);
+        src.close();
+        dst.save(new File(TARGETTESTDIR, "PDFBOX-4418-merged.pdf"));
+        dst.close();
+
+        dst = PDDocument.load(new File(TARGETTESTDIR, "PDFBOX-4418-merged.pdf"));
+        checkWithNumberTree(dst);
+        checkForPageOrphans(dst);
+
+        structureTreeRoot = dst.getDocumentCatalog().getStructureTreeRoot();
+        parentTree = structureTreeRoot.getParentTree();
+        numberTreeAsMap = PDFMergerUtility.getNumberTreeAsMap(parentTree);
+        assertEquals(381+7, numberTreeAsMap.size());
+        assertEquals(408+743, Collections.max(numberTreeAsMap.keySet()) + 1);
+        assertEquals(321, (int) Collections.min(numberTreeAsMap.keySet()));
+        assertEquals(408+743, structureTreeRoot.getParentTreeNextKey());
+        dst.close();
+
+        checkStructTreeRootCount(new File(TARGETTESTDIR, "PDFBOX-4418-merged.pdf"));
+    }
+
+    /**
+     * PDFBOX-4423: test merging a PDF where a widget has no StructParent.
+     * 
+     * @throws IOException 
+     */
+    public void testStructureTreeMerge7() throws IOException
+    {
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        PDDocument src = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-4423-000746.pdf"));
+
+        PDStructureTreeRoot structureTreeRoot = src.getDocumentCatalog().getStructureTreeRoot();
+        PDNumberTreeNode parentTree = structureTreeRoot.getParentTree();
+        Map<Integer, COSObjectable> numberTreeAsMap = PDFMergerUtility.getNumberTreeAsMap(parentTree);
+        assertEquals(33, numberTreeAsMap.size());
+        assertEquals(64, Collections.max(numberTreeAsMap.keySet()) + 1);
+        assertEquals(31, (int) Collections.min(numberTreeAsMap.keySet()));
+        assertEquals(126, structureTreeRoot.getParentTreeNextKey());        
+
+        PDDocument dst = new PDDocument();
+
+        pdfMergerUtility.appendDocument(dst, src);
+        src.close();
+        dst.save(new File(TARGETTESTDIR, "PDFBOX-4423-merged.pdf"));
+        dst.close();
+
+        dst = PDDocument.load(new File(TARGETTESTDIR, "PDFBOX-4423-merged.pdf"));
+        checkWithNumberTree(dst);
+        checkForPageOrphans(dst);
+
+        structureTreeRoot = dst.getDocumentCatalog().getStructureTreeRoot();
+        parentTree = structureTreeRoot.getParentTree();
+        numberTreeAsMap = PDFMergerUtility.getNumberTreeAsMap(parentTree);
+        assertEquals(33, numberTreeAsMap.size());
+        assertEquals(64, Collections.max(numberTreeAsMap.keySet()) + 1);
+        assertEquals(31, (int) Collections.min(numberTreeAsMap.keySet()));
+        assertEquals(64, structureTreeRoot.getParentTreeNextKey());
+        dst.close();
+
+        checkStructTreeRootCount(new File(TARGETTESTDIR, "PDFBOX-4423-merged.pdf"));
+    }
+
+    /**
+     * PDFBOX-4009: Test that ParentTreeNextKey is recalculated correctly.
+     */
+    public void testMissingParentTreeNextKey() throws IOException
+    {
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        PDDocument src = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-4418-000314.pdf"));
+        PDDocument dst = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-4418-000314.pdf"));
+        // existing numbers are 321..327; ParentTreeNextKey is 408. 
+        // After deletion, it is recalculated in the merge 328.
+        // That value is added to all numbers of the destination,
+        // so the new numbers should be 321+328..327+328, i.e. 649..655,
+        // and this ParentTreeNextKey is 656 at the end.
+        dst.getDocumentCatalog().getStructureTreeRoot().getCOSObject().removeItem(COSName.PARENT_TREE_NEXT_KEY);
+        pdfMergerUtility.appendDocument(dst, src);
+        src.close();
+        dst.save(new File(TARGETTESTDIR, "PDFBOX-4418-000314-merged.pdf"));
+        dst.close();
+        dst = PDDocument.load(new File(TARGETTESTDIR, "PDFBOX-4418-000314-merged.pdf"));
+        assertEquals(656, dst.getDocumentCatalog().getStructureTreeRoot().getParentTreeNextKey());
+        dst.close();
+    }
+
+    /**
+     * PDFBOX-4416: Test merging of /IDTree
+     * <br>
+     * PDFBOX-4009: test merging to empty destination
+     *
+     * @throws IOException 
+     */
+    public void testStructureTreeMergeIDTree() throws IOException
+    {
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        PDDocument src = PDDocument.load(new File(SRCDIR, "PDFBOX-4417-001031.pdf"));
+        PDDocument dst = PDDocument.load(new File(SRCDIR, "PDFBOX-4417-054080.pdf"));
+
+        PDNameTreeNode<PDStructureElement> srcIDTree = src.getDocumentCatalog().getStructureTreeRoot().getIDTree();
+        Map<String, PDStructureElement> srcIDTreeMap = PDFMergerUtility.getIDTreeAsMap(srcIDTree);
+        PDNameTreeNode<PDStructureElement> dstIDTree = dst.getDocumentCatalog().getStructureTreeRoot().getIDTree();
+        Map<String, PDStructureElement> dstIDTreeMap = PDFMergerUtility.getIDTreeAsMap(dstIDTree);
+        int expectedTotal = srcIDTreeMap.size() + dstIDTreeMap.size();
+        assertEquals(192, expectedTotal);
+
+        // PDFBOX-4009, test that empty dest doc still merges structure tree
+        // (empty dest doc is used in command line app)
+        PDDocument emptyDest = new PDDocument();
+        pdfMergerUtility.appendDocument(emptyDest, src);
+        src.close();
+        src = emptyDest;
+        assertEquals(4, src.getDocumentCatalog().getStructureTreeRoot().getParentTreeNextKey());
+
+        pdfMergerUtility.appendDocument(dst, src);
+        src.close();
+        dst.save(new File(TARGETTESTDIR, "PDFBOX-4416-IDTree-merged.pdf"));
+        dst.close();
+        dst = PDDocument.load(new File(TARGETTESTDIR, "PDFBOX-4416-IDTree-merged.pdf"));
+        checkWithNumberTree(dst);
+        checkForPageOrphans(dst);
+
+        dstIDTree = dst.getDocumentCatalog().getStructureTreeRoot().getIDTree();
+        dstIDTreeMap = PDFMergerUtility.getIDTreeAsMap(dstIDTree);
+        assertEquals(expectedTotal, dstIDTreeMap.size());
+
+        dst.close();
+        checkStructTreeRootCount(new File(TARGETTESTDIR, "PDFBOX-4416-IDTree-merged.pdf"));
+    }
+
+    /**
+     * PDFBOX-4429: merge into destination that has /StructParent(s) entries in the destination file
+     * but no structure tree.
+     *
+     * @throws IOException
+     */
+    public void testMergeBogusStructParents1() throws IOException
+    {
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        PDDocument src = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-4408.pdf"));
+        PDDocument dst = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-4408.pdf"));
+        dst.getDocumentCatalog().setStructureTreeRoot(null);
+        dst.getPage(0).setStructParents(9999);
+        dst.getPage(0).getAnnotations().get(0).setStructParent(9998);
+        pdfMergerUtility.appendDocument(dst, src);
+        checkWithNumberTree(dst);
+        checkForPageOrphans(dst);
+        src.close();
+        dst.close();
+    }
+
+    /**
+     * PDFBOX-4429: merge into destination that has /StructParent(s) entries in the source file but
+     * no structure tree.
+     *
+     * @throws IOException
+     */
+    public void testMergeBogusStructParents2() throws IOException
+    {
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        PDDocument src = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-4408.pdf"));
+        PDDocument dst = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-4408.pdf"));
+        src.getDocumentCatalog().setStructureTreeRoot(null);
+        src.getPage(0).setStructParents(9999);
+        src.getPage(0).getAnnotations().get(0).setStructParent(9998);
+        pdfMergerUtility.appendDocument(dst, src);
+        checkWithNumberTree(dst);
+        checkForPageOrphans(dst);
+        src.close();
+        dst.close();
+    }
+
+    /**
+     * Test of the parent tree. Didn't work before PDFBOX-4003 because of incompatible class for
+     * PDNumberTreeNode.
+     *
+     * @throws IOException
+     */
+    public void testParentTree() throws IOException
+    {
+        PDDocument doc = PDDocument.load(new File(TARGETPDFDIR, "PDFBOX-3999-GeneralForbearance.pdf"));
+        PDStructureTreeRoot structureTreeRoot = doc.getDocumentCatalog().getStructureTreeRoot();
+        PDNumberTreeNode parentTree = structureTreeRoot.getParentTree();
+        parentTree.getValue(0);
+        Map<Integer, COSObjectable> numberTreeAsMap = PDFMergerUtility.getNumberTreeAsMap(parentTree);
+        assertEquals(31, numberTreeAsMap.size());
+        assertEquals(31, Collections.max(numberTreeAsMap.keySet()) + 1);
+        assertEquals(0, (int) Collections.min(numberTreeAsMap.keySet()));
+        assertEquals(31, structureTreeRoot.getParentTreeNextKey());
+        doc.close();
+    }
+
+    // PDFBOX-4417: check for multiple /StructTreeRoot entries that was due to
+    // incorrect merging of /K entries
+    private void checkStructTreeRootCount(File file) throws IOException
+    {
+        int count = 0;
+        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
+        String line;
+        while ((line = br.readLine()) != null)
+        {
+            if (line.equals("/Type /StructTreeRoot"))
+            {
+                ++count;
+            }
+        }
+        br.close();
+        assertEquals(file.getPath(), 1, count);
+    }
+
+    /**
+     * PDFBOX-4408: Check that /StructParents values from pages and /StructParent values from
+     * annotations are found in the /ParentTree.
+     *
+     * @param document
+     */
+    void checkWithNumberTree(PDDocument document) throws IOException
+    {
+        PDDocumentCatalog documentCatalog = document.getDocumentCatalog();
+        PDNumberTreeNode parentTree = documentCatalog.getStructureTreeRoot().getParentTree();
+        Map<Integer, COSObjectable> numberTreeAsMap = PDFMergerUtility.getNumberTreeAsMap(parentTree);
+        Set<Integer> keySet = numberTreeAsMap.keySet();
+        PDAcroForm acroForm = documentCatalog.getAcroForm();
+        if (acroForm != null)
+        {
+            for (PDField field : acroForm.getFieldTree())
+            {
+                for (PDAnnotationWidget widget : field.getWidgets())
+                {
+                    if (widget.getStructParent() >= 0)
+                    {
+                        assertTrue("field '" + field.getFullyQualifiedName() + "' /StructParent " +
+                                   widget.getStructParent() + " missing in /ParentTree",
+                                   keySet.contains(widget.getStructParent()));
+                    }
+                }
+            }
+        }
+        for (PDPage page : document.getPages())
+        {
+            if (page.getStructParents() >= 0)
+            {
+                assertTrue(keySet.contains(page.getStructParents()));
+            }
+            for (PDAnnotation ann : page.getAnnotations())
+            {
+                if (ann.getStructParent() >= 0)
+                {
+                    assertTrue("/StructParent " + ann.getStructParent() + " missing in /ParentTree",
+                               keySet.contains(ann.getStructParent()));
+                }
+            }
+        }
+
+        // might also test image and form dictionaries...
+    }
+
+    /**
+     * PDFBOX-4383: Test that file can be deleted after merge.
+     *
+     * @throws IOException 
+     */
+    public void testFileDeletion() throws IOException
+    {
+        File outFile = new File(TARGETTESTDIR, "PDFBOX-4383-result.pdf");
+
+        File inFile1 = new File(TARGETTESTDIR, "PDFBOX-4383-src1.pdf");
+        File inFile2 = new File(TARGETTESTDIR, "PDFBOX-4383-src2.pdf");
+
+        createSimpleFile(inFile1);
+        createSimpleFile(inFile2);
+
+        OutputStream out = new FileOutputStream(outFile);
+        PDFMergerUtility merger = new PDFMergerUtility();
+        merger.setDestinationStream(out);
+        merger.addSource(inFile1);
+        merger.addSource(inFile2);
+        merger.mergeDocuments(MemoryUsageSetting.setupMainMemoryOnly());
+        out.close();
+
+        assertTrue(inFile1.delete());
+        assertTrue(inFile2.delete());
+        assertTrue(outFile.delete());
+    }
+
+
+    /**
+     * Check that there is a top level Document and Parts below in a merge of 2 documents.
+     *
+     * @throws IOException
+     */
+    public void testPDFBox5198_2() throws IOException
+    {
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        pdfMergerUtility.addSource(new File(SRCDIR, "PDFA3A.pdf"));
+        pdfMergerUtility.addSource(new File(SRCDIR, "PDFA3A.pdf"));
+        pdfMergerUtility.setDestinationFileName(TARGETTESTDIR + "PDFA3A-merged2.pdf");
+        pdfMergerUtility.mergeDocuments(MemoryUsageSetting.setupMainMemoryOnly());
+
+        checkParts(new File(TARGETTESTDIR + "PDFA3A-merged2.pdf"));
+    }
+    
+    /**
+     * Check that there is a top level Document and Parts below in a merge of 3 documents.
+     *
+     * @throws IOException
+     */
+    public void testPDFBox5198_3() throws IOException
+    {
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        pdfMergerUtility.addSource(new File(SRCDIR, "PDFA3A.pdf"));
+        pdfMergerUtility.addSource(new File(SRCDIR, "PDFA3A.pdf"));
+        pdfMergerUtility.addSource(new File(SRCDIR, "PDFA3A.pdf"));
+        pdfMergerUtility.setDestinationFileName(TARGETTESTDIR + "PDFA3A-merged3.pdf");
+        pdfMergerUtility.mergeDocuments(MemoryUsageSetting.setupMainMemoryOnly());
+
+        checkParts(new File(TARGETTESTDIR + "PDFA3A-merged3.pdf"));
+    }
+
+    /**
+     * Check that there is a top level Document and Parts below.
+     * @param file
+     * @throws IOException 
+     */
+    private void checkParts(File file) throws IOException
+    {
+        PDDocument doc = PDDocument.load(file);
+        PDStructureTreeRoot structureTreeRoot = doc.getDocumentCatalog().getStructureTreeRoot();
+        COSDictionary topDict = (COSDictionary) structureTreeRoot.getK();
+        assertEquals(COSName.DOCUMENT, topDict.getItem(COSName.S));
+        assertEquals(structureTreeRoot.getCOSObject(), topDict.getCOSDictionary(COSName.P));
+        COSArray kArray = topDict.getCOSArray(COSName.K);
+        assertEquals(doc.getNumberOfPages(), kArray.size());
+        for (int i = 0; i < kArray.size(); ++i)
+        {
+            COSDictionary dict = (COSDictionary) kArray.getObject(i);
+            assertEquals(COSName.PART, dict.getItem(COSName.S));
+            assertEquals(topDict, dict.getCOSDictionary(COSName.P));
+        }
+        doc.close();
+    }
+
+    private void checkForPageOrphans(PDDocument doc) throws IOException
+    {
+        // check for orphan pages in the StructTreeRoot/K, StructTreeRoot/ParentTree and
+        // StructTreeRoot/IDTree trees.
+        PDPageTree pageTree = doc.getPages();
+        PDStructureTreeRoot structureTreeRoot = doc.getDocumentCatalog().getStructureTreeRoot();
+        checkElement(pageTree, structureTreeRoot.getParentTree().getCOSObject());
+        checkElement(pageTree, structureTreeRoot.getK());
+        checkForIDTreeOrphans(pageTree, structureTreeRoot);
+    }
+
+    private void checkForIDTreeOrphans(PDPageTree pageTree, PDStructureTreeRoot structureTreeRoot)
+            throws IOException
+    {
+        PDNameTreeNode<PDStructureElement> idTree = structureTreeRoot.getIDTree();
+        if (idTree == null)
+        {
+            return;
+        }
+        Map<String, PDStructureElement> map = PDFMergerUtility.getIDTreeAsMap(idTree);
+        for (PDStructureElement element : map.values())
+        {
+            if (element.getPage() != null)
+            {
+                checkForPage(pageTree, element);
+            }
+            if (!element.getKids().isEmpty())
+            {
+                checkElement(pageTree, element.getCOSObject().getDictionaryObject(COSName.K));
+            }
+        }
+    }
+
+    private void createSimpleFile(File file) throws IOException
+    {
+        PDDocument doc = new PDDocument();
+        doc.addPage(new PDPage());
+        doc.save(file);
+        doc.close();
+    }
+
+    private class ElementCounter
+    {
+        int cnt = 0;
+        Set<COSBase> set = new HashSet<COSBase>();
+
+        void walk(COSBase base)
+        {
+            if (base instanceof COSArray)
+            {
+                for (COSBase base2 : (COSArray) base)
+                {
+                    if (base2 instanceof COSObject)
+                    {
+                        base2 = ((COSObject) base2).getObject();
+                    }
+                    walk(base2);
+                }
+            }
+            else if (base instanceof COSDictionary)
+            {
+                COSDictionary kdict = (COSDictionary) base;
+                if (kdict.containsKey(COSName.PG))
+                {
+                    ++cnt;
+                    set.add(kdict);
+                }
+                if (kdict.containsKey(COSName.K))
+                {
+                    walk(kdict.getDictionaryObject(COSName.K));
+                }
+            }
+        }
+    }
+
+    // Each element can be an array, a dictionary or a number.
+    // See PDF specification Table 37 - Entries in a number tree node dictionary
+    // See PDF specification Table 322 - Entries in the structure tree root
+    // See PDF specification Table 323 - Entries in a structure element dictionary
+    // See PDF specification Table 325 – Entries in an object reference dictionary
+    // example of file with /Kids: 000153.pdf 000208.pdf 000314.pdf 000359.pdf 000671.pdf
+    // from digitalcorpora site
+    private void checkElement(PDPageTree pageTree, COSBase base) throws IOException
+    {
+        if (base instanceof COSArray)
+        {
+            for (COSBase base2 : (COSArray) base)
+            {
+                if (base2 instanceof COSObject)
+                {
+                    base2 = ((COSObject) base2).getObject();
+                }
+                checkElement(pageTree, base2);
+            }
+        }
+        else if (base instanceof COSDictionary)
+        {
+            COSDictionary kdict = (COSDictionary) base;
+            if (kdict.containsKey(COSName.PG))
+            {
+                PDStructureElement structureElement = new PDStructureElement(kdict);
+                checkForPage(pageTree, structureElement);
+            }
+            if (kdict.containsKey(COSName.K))
+            {
+                checkElement(pageTree, kdict.getDictionaryObject(COSName.K));
+                return;
+            }
+
+            // if we're in a number tree, check /Nums and /Kids
+            if (kdict.containsKey(COSName.KIDS))
+            {
+                checkElement(pageTree, kdict.getDictionaryObject(COSName.KIDS));
+            }
+            else if (kdict.containsKey(COSName.NUMS))
+            {
+                checkElement(pageTree, kdict.getDictionaryObject(COSName.NUMS));
+            }
+
+            // if we're an object reference dictionary (/OBJR), check the obj
+            if (kdict.containsKey(COSName.OBJ))
+            {
+                COSDictionary obj = (COSDictionary) kdict.getDictionaryObject(COSName.OBJ);
+                COSBase type = obj.getDictionaryObject(COSName.TYPE);
+                if (COSName.ANNOT.equals(type))
+                {
+                    PDAnnotation annotation = PDAnnotation.createAnnotation(obj);
+                    PDPage page = annotation.getPage();
+                    if (page != null)
+                    {
+                        if (pageTree.indexOf(page) == -1)
+                        {
+                            COSBase item = kdict.getItem(COSName.OBJ);
+                            if (item instanceof COSObject)
+                            {
+                                Assert.assertNotEquals("Annotation page is not in the page tree: " + item, -1, pageTree.indexOf(page));
+                            }
+                            else
+                            {
+                                // don't display because of stack overflow
+                                Assert.assertNotEquals("Annotation page is not in the page tree", -1, pageTree.indexOf(page));
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    //TODO needs to be investigated. Specification mentions
+                    // "such as an XObject or an annotation"
+                    fail("Other type: " + type);
+                }
+            }
+        }
+    }
+
+    // checks that the result file of a merge has the same rendering as the two
+    // source files
+    private void checkMergeIdentical(String filename1, String filename2, String mergeFilename, 
+            MemoryUsageSetting memUsageSetting)
+            throws IOException
+    {
+        PDDocument srcDoc1 = PDDocument.load(new File(SRCDIR, filename1), (String)null);
+        int src1PageCount = srcDoc1.getNumberOfPages();
+        PDFRenderer src1PdfRenderer = new PDFRenderer(srcDoc1);
+        BufferedImage[] src1ImageTab = new BufferedImage[src1PageCount];
+        for (int page = 0; page < src1PageCount; ++page)
+        {
+            src1ImageTab[page] = src1PdfRenderer.renderImageWithDPI(page, DPI);
+        }
+        srcDoc1.close();
+
+        PDDocument srcDoc2 = PDDocument.load(new File(SRCDIR, filename2), (String)null);
+        int src2PageCount = srcDoc2.getNumberOfPages();
+        PDFRenderer src2PdfRenderer = new PDFRenderer(srcDoc2);
+        BufferedImage[] src2ImageTab = new BufferedImage[src2PageCount];
+        for (int page = 0; page < src2PageCount; ++page)
+        {
+            src2ImageTab[page] = src2PdfRenderer.renderImageWithDPI(page, DPI);
+        }
+        srcDoc2.close();
+
+        PDFMergerUtility pdfMergerUtility = new PDFMergerUtility();
+        pdfMergerUtility.addSource(new File(SRCDIR, filename1));
+        pdfMergerUtility.addSource(new File(SRCDIR, filename2));
+        pdfMergerUtility.setDestinationFileName(TARGETTESTDIR + mergeFilename);
+        pdfMergerUtility.mergeDocuments(memUsageSetting);
+
+        PDDocument mergedDoc
+                = PDDocument.load(new File(TARGETTESTDIR, mergeFilename), (String)null);
+        PDFRenderer mergePdfRenderer = new PDFRenderer(mergedDoc);
+        int mergePageCount = mergedDoc.getNumberOfPages();
+        assertEquals(src1PageCount + src2PageCount, mergePageCount);
+        for (int page = 0; page < src1PageCount; ++page)
+        {
+            BufferedImage bim = mergePdfRenderer.renderImageWithDPI(page, DPI);
+            checkImagesIdentical(bim, src1ImageTab[page]);
+        }
+        for (int page = 0; page < src2PageCount; ++page)
+        {
+            int mergePage = page + src1PageCount;
+            BufferedImage bim = mergePdfRenderer.renderImageWithDPI(mergePage, DPI);
+            checkImagesIdentical(bim, src2ImageTab[page]);
+        }
+        mergedDoc.close();
+    }
+
+    private void checkImagesIdentical(BufferedImage bim1, BufferedImage bim2)
+    {
+        assertEquals(bim1.getHeight(), bim2.getHeight());
+        assertEquals(bim1.getWidth(), bim2.getWidth());
+        int w = bim1.getWidth();
+        int h = bim1.getHeight();
+        for (int i = 0; i < w; ++i)
+        {
+            for (int j = 0; j < h; ++j)
+            {
+                assertEquals(bim1.getRGB(i, j), bim2.getRGB(i, j));
+            }
+        }
+    }
+
+    private void checkForPage(PDPageTree pageTree, PDStructureElement structureElement)
+    {
+        PDPage page = structureElement.getPage();
+        if (page != null)
+        {
+            Assert.assertNotEquals("Page is not in the page tree", -1, pageTree.indexOf(page));
+        }
+    }
+
+    public void testSplitWithStructureTree() throws IOException
+    {
+        PDDocument doc = PDDocument.load(new File(SRCDIR, "PDFBOX-4417-001031.pdf"));
+        Splitter splitter = new Splitter();
+        splitter.setStartPage(1);
+        splitter.setEndPage(2);
+        splitter.setSplitAtPage(2);
+        List<PDDocument> splitResult = splitter.split(doc);
+        assertEquals(1, splitResult.size());
+        PDDocument dstDoc = splitResult.get(0);
+        assertEquals(2, dstDoc.getNumberOfPages());
+        checkForPageOrphans(dstDoc);
+        // these tests just verify the status quo. Changes should be checked visually with
+        // a PDF viewer that can display structural information.
+        PDStructureTreeRoot structureTreeRoot = dstDoc.getDocumentCatalog().getStructureTreeRoot();
+        assertEquals(126, PDFMergerUtility.getIDTreeAsMap(structureTreeRoot.getIDTree()).size());
+        assertEquals(2, PDFMergerUtility.getNumberTreeAsMap(structureTreeRoot.getParentTree()).size());
+        assertEquals(6, structureTreeRoot.getRoleMap().size());
+        dstDoc.close();
+        doc.close();
+    }
+
+    public void testSplitWithStructureTreeAndDestinations() throws IOException
+    {
+        PDDocument doc = PDDocument.load(new File(SRCDIR,"PDFBOX-5762-722238.pdf"));
+        Splitter splitter = new Splitter();
+        splitter.setStartPage(1);
+        splitter.setEndPage(2);
+        splitter.setSplitAtPage(2);
+        List<PDDocument> splitResult = splitter.split(doc);
+        assertEquals(1, splitResult.size());
+        PDDocument dstDoc = splitResult.get(0);
+        assertEquals(2, dstDoc.getNumberOfPages());
+        checkForPageOrphans(dstDoc);
+        // these tests just verify the status quo. Changes should be checked visually with
+        // a PDF viewer that can display structural information.
+        PDStructureTreeRoot structureTreeRoot = dstDoc.getDocumentCatalog().getStructureTreeRoot();
+        assertEquals(7, PDFMergerUtility.getNumberTreeAsMap(structureTreeRoot.getParentTree()).size());
+        assertEquals(4, structureTreeRoot.getRoleMap().size());
+
+        // check that destinations are fixed (only the two first point to the split doc)
+        List<PDAnnotation> annotations = dstDoc.getPage(0).getAnnotations();
+        assertEquals(5, annotations.size());
+        PDAnnotationLink link1 = (PDAnnotationLink) annotations.get(0);
+        PDAnnotationLink link2 = (PDAnnotationLink) annotations.get(1);
+        PDAnnotationLink link3 = (PDAnnotationLink) annotations.get(2);
+        PDAnnotationLink link4 = (PDAnnotationLink) annotations.get(3);
+        PDAnnotationLink link5 = (PDAnnotationLink) annotations.get(4);
+        PDPageDestination pd1 = 
+                (PDPageDestination) ((PDActionGoTo) link1.getAction()).getDestination();
+        PDPageDestination pd2 = 
+                (PDPageDestination) ((PDActionGoTo) link2.getAction()).getDestination();
+        PDPageDestination pd3 = 
+                (PDPageDestination) ((PDActionGoTo) link3.getAction()).getDestination();
+        PDPageDestination pd4 = 
+                (PDPageDestination) ((PDActionGoTo) link4.getAction()).getDestination();
+        PDPageDestination pd5 = 
+                (PDPageDestination) ((PDActionGoTo) link5.getAction()).getDestination();
+        PDPageTree pageTree = dstDoc.getPages();
+        assertEquals(0, pageTree.indexOf(pd1.getPage()));
+        assertEquals(1, pageTree.indexOf(pd2.getPage()));
+        assertNull(pd3.getPage());
+        assertNull(pd4.getPage());
+        assertNull(pd5.getPage());
+        dstDoc.close();
+        doc.close();
+    }
+}

Propchange: pdfbox/branches/2.0/pdfbox/src/test/java/org/apache/pdfbox/multipdf/PDFMergerUtilityTest.java
------------------------------------------------------------------------------
    svn:eol-style = native