Java 类org.w3c.dom.ls.LSParserFilter 实例源码

public void endDocument()
  throws SAXException
{
  if (interrupted)
    {
      return;
    }
  super.endDocument();

  switch (getDecision(ctx, false))
    {
    case LSParserFilter.FILTER_REJECT:
      ctx = null;
      doc = null;
      break;
    }

  nodes = null;
  decisions = null;
}

public void startElement(String uri, String localName, String qName,
                         Attributes atts)
  throws SAXException
{
  if (rejecting || interrupted)
    {
      return;
    }
  Element element = createElement(uri, localName, qName, atts);
  ctx = element;

  short decision = getDecision(element, true);
  nodes.addLast(element);
  decisions.addLast(new Short(decision));

  switch (decision)
    {
    case LSParserFilter.FILTER_REJECT:
      rejecting = true;
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void characters(char[] c, int off, int len)
  throws SAXException
{
  if (rejecting || interrupted)
    {
      return;
    }
  Text text = createText(c, off, len);
  short decision = getDecision(text, false);
  switch (decision)
    {
    case LSParserFilter.FILTER_ACCEPT:
      ctx.appendChild(text);
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void processingInstruction(String target, String data)
  throws SAXException
{
  if (rejecting || interrupted || inDTD)
    {
      return;
    }
  Node pi = createProcessingInstruction(target, data);
  short decision = getDecision(pi, false);
  switch (decision)
    {
    case LSParserFilter.FILTER_ACCEPT:
      ctx.appendChild(pi);
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void endDTD()
  throws SAXException
{
  if (interrupted)
    {
      return;
    }
  Node doctype = (Node) nodes.removeLast();
  decisions.removeLast();
  inDTD = false;
  ctx = doc;
  short decision = getDecision(doctype, false);
  switch (decision)
    {
    case LSParserFilter.FILTER_ACCEPT:
      ctx.appendChild(doctype);
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void endDocument()
  throws SAXException
{
  if (interrupted)
    {
      return;
    }
  super.endDocument();

  switch (getDecision(ctx, false))
    {
    case LSParserFilter.FILTER_REJECT:
      ctx = null;
      doc = null;
      break;
    }

  nodes = null;
  decisions = null;
}

public void startElement(String uri, String localName, String qName,
                         Attributes atts)
  throws SAXException
{
  if (rejecting || interrupted)
    {
      return;
    }
  Element element = createElement(uri, localName, qName, atts);
  ctx = element;

  short decision = getDecision(element, true);
  nodes.addLast(element);
  decisions.addLast(new Short(decision));

  switch (decision)
    {
    case LSParserFilter.FILTER_REJECT:
      rejecting = true;
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void characters(char[] c, int off, int len)
  throws SAXException
{
  if (rejecting || interrupted)
    {
      return;
    }
  Text text = createText(c, off, len);
  short decision = getDecision(text, false);
  switch (decision)
    {
    case LSParserFilter.FILTER_ACCEPT:
      ctx.appendChild(text);
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void processingInstruction(String target, String data)
  throws SAXException
{
  if (rejecting || interrupted || inDTD)
    {
      return;
    }
  Node pi = createProcessingInstruction(target, data);
  short decision = getDecision(pi, false);
  switch (decision)
    {
    case LSParserFilter.FILTER_ACCEPT:
      ctx.appendChild(pi);
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void endDTD()
  throws SAXException
{
  if (interrupted)
    {
      return;
    }
  Node doctype = (Node) nodes.removeLast();
  decisions.removeLast();
  inDTD = false;
  ctx = doc;
  short decision = getDecision(doctype, false);
  switch (decision)
    {
    case LSParserFilter.FILTER_ACCEPT:
      ctx.appendChild(doctype);
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void endDocument()
  throws SAXException
{
  if (interrupted)
    {
      return;
    }
  super.endDocument();

  switch (getDecision(ctx, false))
    {
    case LSParserFilter.FILTER_REJECT:
      ctx = null;
      doc = null;
      break;
    }

  nodes = null;
  decisions = null;
}

public void startElement(String uri, String localName, String qName,
                         Attributes atts)
  throws SAXException
{
  if (rejecting || interrupted)
    {
      return;
    }
  Element element = createElement(uri, localName, qName, atts);
  ctx = element;

  short decision = getDecision(element, true);
  nodes.addLast(element);
  decisions.addLast(new Short(decision));

  switch (decision)
    {
    case LSParserFilter.FILTER_REJECT:
      rejecting = true;
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void characters(char[] c, int off, int len)
  throws SAXException
{
  if (rejecting || interrupted)
    {
      return;
    }
  Text text = createText(c, off, len);
  short decision = getDecision(text, false);
  switch (decision)
    {
    case LSParserFilter.FILTER_ACCEPT:
      ctx.appendChild(text);
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void processingInstruction(String target, String data)
  throws SAXException
{
  if (rejecting || interrupted || inDTD)
    {
      return;
    }
  Node pi = createProcessingInstruction(target, data);
  short decision = getDecision(pi, false);
  switch (decision)
    {
    case LSParserFilter.FILTER_ACCEPT:
      ctx.appendChild(pi);
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void endDTD()
  throws SAXException
{
  if (interrupted)
    {
      return;
    }
  Node doctype = (Node) nodes.removeLast();
  decisions.removeLast();
  inDTD = false;
  ctx = doc;
  short decision = getDecision(doctype, false);
  switch (decision)
    {
    case LSParserFilter.FILTER_ACCEPT:
      ctx.appendChild(doctype);
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void endDocument()
  throws SAXException
{
  if (interrupted)
    {
      return;
    }
  super.endDocument();

  switch (getDecision(ctx, false))
    {
    case LSParserFilter.FILTER_REJECT:
      ctx = null;
      doc = null;
      break;
    }

  nodes = null;
  decisions = null;
}

public void startElement(String uri, String localName, String qName,
                         Attributes atts)
  throws SAXException
{
  if (rejecting || interrupted)
    {
      return;
    }
  Element element = createElement(uri, localName, qName, atts);
  ctx = element;

  short decision = getDecision(element, true);
  nodes.addLast(element);
  decisions.addLast(new Short(decision));

  switch (decision)
    {
    case LSParserFilter.FILTER_REJECT:
      rejecting = true;
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void characters(char[] c, int off, int len)
  throws SAXException
{
  if (rejecting || interrupted)
    {
      return;
    }
  Text text = createText(c, off, len);
  short decision = getDecision(text, false);
  switch (decision)
    {
    case LSParserFilter.FILTER_ACCEPT:
      ctx.appendChild(text);
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void processingInstruction(String target, String data)
  throws SAXException
{
  if (rejecting || interrupted || inDTD)
    {
      return;
    }
  Node pi = createProcessingInstruction(target, data);
  short decision = getDecision(pi, false);
  switch (decision)
    {
    case LSParserFilter.FILTER_ACCEPT:
      ctx.appendChild(pi);
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

public void endDTD()
  throws SAXException
{
  if (interrupted)
    {
      return;
    }
  Node doctype = (Node) nodes.removeLast();
  decisions.removeLast();
  inDTD = false;
  ctx = doc;
  short decision = getDecision(doctype, false);
  switch (decision)
    {
    case LSParserFilter.FILTER_ACCEPT:
      ctx.appendChild(doctype);
      break;
    case LSParserFilter.FILTER_INTERRUPT:
      interrupted = true;
      break;
    }
}

/**
 * Equivalence class partitioning
 * with state, input and output values orientation
 * for public Document parse(LSInput is),
 * <br><b>pre-conditions</b>: set filter that REJECTs any CHILD* node,
 * <br><b>is</b>: xml1
 * <br><b>output</b>: XML document with ELEMNENT1 and ELEMENT2 only.
 */
@Test
public void testfilter0001() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            if (enode.getNodeName().startsWith("CHILD")) {
                return FILTER_REJECT;
            }
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    String expected = "<?xml version=\"1.0\"?><ROOT><ELEMENT1></ELEMENT1><ELEMENT2>test1</ELEMENT2></ROOT>";
    Document doc = parser.parse(getXmlSource(xml1));
    if (!match(expected, doc)) {
        Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed");
    }

    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that SKIPs ELEMENT1 node, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: XML document with CHILD1 and ELEMENT2 only.
 */
@Test
public void testFilter0002() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            if (enode.getNodeName().startsWith("ELEMENT1")) {
                return FILTER_SKIP;
            }
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    String expected = "<?xml version=\"1.0\"?><ROOT><CHILD1/><CHILD1><COC1/></CHILD1><ELEMENT2>test1<CHILD2/></ELEMENT2></ROOT>";
    Document doc = parser.parse(getXmlSource(xml1));
    if (!match(expected, doc)) {
        Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that SKIPs ELEMENT1 node, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: XML document with ELEMENT1 only.
 */
@Test
public void testFilter0003() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            if (enode.getNodeName().startsWith("ELEMENT2")) {
                return FILTER_INTERRUPT;
            }
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    String expected = "<ROOT><ELEMENT1><CHILD1/><CHILD1><COC1/></CHILD1></ELEMENT1></ROOT>";
    Document doc = parser.parse(getXmlSource(xml1));
    if (!match(expected, doc)) {
        Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that accepts all, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: full XML document.
 */
@Test
public void testFilter0004() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    String expected = "<ROOT><ELEMENT1><CHILD1/><CHILD1><COC1/></CHILD1></ELEMENT1><ELEMENT2>test1<CHILD2/></ELEMENT2></ROOT>";
    Document doc = parser.parse(getXmlSource(xml1));
    if (!match(expected, doc)) {
        Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that REJECTs all, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: empty XML document.
 */
@Test
public void testFilter0005() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            return FILTER_REJECT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    Document doc = parser.parse(getXmlSource(xml1));
    NodeList children = doc.getDocumentElement().getChildNodes();
    if (children.getLength() != 0) {
        Assert.fail("Not all children skipped");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that SKIPs all, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: empty XML document.
 */
@Test
public void testFilter0006() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            return FILTER_SKIP;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    Document doc = parser.parse(getXmlSource(xml1));
    NodeList children = doc.getDocumentElement().getChildNodes();
    if (children.getLength() != 0) {
        Assert.fail("Not all children skipped");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that REJECTs any CHILD* start element, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: XML document with ELEMENT1 and ELEMENT2 only.
 */
@Test
public void testFilter0007() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            if (elt.getTagName().startsWith("CHILD")) {
                return FILTER_REJECT;
            }
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    String expected = "<?xml version=\"1.0\"?><ROOT><ELEMENT1></ELEMENT1><ELEMENT2>test1</ELEMENT2></ROOT>";
    Document doc = parser.parse(getXmlSource(xml1));
    if (!match(expected, doc)) {
        Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that SKIPs ELEMENT1 start element, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: XML document with CHILD1 and ELEMENT2 only.
 */
@Test
public void testFilter0008() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            if (elt.getTagName().equals("ELEMENT1")) {
                return FILTER_SKIP;
            }
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    String expected = "<?xml version=\"1.0\"?><ROOT><CHILD1/><CHILD1><COC1/></CHILD1><ELEMENT2>test1<CHILD2/></ELEMENT2></ROOT>";
    Document doc = parser.parse(getXmlSource(xml1));
    if (!match(expected, doc)) {
        Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that SKIPs ELEMENT1 start element, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: XML document with ELEMENT1 only.
 */
@Test
public void testFilter0009() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            if (elt.getTagName().startsWith("ELEMENT2")) {
                return FILTER_INTERRUPT;
            }
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    String expected = "<ROOT><ELEMENT1><CHILD1/><CHILD1><COC1/></CHILD1></ELEMENT1></ROOT>";
    Document doc = parser.parse(getXmlSource(xml1));
    if (!match(expected, doc)) {
        Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that REJECTs all start element, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: empty XML document.
 */
@Test
public void testFilter0010() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            return FILTER_REJECT;
        }

        public short acceptNode(Node enode) {
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    Document doc = parser.parse(getXmlSource(xml1));
    NodeList children = doc.getDocumentElement().getChildNodes();
    if (children.getLength() != 0) {
        Assert.fail("Not all children skipped");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that SKIPs all, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: empty XML document.
 */
@Test
public void testFilter0011() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            return FILTER_SKIP;
        }

        public short acceptNode(Node enode) {
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    Document doc = parser.parse(getXmlSource(xml1));
    NodeList children = doc.getDocumentElement().getChildNodes();
    if (children.getLength() != 1) {
        Assert.fail("Not all Element nodes skipped");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning
 * with state, input and output values orientation
 * for public Document parse(LSInput is),
 * <br><b>pre-conditions</b>: set filter that REJECTs any CHILD* node,
 * <br><b>is</b>: xml1
 * <br><b>output</b>: XML document with ELEMNENT1 and ELEMENT2 only.
 */
@Test
public void testfilter0001() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            if (enode.getNodeName().startsWith("CHILD")) {
                return FILTER_REJECT;
            }
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    String expected = "<?xml version=\"1.0\"?><ROOT><ELEMENT1></ELEMENT1><ELEMENT2>test1</ELEMENT2></ROOT>";
    Document doc = parser.parse(getXmlSource(xml1));
    if (!match(expected, doc)) {
        Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed");
    }

    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that SKIPs ELEMENT1 node, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: XML document with CHILD1 and ELEMENT2 only.
 */
@Test
public void testFilter0002() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            if (enode.getNodeName().startsWith("ELEMENT1")) {
                return FILTER_SKIP;
            }
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    String expected = "<?xml version=\"1.0\"?><ROOT><CHILD1/><CHILD1><COC1/></CHILD1><ELEMENT2>test1<CHILD2/></ELEMENT2></ROOT>";
    Document doc = parser.parse(getXmlSource(xml1));
    if (!match(expected, doc)) {
        Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that SKIPs ELEMENT1 node, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: XML document with ELEMENT1 only.
 */
@Test
public void testFilter0003() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            if (enode.getNodeName().startsWith("ELEMENT2")) {
                return FILTER_INTERRUPT;
            }
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    String expected = "<ROOT><ELEMENT1><CHILD1/><CHILD1><COC1/></CHILD1></ELEMENT1></ROOT>";
    Document doc = parser.parse(getXmlSource(xml1));
    if (!match(expected, doc)) {
        Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that accepts all, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: full XML document.
 */
@Test
public void testFilter0004() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    String expected = "<ROOT><ELEMENT1><CHILD1/><CHILD1><COC1/></CHILD1></ELEMENT1><ELEMENT2>test1<CHILD2/></ELEMENT2></ROOT>";
    Document doc = parser.parse(getXmlSource(xml1));
    if (!match(expected, doc)) {
        Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that REJECTs all, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: empty XML document.
 */
@Test
public void testFilter0005() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            return FILTER_REJECT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    Document doc = parser.parse(getXmlSource(xml1));
    NodeList children = doc.getDocumentElement().getChildNodes();
    if (children.getLength() != 0) {
        Assert.fail("Not all children skipped");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that SKIPs all, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: empty XML document.
 */
@Test
public void testFilter0006() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            return FILTER_SKIP;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    Document doc = parser.parse(getXmlSource(xml1));
    NodeList children = doc.getDocumentElement().getChildNodes();
    if (children.getLength() != 0) {
        Assert.fail("Not all children skipped");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that REJECTs any CHILD* start element, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: XML document with ELEMENT1 and ELEMENT2 only.
 */
@Test
public void testFilter0007() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            if (elt.getTagName().startsWith("CHILD")) {
                return FILTER_REJECT;
            }
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    String expected = "<?xml version=\"1.0\"?><ROOT><ELEMENT1></ELEMENT1><ELEMENT2>test1</ELEMENT2></ROOT>";
    Document doc = parser.parse(getXmlSource(xml1));
    if (!match(expected, doc)) {
        Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that SKIPs ELEMENT1 start element, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: XML document with CHILD1 and ELEMENT2 only.
 */
@Test
public void testFilter0008() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            if (elt.getTagName().equals("ELEMENT1")) {
                return FILTER_SKIP;
            }
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    String expected = "<?xml version=\"1.0\"?><ROOT><CHILD1/><CHILD1><COC1/></CHILD1><ELEMENT2>test1<CHILD2/></ELEMENT2></ROOT>";
    Document doc = parser.parse(getXmlSource(xml1));
    if (!match(expected, doc)) {
        Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed");
    }
    System.out.println("OKAY");
}

/**
 * Equivalence class partitioning with state, input and output values
 * orientation for public Document parse(LSInput is), <br>
 * <b>pre-conditions</b>: set filter that SKIPs ELEMENT1 start element, <br>
 * <b>is</b>: xml1 <br>
 * <b>output</b>: XML document with ELEMENT1 only.
 */
@Test
public void testFilter0009() {
    LSParser parser = createLSParser();
    if (parser == null) {
        Assert.fail("Unable to create LSParser!");
    }
    // set filter
    parser.setFilter(new LSParserFilter() {
        public short startElement(Element elt) {
            if (elt.getTagName().startsWith("ELEMENT2")) {
                return FILTER_INTERRUPT;
            }
            return FILTER_ACCEPT;
        }

        public short acceptNode(Node enode) {
            return FILTER_ACCEPT;
        }

        public int getWhatToShow() {
            return NodeFilter.SHOW_ALL;
        }
    });
    String expected = "<ROOT><ELEMENT1><CHILD1/><CHILD1><COC1/></CHILD1></ELEMENT1></ROOT>";
    Document doc = parser.parse(getXmlSource(xml1));
    if (!match(expected, doc)) {
        Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed");
    }
    System.out.println("OKAY");
}