/*
 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package org.xml.sax.ptests;

import java.io.FileInputStream;
import java.io.FilePermission;
import java.io.IOException;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParserFactory;
import jaxp.library.JAXPBaseTest;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.assertTrue;
import org.testng.annotations.AfterGroups;
import org.testng.annotations.BeforeGroups;
import org.testng.annotations.Test;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLFilterImpl;
import static org.xml.sax.ptests.SAXTestConst.XML_DIR;

/**
 * Unit test for XMLFilter.
 */
public class XMLFilterTest extends JAXPBaseTest {
    /**
     * name spaces constant.
     */
    private static final String NAMESPACES =
                "http://xml.org/sax/features/namespaces";

    /**
     * name spaces prefixes constant.
     */
    private static final String NAMESPACE_PREFIXES =
                "http://xml.org/sax/features/namespace-prefixes";

    /**
     * No exception expected when set a correct content handler.
     */
    @Test
    public void contentHandler01() {
        XMLFilterImpl xmlFilter = new XMLFilterImpl();
        xmlFilter.setContentHandler(xmlFilter);
        assertNotNull(xmlFilter.getContentHandler());
    }

    /**
     * No exception is expected when set content handler as null.
     */
    @Test
    public void contentHandler02() {
        new XMLFilterImpl().setContentHandler(null);
    }

    /**
     * No exception expected when set a correct entity solver.
     */
    @Test
    public void entity01() {
        XMLFilterImpl xmlFilter = new XMLFilterImpl();
        xmlFilter.setEntityResolver(xmlFilter);
        assertNotNull(xmlFilter.getEntityResolver());
    }

    /**
     * No exception is expected when set entity resolver as null.
     */
    @Test
    public void entity02() {
        new XMLFilterImpl().setEntityResolver(null);
    }

    /**
     * No exception expected when set a correct DTD handler.
     */
    @Test
    public void dtdHandler01() {
        XMLFilterImpl xmlFilter = new XMLFilterImpl();
        xmlFilter.setDTDHandler(xmlFilter);
        assertNotNull(xmlFilter.getDTDHandler());
    }

    /**
     * No exception is expected when set DTD handler as null.
     */
    @Test
    public void dtdHandler02() {
        new XMLFilterImpl().setDTDHandler(null);
    }

    /**
     * No exception expected when set a correct error handler.
     */
    @Test
    public void errorHandler01() {
        XMLFilterImpl xmlFilter = new XMLFilterImpl();
        xmlFilter.setErrorHandler(xmlFilter);
        assertNotNull(xmlFilter.getErrorHandler());
    }

    /**
     * No exception is expected when set error handler as null.
     */
    @Test
    public void errorHandler02() {
        new XMLFilterImpl().setErrorHandler(null);
    }

    /**
     * By default true is expected get namespaces feature.
     * 
     * @throws SAXException If there is a problem processing the document.
     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
     *         created which satisfies the configuration requested.
     */
    @Test
    public void getFeature01() throws SAXException, ParserConfigurationException {
        SAXParserFactory spf = SAXParserFactory.newInstance();
        spf.setNamespaceAware(true);
        XMLReader xmlReader = spf.newSAXParser().getXMLReader();

        XMLFilterImpl xmlFilter = new XMLFilterImpl();
        xmlFilter.setParent(xmlReader);
        assertTrue(xmlFilter.getFeature(NAMESPACES));
    }

    /**
     * By default false is expected get namespaces-prefix feature.
     * 
     * @throws SAXException If there is a problem processing the document.
     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
     *         created which satisfies the configuration requested.
     */
    @Test
    public void getFeature02() throws ParserConfigurationException, SAXException {
        SAXParserFactory spf = SAXParserFactory.newInstance();
        spf.setNamespaceAware(true);
        XMLFilterImpl xmlFilter = new XMLFilterImpl();
        xmlFilter.setParent(spf.newSAXParser().getXMLReader());
        assertFalse(xmlFilter.getFeature(NAMESPACE_PREFIXES));
    }

    /**
     * SAXNotRecognizedException is expected when get a feature by an invalid
     * feature name.
     * @throws org.xml.sax.SAXNotRecognizedException If the feature
     *            value can't be assigned or retrieved from the parent.
     * @throws org.xml.sax.SAXNotSupportedException When the
     *            parent recognizes the feature name but
     *            cannot determine its value at this time.
     */
    @Test(expectedExceptions = SAXNotRecognizedException.class)
    public void getFeature03() throws SAXNotRecognizedException,
           SAXNotSupportedException {
        new XMLFilterImpl().getFeature("no-meaning-feature");
    }

    /**
     * Set namespaces feature to a value to XMLFilter. it's expected same when
     * obtain it again.
     * 
     * @throws SAXException If there is a problem processing the document.
     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
     *         created which satisfies the configuration requested.
     */
    @Test
    public void setFeature01() throws ParserConfigurationException, SAXException {
        SAXParserFactory spf = SAXParserFactory.newInstance();
        spf.setNamespaceAware(true);

        XMLFilterImpl xmlFilter = new XMLFilterImpl();
        xmlFilter.setParent(spf.newSAXParser().getXMLReader());
        xmlFilter.setFeature(NAMESPACES, false);
        assertFalse(xmlFilter.getFeature(NAMESPACES));
        xmlFilter.setFeature(NAMESPACES, true);
        assertTrue(xmlFilter.getFeature(NAMESPACES));
    }

    /**
     * Set namespaces-prefix feature to a value to XMLFilter. it's expected same
     * when obtain it again.
     * 
     * @throws SAXException If there is a problem processing the document.
     * @throws ParserConfigurationException if a DocumentBuilder cannot be 
     *         created which satisfies the configuration requested.
     */
    @Test
    public void setFeature02() throws ParserConfigurationException, SAXException {
        SAXParserFactory spf = SAXParserFactory.newInstance();
        spf.setNamespaceAware(true);

        XMLFilterImpl xmlFilter = new XMLFilterImpl();
        xmlFilter.setParent(spf.newSAXParser().getXMLReader());
        xmlFilter.setFeature(NAMESPACE_PREFIXES, false);
        assertFalse(xmlFilter.getFeature(NAMESPACE_PREFIXES));
        xmlFilter.setFeature(NAMESPACE_PREFIXES, true);
        assertTrue(xmlFilter.getFeature(NAMESPACE_PREFIXES));
    }

    /**
     * NullPointerException is expected when parse a null InputSource.
     * 
     * @throws SAXException If there is a problem processing the document.
     * @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 = NullPointerException.class)
    public void parse01() throws SAXException, IOException {
        new XMLFilterImpl().parse((InputSource)null);
    }
  
    /**
     * Save system property for restoring.
     */
    @BeforeGroups (groups = {"readLocalFiles"})
    public void setFilePermissions() {
        setPermissions(new FilePermission(XML_DIR + "/-", "read"));
    }
    
    /**
     * Restore the system property.
     */
    @AfterGroups (groups = {"readLocalFiles"})
    public void restoreFilePermissions() {
        setPermissions();
    }

    /**
     * SAXException is expected when parsing a invalid formatted XML file.
     * 
     * @throws SAXException when parse a incorrect formatted XML file.
     * @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 = {"readLocalFiles"}, expectedExceptions = NullPointerException.class)
    public void parse02() throws SAXException, IOException {
        try(FileInputStream fis = new FileInputStream(XML_DIR + "invalid.xml")) {
            new XMLFilterImpl().parse(new InputSource(fis));
        } 
    }

    /**
     * No exception when parse a normal XML file.
     * 
     * @throws SAXException when parse a incorrect formatted XML file.
     * @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 = {"readLocalFiles"}, expectedExceptions = NullPointerException.class)
    public void parse03() throws SAXException, IOException {
        try(FileInputStream fis = new FileInputStream(XML_DIR + "correct2.xml")) {
            new XMLFilterImpl().parse(new InputSource(fis));
        }
    }
}