< prev index next >

test/javax/xml/jaxp/functional/test/auctionportal/AuctionItemRepository.java

Print this page

        

@@ -28,15 +28,14 @@
 import static com.sun.org.apache.xerces.internal.jaxp.JAXPConstants.JAXP_SCHEMA_SOURCE;
 import static org.testng.Assert.assertTrue;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
+import java.io.FilePermission;
 import java.io.IOException;
 import java.io.InputStream;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
+import java.io.UnsupportedEncodingException;
 import static javax.xml.XMLConstants.FEATURE_SECURE_PROCESSING;
 import static javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;

@@ -44,15 +43,15 @@
 import javax.xml.parsers.SAXParserFactory;
 import javax.xml.transform.TransformerException;
 import javax.xml.transform.TransformerFactory;
 import javax.xml.transform.dom.DOMSource;
 import javax.xml.transform.stream.StreamResult;
+import jaxp.library.JAXPFileBaseTest;
 import static jaxp.library.JAXPTestUtilities.compareDocumentWithGold;
-import static jaxp.library.JAXPTestUtilities.failCleanup;
-import static jaxp.library.JAXPTestUtilities.failUnexpected;
 import static org.testng.Assert.assertFalse;
-
+import org.testng.annotations.AfterGroups;
+import org.testng.annotations.BeforeGroups;
 import org.testng.annotations.Test;
 import org.w3c.dom.Document;
 import org.xml.sax.SAXException;
 import org.xml.sax.SAXParseException;
 import static test.auctionportal.HiBidConstants.CLASS_DIR;

@@ -60,11 +59,11 @@
 import static test.auctionportal.HiBidConstants.XML_DIR;
 
 /**
  * This is a test class for the Auction portal HiBid.com.
  */
-public class AuctionItemRepository {
+public class AuctionItemRepository extends JAXPFileBaseTest {
     /**
      * XML file for parsing.
      */
     private final static String ENTITY_XML = XML_DIR + "entity.xml";
 

@@ -76,203 +75,242 @@
     /**
      * Setting the EntityExpansion Limit to 128000 and checks if the XML
      * document that has more than two levels of entity expansion is parsed or
      * not. Previous system property was changed to jdk.xml.entityExpansionLimit
      * see http://docs.oracle.com/javase/tutorial/jaxp/limits/limits.html.
+     * 
+     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
+     *         created which satisfies the configuration requested.
+     * @throws SAXException If any parse errors occur.
+     * @throws IOException if the file exists but is a directory rather than
+     *         a regular file, does not exist but cannot be created, or cannot 
+     *         be opened for any other reason.
      */
     @Test
-    public void testEntityExpansionSAXPos() {
-        try {
+    public void testEntityExpansionSAXPos() throws ParserConfigurationException,
+            SAXException, IOException { 
             SAXParserFactory factory = SAXParserFactory.newInstance();
             // Secure processing will limit XML processing to conform to
             // implementation limits.
             factory.setFeature(FEATURE_SECURE_PROCESSING, true);
             // Set entityExpansionLimit as 2 should expect fatalError
-            System.setProperty(SP_ENTITY_EXPANSION_LIMIT, String.valueOf(128000));
+        setSystemProperty(SP_ENTITY_EXPANSION_LIMIT, String.valueOf(128000));
             SAXParser parser = factory.newSAXParser();
 
             MyErrorHandler fatalHandler = new MyErrorHandler();
+        setPermissions(new FilePermission(ENTITY_XML, "read"));
             parser.parse(new File(ENTITY_XML), fatalHandler);
             assertFalse(fatalHandler.isAnyError());
-        } catch (ParserConfigurationException | SAXException | IOException e) {
-            failUnexpected(e);
-        }
     }
     /**
      * Setting the EntityExpansion Limit to 2 and checks if the XML
      * document that has more than two levels of entity expansion is parsed or
      * not. Previous system property was changed to jdk.xml.entityExpansionLimit
      * see http://docs.oracle.com/javase/tutorial/jaxp/limits/limits.html.
+     * 
+     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
+     *         created which satisfies the configuration requested.
+     * @throws SAXException If any parse errors occur.
+     * @throws IOException if the file exists but is a directory rather than
+     *         a regular file, does not exist but cannot be created, or cannot 
+     *         be opened for any other reason.
      */
     @Test(expectedExceptions = SAXParseException.class)
-    public void testEntityExpansionSAXNeg() throws SAXParseException {
-        //
-        try {
+    public void testEntityExpansionSAXNeg() throws ParserConfigurationException, 
+            SAXException, IOException {
             SAXParserFactory factory = SAXParserFactory.newInstance();
             // Secure processing will limit XML processing to conform to
             // implementation limits.
             factory.setFeature(FEATURE_SECURE_PROCESSING, true);
-            // Set entityExpansionLimit as 2 should expect SAXParseException
-            System.setProperty(SP_ENTITY_EXPANSION_LIMIT, String.valueOf(2));
-            SAXParser parser = factory.newSAXParser();
+        // Set entityExpansionLimit as 2 should expect SAXParseException.
+        setSystemProperty(SP_ENTITY_EXPANSION_LIMIT, String.valueOf(2)); 
 
+        SAXParser parser = factory.newSAXParser();
             MyErrorHandler fatalHandler = new MyErrorHandler();
+        setPermissions(new FilePermission(ENTITY_XML, "read"));
             parser.parse(new File(ENTITY_XML), fatalHandler);
-        } catch (SAXParseException e) {
-            throw e;
-        } catch (ParserConfigurationException | SAXException | IOException e) {
-            failUnexpected(e);
-        }
     }
 
     /**
      * Testing set MaxOccursLimit to 10000 in the secure processing enabled for
      * SAXParserFactory.
+     * 
+     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
+     *         created which satisfies the configuration requested.
+     * @throws SAXException If any parse errors occur.
+     * @throws IOException if the file exists but is a directory rather than
+     *         a regular file, does not exist but cannot be created, or cannot 
+     *         be opened for any other reason.
      */
     @Test
-    public void testMaxOccurLimitPos() {
+    public void testMaxOccurLimitPos() throws ParserConfigurationException, 
+            SAXException, IOException {
         String schema_file = XML_DIR + "toys.xsd";
         String xml_file = XML_DIR + "toys.xml";
-
-        try (InputStream is = new FileInputStream(xml_file)) {
             SAXParserFactory factory = SAXParserFactory.newInstance();
             factory.setValidating(true);
             factory.setFeature(FEATURE_SECURE_PROCESSING, true);
-            System.setProperty(SP_MAX_OCCUR_LIMIT, String.valueOf(10000));
+        setSystemProperty(SP_MAX_OCCUR_LIMIT, String.valueOf(10000));
             SAXParser parser = factory.newSAXParser();
             parser.setProperty(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA_NS_URI);
+        setPermissions(new FilePermission(XML_DIR + "-", "read"));
             parser.setProperty(JAXP_SCHEMA_SOURCE, new File(schema_file));
+        try (InputStream is = new FileInputStream(xml_file)) {
             MyErrorHandler eh = new MyErrorHandler();
             parser.parse(is, eh);
             assertFalse(eh.isAnyError());
-        } catch (ParserConfigurationException | SAXException | IOException e) {
-            failUnexpected(e);
         }
     }
 
     /**
      * Use a DocumentBuilder to create a DOM object and see if Secure Processing
      * feature affects the entity expansion.
+     * 
+     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
+     *         created which satisfies the configuration requested.
+     * @throws SAXException If any parse errors occur.
+     * @throws IOException if the file exists but is a directory rather than
+     *         a regular file, does not exist but cannot be created, or cannot 
+     *         be opened for any other reason.
      */
     @Test
-    public void testEntityExpansionDOMPos()  {
-        try {
+    public void testEntityExpansionDOMPos() throws ParserConfigurationException,
+            SAXException, IOException  {
             DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance();
             dfactory.setFeature(FEATURE_SECURE_PROCESSING, true);
-            System.setProperty(SP_ENTITY_EXPANSION_LIMIT, String.valueOf(10000));
+        setSystemProperty(SP_ENTITY_EXPANSION_LIMIT, String.valueOf(10000));
             DocumentBuilder dBuilder = dfactory.newDocumentBuilder();
             MyErrorHandler eh = new MyErrorHandler();
             dBuilder.setErrorHandler(eh);
+        setPermissions(new FilePermission(ENTITY_XML, "read"));
             dBuilder.parse(ENTITY_XML);
             assertFalse(eh.isAnyError());
-        } catch (ParserConfigurationException | IOException | SAXException e) {
-            failUnexpected(e);
-        }
     }
 
     /**
      * Use a DocumentBuilder to create a DOM object and see how does the Secure
      * Processing feature and entityExpansionLimit value affects output.
      * Negative test that when entityExpansionLimit is too small.
+     * 
+     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
+     *         created which satisfies the configuration requested.
+     * @throws SAXException If any parse errors occur.
+     * @throws IOException if the file exists but is a directory rather than
+     *         a regular file, does not exist but cannot be created, or cannot 
+     *         be opened for any other reason.
      */
     @Test(expectedExceptions = SAXParseException.class)
-    public void testEntityExpansionDOMNeg() throws SAXParseException {
-        try {
+    public void testEntityExpansionDOMNeg() throws ParserConfigurationException,
+            SAXException, IOException {
             DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance();
             dfactory.setFeature(FEATURE_SECURE_PROCESSING, true);
-            System.setProperty(SP_ENTITY_EXPANSION_LIMIT, String.valueOf(2));
+        setSystemProperty(SP_ENTITY_EXPANSION_LIMIT, String.valueOf(2));
             DocumentBuilder dBuilder = dfactory.newDocumentBuilder();
             MyErrorHandler eh = new MyErrorHandler();
             dBuilder.setErrorHandler(eh);
+        setPermissions(new FilePermission(ENTITY_XML, "read"));
             dBuilder.parse(ENTITY_XML);
-        } catch (SAXParseException e) {
-            throw e;
-        } catch (ParserConfigurationException | IOException | SAXException e) {
-            failUnexpected(e);
         }
+
+    
+    /**
+     * Save system property for restoring.
+     */
+    @BeforeGroups (groups = {"readWriteLocalFiles"})
+    public void setFilePermissions() {
+        setPermissions(new FilePermission(XML_DIR + "/-", "read"),
+                new FilePermission(GOLDEN_DIR + "/-", "read"),
+                new FilePermission(CLASS_DIR + "/-", "read, write"));
     }
 
     /**
-     * Test xi:include with a SAXParserFactory.
+     * Restore the system property.
      */
-    @Test
-    public void testXIncludeSAXPos() {
+    @AfterGroups (groups = {"readWriteLocalFiles"})
+    public void restoreFilePermissions() {
+        setPermissions();
+    }
+    /**
+     * Test xi:include with a SAXParserFactory.
+     * 
+     * @throws UnsupportedEncodingException if given encoding is an invalid
+     *         encoding name.
+     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
+     *         created which satisfies the configuration requested.
+     * @throws SAXException If any parse errors occur.
+     * @throws IOException if the file exists but is a directory rather than
+     *         a regular file, does not exist but cannot be created, or cannot 
+     *         be opened for any other reason.
+     */
+    @Test(groups = {"readWriteLocalFiles"})
+    public void testXIncludeSAXPos() throws UnsupportedEncodingException, 
+            ParserConfigurationException, SAXException, IOException {
         String resultFile = CLASS_DIR + "doc_xinclude.out";
         String goldFile = GOLDEN_DIR + "doc_xincludeGold.xml";
         String xmlFile = XML_DIR + "doc_xinclude.xml";
 
-        try {
             try(FileOutputStream fos = new FileOutputStream(resultFile)) {
                 XInclHandler xh = new XInclHandler(fos, null);
                 SAXParserFactory spf = SAXParserFactory.newInstance();
                 spf.setNamespaceAware(true);
                 spf.setXIncludeAware(true);
                 spf.setFeature(FEATURE_NAME, true);
                 spf.newSAXParser().parse(new File(xmlFile), xh);
             }
             assertTrue(compareDocumentWithGold(goldFile, resultFile));
-        } catch (ParserConfigurationException | SAXException | IOException e) {
-            failUnexpected(e);
-        } finally {
-            try {
-                Path resultPath = Paths.get(resultFile);
-                if (Files.exists(resultPath)) {
-                    Files.delete(resultPath);
-                }
-            } catch (IOException ex) {
-                failCleanup(ex, resultFile);
-            }
-        }
     }
 
     /**
      * Test the simple case of including a document using xi:include using a
      * DocumentBuilder.
-     */
-    @Test
-    public void testXIncludeDOMPos() {
+     * 
+     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
+     *         created which satisfies the configuration requested.
+     * @throws SAXException If any parse errors occur.
+     * @throws IOException if the file exists but is a directory rather than
+     *         a regular file, does not exist but cannot be created, or cannot 
+     *         be opened for any other reason.
+     * @throws TransformerException If an unrecoverable error occurs
+     *         during the course of the transformation.
+     */
+    @Test(groups = {"readWriteLocalFiles"})
+    public void testXIncludeDOMPos() throws ParserConfigurationException, 
+            SAXException, IOException, TransformerException {
         String resultFile = CLASS_DIR + "doc_xincludeDOM.out";
         String goldFile = GOLDEN_DIR + "doc_xincludeGold.xml";
         String xmlFile = XML_DIR + "doc_xinclude.xml";
-        try {
             try (FileOutputStream fos = new FileOutputStream(resultFile)) {
                 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
                 dbf.setXIncludeAware(true);
                 dbf.setNamespaceAware(true);
-
                 Document doc = dbf.newDocumentBuilder().parse(new File(xmlFile));
                 doc.setXmlStandalone(true);
-
                 TransformerFactory.newInstance().newTransformer().
                         transform(new DOMSource(doc), new StreamResult(fos));
             }
             assertTrue(compareDocumentWithGold(goldFile, resultFile));
-        } catch (ParserConfigurationException | SAXException | IOException
-                | TransformerException e) {
-            failUnexpected(e);
-        } finally {
-            try {
-                Path resultPath = Paths.get(resultFile);
-                if (Files.exists(resultPath)) {
-                    Files.delete(resultPath);
-                }
-            } catch (IOException ex) {
-                failCleanup(ex, resultFile);
-            }
-        }
     }
 
     /**
      * Test the simple case of including a document using xi:include within a
      * xi:fallback using a DocumentBuilder.
-     */
-    @Test
-    public void testXIncludeFallbackDOMPos() {
+     * 
+     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
+     *         created which satisfies the configuration requested.
+     * @throws SAXException If any parse errors occur.
+     * @throws IOException if the file exists but is a directory rather than
+     *         a regular file, does not exist but cannot be created, or cannot 
+     *         be opened for any other reason.
+     * @throws TransformerException If an unrecoverable error occurs
+     *         during the course of the transformation.
+     */
+    @Test(groups = {"readWriteLocalFiles"})
+    public void testXIncludeFallbackDOMPos() throws ParserConfigurationException, 
+            SAXException, IOException, TransformerException {
         String resultFile = CLASS_DIR + "doc_fallbackDOM.out";
         String goldFile = GOLDEN_DIR + "doc_fallbackGold.xml";
         String xmlFile = XML_DIR + "doc_fallback.xml";
-        try{
             try (FileOutputStream fos = new FileOutputStream(resultFile)) {
                 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
                 dbf.setXIncludeAware(true);
                 dbf.setNamespaceAware(true);
 

@@ -280,36 +318,31 @@
                 doc.setXmlStandalone(true);
                 TransformerFactory.newInstance().newTransformer()
                         .transform(new DOMSource(doc), new StreamResult(fos));
             }
             assertTrue(compareDocumentWithGold(goldFile, resultFile));
-        } catch (ParserConfigurationException | SAXException | IOException
-                | TransformerException e) {
-            failUnexpected(e);
-        } finally {
-            try {
-                Path resultPath = Paths.get(resultFile);
-                if (Files.exists(resultPath)) {
-                    Files.delete(resultPath);
-                }
-            } catch (IOException ex) {
-                failCleanup(ex, resultFile);
-            }
-        }
     }
 
     /**
      * Test for xi:fallback where the fall back text is parsed as text. This
      * test uses a nested xi:include for the fallback test.
-     */
-    @Test
-    public void testXIncludeFallbackTextPos() {
+     * 
+     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
+     *         created which satisfies the configuration requested.
+     * @throws SAXException If any parse errors occur.
+     * @throws IOException if the file exists but is a directory rather than
+     *         a regular file, does not exist but cannot be created, or cannot 
+     *         be opened for any other reason.
+     * @throws TransformerException If an unrecoverable error occurs
+     *         during the course of the transformation.
+     */
+    @Test(groups = {"readWriteLocalFiles"})
+    public void testXIncludeFallbackTextPos() throws ParserConfigurationException, 
+            SAXException, IOException, TransformerException {
         String resultFile = CLASS_DIR + "doc_fallback_text.out";
         String goldFile = GOLDEN_DIR + "doc_fallback_textGold.xml";
         String xmlFile = XML_DIR + "doc_fallback_text.xml";
-
-        try{
             try (FileOutputStream fos = new FileOutputStream(resultFile)) {
                 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
                 dbf.setXIncludeAware(true);
                 dbf.setNamespaceAware(true);
 

@@ -317,35 +350,30 @@
                 doc.setXmlStandalone(true);
                 TransformerFactory.newInstance().newTransformer()
                         .transform(new DOMSource(doc), new StreamResult(fos));
             }
             assertTrue(compareDocumentWithGold(goldFile, resultFile));
-        } catch (ParserConfigurationException | SAXException | IOException
-                | TransformerException e) {
-            failUnexpected(e);
-        } finally {
-            try {
-                Path resultPath = Paths.get(resultFile);
-                if (Files.exists(resultPath)) {
-                    Files.delete(resultPath);
-                }
-            } catch (IOException ex) {
-                failCleanup(ex, resultFile);
-            }
-        }
     }
 
     /**
      * Test the XPointer element() framework with XInclude.
-     */
-    @Test
-    public void testXpointerElementPos() {
+     * 
+     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
+     *         created which satisfies the configuration requested.
+     * @throws SAXException If any parse errors occur.
+     * @throws IOException if the file exists but is a directory rather than
+     *         a regular file, does not exist but cannot be created, or cannot 
+     *         be opened for any other reason.
+     * @throws TransformerException If an unrecoverable error occurs
+     *         during the course of the transformation.
+     */
+    @Test(groups = {"readWriteLocalFiles"})
+    public void testXpointerElementPos() throws ParserConfigurationException, 
+            TransformerException, SAXException, IOException {
         String resultFile = CLASS_DIR + "doc_xpointer_element.out";
         String goldFile = GOLDEN_DIR + "doc_xpointerGold.xml";
         String xmlFile = XML_DIR + "doc_xpointer_element.xml";
-
-        try{
             try (FileOutputStream fos = new FileOutputStream(resultFile)) {
                 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
                 dbf.setXIncludeAware(true);
                 dbf.setNamespaceAware(true);
 

@@ -354,69 +382,62 @@
                 TransformerFactory.newInstance().newTransformer()
                         .transform(new DOMSource(db.parse(new File(xmlFile))),
                                 new StreamResult(fos));
             }
             assertTrue(compareDocumentWithGold(goldFile, resultFile));
-        } catch (ParserConfigurationException | SAXException | IOException
-                | TransformerException e) {
-            failUnexpected(e);
-        } finally {
-            try {
-                Path resultPath = Paths.get(resultFile);
-                if (Files.exists(resultPath)) {
-                    Files.delete(resultPath);
-                }
-            } catch (IOException ex) {
-                failCleanup(ex, resultFile);
-            }
-        }
     }
 
     /**
      * Test the XPointer framework with a SAX object.
-     */
-    @Test
-    public void testXPointerPos() {
+     * 
+     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
+     *         created which satisfies the configuration requested.
+     * @throws SAXException If any parse errors occur.
+     * @throws IOException if the file exists but is a directory rather than
+     *         a regular file, does not exist but cannot be created, or cannot 
+     *         be opened for any other reason.
+     * @throws TransformerException If an unrecoverable error occurs
+     *         during the course of the transformation.
+     */
+    @Test(groups = {"readWriteLocalFiles"})
+    public void testXPointerPos() throws ParserConfigurationException, 
+            TransformerException, SAXException, IOException {
         String resultFile = CLASS_DIR + "doc_xpointer.out";
         String goldFile = GOLDEN_DIR + "doc_xpointerGold.xml";
         String xmlFile = XML_DIR + "doc_xpointer.xml";
 
-        try{
             try (FileOutputStream fos = new FileOutputStream(resultFile)) {
                 SAXParserFactory spf = SAXParserFactory.newInstance();
                 spf.setNamespaceAware(true);
                 spf.setXIncludeAware(true);
                 spf.setFeature(FEATURE_NAME, true);
                 // parse the file
                 spf.newSAXParser().parse(new File(xmlFile), new XInclHandler(fos, null));
             }
             assertTrue(compareDocumentWithGold(goldFile, resultFile));
-        } catch (ParserConfigurationException | SAXException | IOException e) {
-            failUnexpected(e);
-        } finally {
-            try {
-                Path resultPath = Paths.get(resultFile);
-                if (Files.exists(resultPath)) {
-                    Files.delete(resultPath);
-                }
-            } catch (IOException ex) {
-                failCleanup(ex, resultFile);
-            }
-        }
     }
 
     /**
      * Test if xi:include may reference the doc containing the include if the
      * parse type is text.
-     */
-    @Test
-    public void testXIncludeLoopPos() {
+     * 
+     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
+     *         created which satisfies the configuration requested.
+     * @throws SAXException If any parse errors occur.
+     * @throws IOException if the file exists but is a directory rather than
+     *         a regular file, does not exist but cannot be created, or cannot 
+     *         be opened for any other reason.
+     * @throws TransformerException If an unrecoverable error occurs
+     *         during the course of the transformation.
+     */
+    @Test(groups = {"readWriteLocalFiles"})
+    public void testXIncludeLoopPos() throws ParserConfigurationException, 
+            TransformerException, SAXException, IOException {
         String resultFile = CLASS_DIR + "doc_xinc_loops.out";
         String goldFile = GOLDEN_DIR + "doc_xinc_loopGold.xml";
         String xmlFile = XML_DIR + "doc_xinc_loops.xml";
 
-        try{
             try (FileOutputStream fos = new FileOutputStream(resultFile)) {
                 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
                 dbf.setXIncludeAware(true);
                 dbf.setNamespaceAware(true);
                 DocumentBuilder db = dbf.newDocumentBuilder();

@@ -426,36 +447,32 @@
 
                 TransformerFactory.newInstance().newTransformer()
                         .transform(new DOMSource(doc), new StreamResult(fos));
             }
             assertTrue(compareDocumentWithGold(goldFile, resultFile));
-        } catch (ParserConfigurationException | SAXException | IOException
-                | TransformerException e) {
-            failUnexpected(e);
-        } finally {
-            try {
-                Path resultPath = Paths.get(resultFile);
-                if (Files.exists(resultPath)) {
-                    Files.delete(resultPath);
-                }
-            } catch (IOException ex) {
-                failCleanup(ex, resultFile);
-            }
-        }
     }
 
     /**
      * Test if two non nested xi:include elements can include the same document
      * with an xi:include statement.
-     */
-    @Test
-    public void testXIncludeNestedPos() {
+     * 
+     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
+     *         created which satisfies the configuration requested.
+     * @throws SAXException If any parse errors occur.
+     * @throws IOException if the file exists but is a directory rather than
+     *         a regular file, does not exist but cannot be created, or cannot 
+     *         be opened for any other reason.
+     * @throws TransformerException If an unrecoverable error occurs
+     *         during the course of the transformation.
+     */
+    @Test(groups = {"readWriteLocalFiles"})
+    public void testXIncludeNestedPos() throws ParserConfigurationException, 
+            TransformerException, SAXException, IOException {
         String resultFile = CLASS_DIR + "schedule.out";
         String goldFile = GOLDEN_DIR + "scheduleGold.xml";
         String xmlFile = XML_DIR + "schedule.xml";
 
-        try{
             try (FileOutputStream fos = new FileOutputStream(resultFile)) {
                 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
                 dbf.setXIncludeAware(true);
                 dbf.setNamespaceAware(true);
 

@@ -463,20 +480,7 @@
                 doc.setXmlStandalone(true);
                 TransformerFactory.newInstance().newTransformer()
                         .transform(new DOMSource(doc), new StreamResult(fos));
             }
             assertTrue(compareDocumentWithGold(goldFile, resultFile));
-        } catch (ParserConfigurationException | SAXException | IOException
-                | TransformerException e) {
-            failUnexpected(e);
-        } finally {
-            try {
-                Path resultPath = Paths.get(resultFile);
-                if (Files.exists(resultPath)) {
-                    Files.delete(resultPath);
-                }
-            } catch (IOException ex) {
-                failCleanup(ex, resultFile);
-            }
-        }
     }
 }
< prev index next >