public boolean testCase2()

in java/src/org/apache/qetest/trax/dom/DOMResultAPITest.java [217:386]
146 lines of code
7 McCabe index (conditional complexity)

    public boolean testCase2()
    {
        reporter.testCaseInit("Basic functionality of DOMResults");

        DocumentBuilder docBuilder = null;
        TransformerFactory factory = null;
        Templates templates = null;
        Transformer transformer = null;
        Node xmlNode = null;
        Node xslNode = null;
        Node xslImpInclNode = null;
        Node xmlImpInclNode = null;
        try
        {
            factory = TransformerFactory.newInstance();
            factory.setErrorListener(new DefaultErrorHandler());
            DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance();
            dfactory.setNamespaceAware(true);
            docBuilder = dfactory.newDocumentBuilder();
            reporter.logTraceMsg("parsing xml, xsl files");
            xslNode = docBuilder.parse(new InputSource(testFileInfo.inputName));
            xmlNode = docBuilder.parse(new InputSource(testFileInfo.xmlName));
            xslImpInclNode = docBuilder.parse(new InputSource(impInclFileInfo.inputName));
            xmlImpInclNode = docBuilder.parse(new InputSource(impInclFileInfo.xmlName));
        }
        catch (Throwable t)
        {
            reporter.checkFail("Problem creating factory; can't continue testcase");
            reporter.logThrowable(reporter.ERRORMSG, t,
                                  "Problem creating factory; can't continue testcase");
            reporter.testCaseClose();
            return true;
        }
        try
        {
            // Try to get templates, transformer from node
            DOMSource xslSource = new DOMSource(xslNode);
            templates = factory.newTemplates(xslSource);
            DOMSource xmlSource = new DOMSource(xmlNode);
            
            // Transforming into a DOMResult with a node is already 
            //  well covered in DOMSourceAPITest and elsewhere
            // Verify a 'blank' Result object gets filled up properly
            DOMResult blankResult = new DOMResult();
            transformer = templates.newTransformer();
            transformer.setErrorListener(new DefaultErrorHandler());
            transformer.transform(xmlSource, blankResult);
            reporter.logTraceMsg("blankResult is now: " + blankResult);
            Node blankNode = blankResult.getNode();
            if (blankNode != null)
            {
                serializeDOMAndCheck(blankNode, testFileInfo.goldName, "transform into blank DOMResult");
            }
            else
            {
                reporter.checkFail("transform into 'blank' DOMResult");
            }
        }
        catch (Throwable t)
        {
            reporter.checkFail("Problem with blank results");
            reporter.logThrowable(reporter.ERRORMSG, t,
                                  "Problem with blank results");
        }
        boolean reusePass = false;
        try
        {
            DOMSource xmlSource = new DOMSource(xmlNode);
            DOMSource xslSource = new DOMSource(xslNode);
            templates = factory.newTemplates(xslSource);
            
            // Reuse the same result for multiple transforms
            DOMResult reuseResult = new DOMResult(docBuilder.newDocument());
            transformer = templates.newTransformer();
            transformer.setErrorListener(new DefaultErrorHandler());
            transformer.transform(xmlSource, reuseResult);
            Node reuseNode = reuseResult.getNode();
            serializeDOMAndCheck(reuseNode, testFileInfo.goldName, "transform into reuseable1 DOMResult");
            
            // Get a new transformer just to avoid extra complexity
            reporter.logTraceMsg("About to re-use DOMResult from previous transform, should throw");
            transformer = templates.newTransformer();
            transformer.setErrorListener(new DefaultErrorHandler());
            reusePass = true; // Next line should throw an exception
            transformer.transform(xmlSource, reuseResult); // SPR SCUU4RJKG4 throws DOM006
            reporter.checkFail("Re-using DOMResult should have thrown exception", "SCUU4RJKG4");
        }
        catch (Throwable t)
        {
            reporter.check(reusePass, true, "Re-using DOMResult throws exception properly");
            reporter.logThrowable(reporter.ERRORMSG, t,
                                  "Re-using DOMResult throws exception properly");
            reporter.logTraceMsg("@todo Should validate specific kind of error above");
        }
        try
        {
            DOMSource xmlSource = new DOMSource(xmlNode);
            DOMSource xslSource = new DOMSource(xslNode);
            templates = factory.newTemplates(xslSource);
            
            // Reuse the same result for multiple transforms, after resetting node
            DOMResult reuseResult = new DOMResult(docBuilder.newDocument());
            transformer = templates.newTransformer();
            transformer.setErrorListener(new DefaultErrorHandler());
            transformer.transform(xmlSource, reuseResult);
            Node reuseNode = reuseResult.getNode();
            serializeDOMAndCheck(reuseNode, testFileInfo.goldName, "transform into reuseable2 DOMResult");
            
            // Get a new transformer just to avoid extra complexity
            reporter.logTraceMsg("About to re-use DOMResult from previous transform after setNode()");
            transformer = templates.newTransformer();
            transformer.setErrorListener(new DefaultErrorHandler());
            reuseResult.setNode(docBuilder.newDocument());
            transformer.transform(xmlSource, reuseResult);
            reuseNode = reuseResult.getNode();
            serializeDOMAndCheck(reuseNode, testFileInfo.goldName, "transform into reused2 DOMResult");

            // Reuse again, with the same transformer
            reuseResult.setNode(docBuilder.newDocument());
            transformer.transform(xmlSource, reuseResult);
            reuseNode = reuseResult.getNode();
            serializeDOMAndCheck(reuseNode, testFileInfo.goldName, "transform into reused2 DOMResult again");
        }
        catch (Throwable t)
        {
            reporter.checkFail("Problem with re-using results(2)");
            reporter.logThrowable(reporter.ERRORMSG, t,
                                  "Problem with re-using results(2)");
        }

        try
        {
            // The gold file when transforming with a DOMResult created by
            // the DOMResult(Node node, Node nextSibling) constructor.
            String goldFileName2 = goldDir 
                              + File.separator 
                              + TRAX_DOM_SUBDIR
                              + File.separator
                              + "DOMTest2.out";
            
            DOMSource xmlSource = new DOMSource(xmlNode);
	    DOMSource xslSource = new DOMSource(xslNode);
            templates = factory.newTemplates(xslSource);
            
            // Create a DOMResult using the DOMResult(Node node, Node nextSibling) constructor
            Document doc = docBuilder.newDocument();
            Element a = doc.createElementNS("", "a");
            Element b = doc.createElementNS("", "b");
            Element c = doc.createElementNS("", "c");
            doc.appendChild(a);
            a.appendChild(b);
            a.appendChild(c);
            DOMResult result = new DOMResult(a, c);
            
            transformer = templates.newTransformer();
            transformer.setErrorListener(new DefaultErrorHandler());
            transformer.transform(xmlSource, result);
            Node resultNode = result.getNode();
            serializeDOMAndCheck(resultNode, goldFileName2, "transform into DOMResult with nextSibling");            
        }
        catch (Throwable t)
        {
            reporter.checkFail("Problem with DOMResult with nextSibling");
            reporter.logThrowable(reporter.ERRORMSG, t,
                                  "Problem with DOMResult with nextSibling");        
        }

        reporter.testCaseClose();
        return true;
    }