testverifier.java

一个java操作xml的完整示例

package org.jdom.test.cases;

/*-- 

 Copyright (C) 2000 Brett McLaughlin & Jason Hunter.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:
 
 1. Redistributions of source code must retain the above copyright
	notice, this list of conditions, and the following disclaimer.
 
 2. Redistributions in binary form must reproduce the above copyright
	notice, this list of conditions, and the disclaimer that follows 
	these conditions in the documentation and/or other materials 
	provided with the distribution.

 3. The name "JDOM" must not be used to endorse or promote products
	derived from this software without prior written permission.  For
	written permission, please contact [e-mail].
 
 4. Products derived from this software may not be called "JDOM", nor
	may "JDOM" appear in their name, without prior written permission
	from the JDOM Project Management ([e-mail]).
 
 In addition, we request (but do not require) that you include in the 
 end-user documentation provided with the redistribution and/or in the 
 software itself an acknowledgement equivalent to the following:
	 "This product includes software developed by the
	  JDOM Project (http://www.jdom.org/)."
 Alternatively, the acknowledgment may be graphical using the logos 
 available at http://www.jdom.org/images/logos.

 THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED.  IN NO EVENT SHALL THE JDOM AUTHORS OR THE PROJECT
 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 SUCH DAMAGE.

 This software consists of voluntary contributions made by many 
 individuals on behalf of the JDOM Project and was originally 
 created by Brett McLaughlin <[e-mail]> and 
 Jason Hunter <[e-mail]>.  For more information on the 
 JDOM Project, please see <http://www.jdom.org/>.
 
 */

/**
 * Please put a description of your test here.
 * 
 * @author unascribed
 * @version 0.1
 */
import junit.framework.*;

import org.jdom.*;
import java.io.*;
import java.util.*;
import org.jdom.input.*;

public final class TestVerifier extends junit.framework.TestCase {

	/**
	 * the all characters class that must be accepted by processor
	 */
	private org.jdom.Element allCharacters;
	/**
	 * XML Base Characters
	 */
	private org.jdom.Element characters;
	/**
	 * XML CombiningCharacters
	 */
	private org.jdom.Element combiningChars;
	/**
	 * XML Digits
	 */
	private org.jdom.Element digits;
	/**
	 * XML Extender characters
	 */
	private org.jdom.Element extenders;
	/**
	 * XML IdeoCharacters
	 */
	private Element ideochars;
	/**
	 * XML Letter characters
	 */
	private org.jdom.Element letters;
	/**
	 * Resource Bundle for various testing resources
	 */
	private ResourceBundle rb = ResourceBundle.getBundle("org.jdom.test.Test");
	/**
	 * resourceRoot is the directory relative to running root where
	 * resources are found
	 */

	private String resourceRoot;

	/**
	 * AntiRangeIterator is the opposite of RangeIterator
	 * it iterates up to and between all the valid values
	 * for the JDOM Element passed in the constructor and
	 * returns invalid xml char values for the specified
	 * type
	 */
	class AntiRangeIterator {
		int start= 0;
		int code= 0;
		RangeIterator it;

		public AntiRangeIterator(Element el) {
			super();
			it= new RangeIterator(el);
			code= (int) ((Character) it.next()).charValue();
		}

		/**
		 * return the next invalid char
		 */
		public char next() {

			//have we caught up to the current valid code?
			if (code - start > 1) {
				++start;
				return (char) start;
			}
			//must have been a sequential number so loop until we get
			//past this range
			while (code - start == 1 && it.hasNext()) {

				start= code;

				code= (int) ((Character) it.next()).charValue();
			}
			if (it.hasNext()) {
				return (char) ++start;
			} else {
				//all done! return a value above the highest in the range
				return (char) (code + 2);
			}

		}

		/**
		 * is there another invalid char
		 */
		public boolean hasNext() {
			//first pass

			if (it.hasNext())
				return true;
			//all the ranges have been read so now we just iterate
			//to the last invalid char
			return (code > start && start != code - 1);
		}
		/**
		 * iterator candy - unimplemented
		 */
		public void remove() {
		}
	}

	/**
	 * RangeIterator iterates over the ranges of valid
	 * xml characters based on the type passed in as
	 * a JDOM Element.  The xml was originally part of the xml
	 * spec..
	 */
	class RangeIterator implements Iterator {

		StringTokenizer ranges;

		/**
		 * the code for the current char
		 */
		int current= 0;

		/**
		 * the code for the starting char in the current range
		 */
		int start= 0;

		/**
		 * the code for the last char in the current range
		 */
		int end= 0;

		public RangeIterator(Element el) {
			String content= el.getText();

			ranges= new StringTokenizer(content, "|");

		}
		/**
		 * is the next valid char available
		 */
		public boolean hasNext() {

			if (current +1 >= 0x10000) {
				//java can't handle 32 bit unicode chars
				return false;
			} else if (ranges.hasMoreElements()) {
				return true;
			} else if (end - current > 1) {
				return true;
			} else {
				return false;
			}

		}

		/**
		 * return the next valid char
		 */
		public Object next() {
			if (current == end) {
				//get the next token and load a new range
				String range= ranges.nextToken();
				if (range == null) {
					return null;
                                }

				//now parse the ranges into hex strings
				if (range.indexOf('[') >= 0) {
					String startText=
						"0x" + range.substring(range.indexOf('[') + 3, range.indexOf('-'));
					String endText=
						"0x" + range.substring(range.indexOf('-') + 3, range.indexOf(']'));
					//was there a range?
					if (endText.equals("0x")) {
						start= Integer.decode(startText).intValue();
						end= start;
						current= start;
					} else {
						start= Integer.decode(startText).intValue();
						end= Integer.decode(endText).intValue();
						current= start;

					}

					return new Character((char) start);
				} else {
					//character is not in a range
					String startText= range.trim();
					startText= startText.replace('#', '0');
					start= Integer.decode(startText).intValue();
					end= start;
					current= start;
					return new Character((char) current);

				}

			} else {
				// just increment withing the range