ide/schema2beans/test/unit/data/TestBook.java - netbeans - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 /*
  *	TestBook - test the basic features.
  *
  *	The following test assumes that we know the content of the
  *	graph as we get elements, add and change them. Therefore, the TestBook.xml
  *	file and this java test should be kept in sync.
  *
  * 	Test the following:
  *
  *	single String: get/set/remove/set/get
  *	boolean (from true): get/set true/get/set false/get/set true/get
  *	boolean (from false): get/set false/get/set true/get/set false/get
  *	String[]: get/set (null & !null)/add/remove
  *	Bean: remove/set(null)/create bean and graph of beans/set/add
  *
  */

 import java.io.*;
 import java.util.*;
 import org.w3c.dom.*;

 import org.netbeans.modules.schema2beans.*;
 import book.*;


 public class TestBook extends BaseTest {
     public static void main(String[] argv) {
         TestBook o = new TestBook();
         if (argv.length > 0)
             o.setDocumentDir(argv[0]);
         try {
             o.run();
         } catch (Exception e) {
             e.printStackTrace();
             System.exit(1);
         }
         System.exit(0);
     }

     public void run()
 	throws Exception {
 	Book book;

 	this.readDocument();

 	out("creating the bean graph");
 	book = Book.createGraph(doc);

 	//	Check that we can read the graph an it is complete
 	out("bean graph created");

 	//out(book.toString());
 	//out(book.clone().toString());
 	//((BaseBean)book.clone()).write(System.out);

 	//
 	//	Single string test
 	//

 	String s1, s2;

 	//	Get a String element and change it
 	{
 	    setTest("single String - get/set");
 	    s1 = book.getSummary();
 	    s1 += "Some more dynamic notes on the summary.";
 	    book.setSummary(s1);
 	    s2 = book.getSummary();
 	    check(s1.equals(s2));
 	}

 	//	Remove a final string element
 	{
 	    setTest("single String - remove");
 	    book.setSummary(null);
 	    s2 = book.getSummary();
 	    check(s2==null);
 	    out("should not have a 'summary' element:",
 	    book.dumpDomNode("summary", 1));
 	}

 	//	Adding a final string
 	{
 	    setTest("single String - set new");
 	    book.setSummary(s1);
 	    s2 = book.getSummary();
 	    check(s1.equals(s2));
 	    out("should have a 'summary' element:",
 	    book.dumpDomNode("summary", 1));
 	}

 	//
 	//	Boolean test - from initial value true
 	//

 	{
 	    boolean b1, b2;
 	    setTest("boolean - get value (from true)");
 	    b1 = book.isGood();
 	    check(b1==true);
 	    out("should have a 'good' element:",
 	    book.dumpDomNode("good", 1));

 	    setTest("boolean - change to same value (true)");
 	    book.setGood(b1);
 	    check(b1==book.isGood());
 	    out("should still have a 'good' element:",
 	    book.dumpDomNode("good", 1));

 	    setTest("boolean - change to false");
 	    book.setGood(!b1);
 	    check(b1!=book.isGood());
 	    out("should not have a 'good' element:",
 	    book.dumpDomNode("good", 1));

 	    setTest("boolean - change back to true");
 	    book.setGood(b1);
 	    check(b1==book.isGood());
 	    out("should have a 'good' element:",
 	    book.dumpDomNode("good", 1));
 	}

 	//
 	//	Boolean test - from initial value false
 	//
 	{
 	    boolean b1, b2;
 	    setTest("boolean - get value (from false)");
 	    b1 = book.isAvailable();
 	    check(b1==false);
 	    out("should not have an 'available' element:",
 	    book.dumpDomNode("available", 1));

 	    setTest("boolean - change to same value (false)");
 	    book.setAvailable(b1);
 	    check(b1==book.isAvailable());
 	    out("should not have an 'available' element:",
 	    book.dumpDomNode("available", 1));

 	    setTest("boolean - change to true");
 	    book.setAvailable(!b1);
 	    check(b1!=book.isAvailable());
 	    out("should have now an 'available' element:",
 	    book.dumpDomNode("available", 1));

 	    setTest("boolean - change back to false");
 	    book.setAvailable(b1);
 	    check(b1==book.isAvailable());
 	    out("should not have an 'available' element:",
 	    book.dumpDomNode("available", 1));
 	}


 	//
 	//	Array of string test
 	//
 	//	The tests are performed on the Paragraph string array,
 	//	member of the Chapter bean.
 	//	The book contains three chapter. There is one chapter
 	//	with no paragraph, one with one paragraph and one with
 	//	two paragraph. This convers the three cases: empty array,
 	//	array with only one element, and array with more than one
 	//	element.
 	//

 	{
 	    out("String[] - search for the string arrays");
 	    out("found " + book.sizeChapter() + " chapter in book");
 	    for (int i=0; i<book.sizeChapter(); i++) {
 		Chapter c = book.getChapter(i);
 		out("chapter " + (i+1) + " has " + c.sizeParagraph() +
 		" paragraphs:",	c.dumpDomNode("paragraph", 1));
 	    }
 	}

 	//	Test array size = 0
 	{
 	    Chapter c = null;

 	    setTest("String[0] - search for empty array");
 	    for (int i=0; i<book.sizeChapter(); i++) {
 		Chapter c2 = book.getChapter(i);
 		if (c2.sizeParagraph() == 0) {
 		    c = c2;
 		    break;
 		}
 	    }
 	    check(c != null);

 	    int tmp[] = {-1, 0, 1, 999};

 	    //	Check for out of bound exception
 	    for (int i=0; i<tmp.length; i++) {
 		setTest("String[0] - out of bounds access [" + tmp[i] +
 		"]");
 		s1 = "This is a new paragraph";
 		try {
 		    c.setParagraph(tmp[i], s1);
 		    check(false, "didn't get an exception");
 		}
 		catch(IndexOutOfBoundsException e) {
 		    check(true, "(IndexOutOfBoundsException)");
 		}
 		catch(Exception ee) {
 		    check(false, ee.getMessage());
 		}
 	    }

 	    //	Adding an element
 	    setTest("String[0] - add a string to the array");
 	    c.addParagraph(s1);
 	    if (c.sizeParagraph() != 1)
 		err("array size != 1");
 	    s2 = c.getParagraph(0);
 	    check(s1.equals(s2));
 	    out("should contain one paragraph:",
 	    c.dumpDomNode("paragraph", 1));

 	    setTest("String[0] - add another string to the array");
 	    c.addParagraph(s1);
 	    if (c.sizeParagraph() != 2)
 		err("array size != 2");
 	    s2 = c.getParagraph(1);
 	    check(s1.equals(s2));
 	    out("should contain two paragraphs:",
 	    c.dumpDomNode("paragraph", 1));

 	    setTest("String[0] - compare paragraphs");
 	    s1 = c.getParagraph(0);
 	    s2 = c.getParagraph(1);
 	    check(s1.equals(s2), "(same content)");
 	    check(s1 != s2, "(different instances)");

 	    setTest("String[0] - remove element");
 	    c.setParagraph(0, null);
 	    check(c.sizeParagraph() == 2);
 	    out("should contain one paragraph:",
 	    c.dumpDomNode("paragraph", 1));

 	    setTest("String[0] - access elements");
 	    s2 = c.getParagraph(0);
 	    check(s2 == null, "(first, should be null)");
 	    s2 = c.getParagraph(1);
 	    check(s2 != null, "(second, should be !null)");

 	    s1 = "This is another new paragraph";
 	    setTest("String[0] - set again first element");
 	    c.setParagraph(0, s1);
 	    check(c.sizeParagraph() == 2);
 	    out("should contain two paragraphs:",
 	    c.dumpDomNode("paragraph", 1));

 	    setTest("String[0] - removing all elements");
 	    s1 = c.getParagraph(1);
 	    int i1 = c.removeParagraph(s1);
 	    check(i1 == 1, "(removed correct index)");
 	    check(c.sizeParagraph() == 1, "(size is now 1)");
 	    s1 = c.getParagraph(0);
 	    int i2 = c.removeParagraph(s1);
 	    check(i2 == 0, "(removed correct index)");
 	    check(c.sizeParagraph() == 0, "(size is now 0)");
 	    out("should contain no paragraph:",
 	    c.dumpDomNode("paragraph", 1));

 	}

 	//	Test array size = 1
 	{
 	    Chapter c = null;
 	    s1 = "This is again another new paragraph";

 	    setTest("String[0] - search for array of size 1");
 	    for (int i=0; i<book.sizeChapter(); i++) {
 		Chapter c2 = book.getChapter(i);
 		if (c2.sizeParagraph() == 1) {
 		    c = c2;
 		    break;
 		}
 	    }
 	    check(c != null);

 	    int tmp[] = {-1, 1, 999};

 	    //	Check for out of bound exception
 	    for (int i=0; i<tmp.length; i++) {
 		setTest("String[0] - out of bounds access [" + tmp[i] +
 		"]");
 		try {
 		    c.setParagraph(tmp[i], s1);
 		    check(false, "didn't get an exception");
 		}
 		catch(IndexOutOfBoundsException e) {
 		    check(true, "(IndexOutOfBoundsException)");
 		}
 		catch(Exception ee) {
 		    check(false, ee.getMessage());
 		}
 	    }

 	    //	Adding an element
 	    setTest("String[0] - add a string to the array");
 	    c.addParagraph(s1);
 	    if (c.sizeParagraph() != 2)
 		err("array size != 2");
 	    s2 = c.getParagraph(1);
 	    check(s1.equals(s2));
 	    out("should contain two paragraphs:",
 	    c.dumpDomNode("paragraph", 1));

 	    setTest("String[0] - compare paragraphs");
 	    s1 = c.getParagraph(0);
 	    s2 = c.getParagraph(1);
 	    check(!s1.equals(s2), "(different content)");

 	    setTest("String[0] - add more paragraphs");
 	    s1 = "I always wanted to be a kind of a big paragraph " +
 	    " as I always dreamed to fill an XML paragraph element " +
 	    " only to make sure it could be large enough stuffed with " +
 	    " useless characters.";
 	    int size = 100;
 	    for (int i=0; i<size; i++)
 		c.addParagraph(s1);
 	    check(c.sizeParagraph() == size+2 ,
 	    "(" + size + " new paragraphs)");

 	    setTest("String[0] - removing paragraphs (leaving 10)");
 	    for (int i=0; i<size-8; i++)
 		c.removeParagraph(s1);
 	    check(c.sizeParagraph() == 10);
 	    out("should contain 10 paragraphs:",
 	    c.dumpDomNode("paragraph", 1));
 	}


 	//
 	//	Bean elements test
 	//
 	//	The following tests that we can create a brand new bean,
 	//	populate it with other beans an insert it into an existing
 	//	bean graph.
 	//
 	//	The bean elements test are using the Index and Ref beans
 	//	of the Book bean graph:
 	//
 	//	Book
 	// 	  Index[1,n]
 	// 	         Word - String
 	//	         Ref[1,n]
 	// 	                Page - String
 	// 	                Line - String
 	//		...
 	//
 	//
 	{
 	    Index idx;

 	    int size = book.sizeIndex();
 	    out("book has " + size + " Index beans",
 	    book.dumpDomNode("index", 1));

 	    setTest("remove a bean w/ remove()");
 	    idx = book.getIndex(0);
 	    int i1 = book.removeIndex(idx);
 	    check(i1==0, "(correct element removed)");
 	    check(book.sizeIndex()==size-1, "(correct Index array size)");
 	    out("book should have " + (size - 1) + " Index beans",
 	    book.dumpDomNode("index", 1));

 	    setTest("remove another bean w/ set(null)");
 	    idx = book.getIndex(0);
 	    book.setIndex(0, null);
 	    check(book.sizeIndex()==size-1, "(correct Index array size)");
 	    out("book should have " + (size - 2) + " Index beans",
 	    book.dumpDomNode("index", 1));

 	    setTest("add an empty bean to the graph");
 	    idx = new Index();
 	    book.addIndex(idx);
 	    check(book.sizeIndex()==size, "(correct Index array size)");
 	    out("book should have " + (size - 1) + " Index beans",
 	    book.dumpDomNode("index", 1));

 	    setTest("add a subtree bean");
 	    Ref r = new Ref();
 	    r.setPage("122");
 	    r.setLine("32");
 	    idx = new Index();
 	    idx.addRef(r);
 	    r = new Ref();
 	    r.setPage("1");
 	    r.setLine("3");
 	    idx.addRef(r);
 	    idx.setWord("who");
 	    book.setIndex(0, idx);
 	    out("book should have " + size + " Index beans",
 	    book.dumpDomNode("index", 1));
 	    out("idx should have 2 refs",
 	    idx.dumpDomNode(3));
 	    check(book.sizeIndex() == size);

 	    setTest("add another subtree bean");
 	    r = new Ref();
 	    r.setPage("22");
 	    r.setLine("2");
 	    idx = new Index();
 	    idx.setWord("what");
 	    idx.addRef(r);
 	    book.addIndex(idx);
 	    out("book should have " + (size+1) + " Index beans",
 	    book.dumpDomNode("index", 1));
 	    out("idx should have 1 ref",
 	    idx.dumpDomNode(3));
 	    check(book.sizeIndex() == size+1);

 	    setTest("should failed adding the same instance subtree");
 	    try {
 		book.addIndex(idx);
 		check(false, "didn't get an exception");
 	    }
 	    catch(IllegalArgumentException e) {
 		check(true, "\n >> caught: " + e);
 	    }
 	    catch(Exception ee) {
             ee.printStackTrace();
 		check(false, "\n >> got wrong type of exception: " + ee);
 	    }

 	    setTest("add the same cloned tree");
 	    int i2 = book.addIndex((Index)book.getIndex(0).clone());
 	    out("book should have " + (i2+1) + " Index beans",
 	    book.dumpDomNode("index", 1));

 	    out("Initial Index is:",
 	    book.getIndex(0).dumpDomNode(3));
 	    out("New Index should be identical:",
 	    book.getIndex(i2).dumpDomNode(3));

 	    check(book.sizeIndex() == i2+1);
 	}

 	//
 	//	Bean elements test 2
 	//
 	//	The following tests that we can create, add, remove beans
 	//	and values of a graph that is not attached to a DOM tree.
 	//
 	{
 	    Index idx = new Index();
 	    idx.setWord("oops");
 	    setTest("add beans");
 	    Ref r = new Ref();
 	    r.setPage("999");
 	    r.setLine("9");
 	    idx.addRef(r);
 	    r = new Ref();
 	    r.setPage("888");
 	    r.setLine("8");
 	    idx.addRef(r);
 	    check(idx.sizeRef()==2, "(correct size of array)");
 	    out("should have nothing to print: ", idx.dumpDomNode(1));
 	    setTest("remove an element");
 	    idx.removeRef(r);
 	    check(idx.sizeRef()==1, "(correct size of array)");
 	    setTest("remove last element");
 	    idx.setRef(0, null);
 	    check(idx.sizeRef()==1, "(correct size)");
 	    r = new Ref();
 	    r.setPage("77");
 	    r.setLine("7");
 	    idx.setRef(0, r);
 	    out("add an element and test getValues:", idx.dumpBeanNode());
 	}

 	//
 	//	The following test creates a brand new bean graph and therefore
 	//	a new DOM graph.
 	//
 	setTest("creating the root for a brand new graph");
 	book = Book.createGraph();
 	check(book != null);

 	setTest("populating the graph");
 	book.setGood(false);
 	book.setAvailable(true);
 	book.setSummary("This book is about avoiding summaries at the end of books");
 	Chapter c = new Chapter();
 	c.setComment("What's a good summary in chapter 1");
     c.setComment2("Additional comment");
 	c.addParagraph("This is the first paragraph");
 	c.addParagraph("This is a second paragraph");
 	book.addChapter(c);

 	c = new Chapter();
 	book.addChapter(c);
 	c.setComment("Yet another comment for chapter 2");
 	c.addParagraph("only one paragraph in this second chapter");

 	c = new Chapter();
 	book.addChapter(c);

 	Index i = new Index();
 	i.setWord("summary");

 	Ref r = new Ref();
 	r.setPage("22");
 	r.setLine("12");
 	i.addRef(r);

 	r = new Ref();
 	i.addRef(r);
 	r.setPage("4");
 	r.setLine("5");

 	book.addIndex(i);

 	check(true);

 	out("print the new graph DOM nodes:",
 	book.dumpDomNode(9));

 	out("Re-read the original XML file for array getter/setter testing");
 	this.readDocument();
 	book = Book.createGraph(doc);
 	out("bean graph created");

 	{
 	    setTest("check Index[] getter() method");
 	    Index []a1 = book.getIndex();
 	    check(a1.length == book.sizeIndex(), "(correct array size)");
 	    check(a1[0] == book.getIndex(0), "(same first element)");
 	    check(a1[1] == book.getIndex(1), "(same second element)");
 	    check(a1[0] != book.getIndex(1), "([0] != [1])");
 	    setTest("check Chapter[] getter() method");
 	    Chapter []a2 = book.getChapter();
 	    check(a2.length == book.sizeChapter(), "(correct array size)");
 	    check(a2[0] == book.getChapter(0), "(same first element)");
 	    check(a2[1] == book.getChapter(1), "(same second element)");
 	    check(a2[2] == book.getChapter(2), "(same third element)");
 	    check(a2[0] != book.getChapter(2), "([0] != [2])");
 	    setTest("check Chapter.Paragraph getter() method");
 	    String []p = a2[0].getParagraph();
 	    check(p.length == book.getChapter(0).sizeParagraph(),
 	    "(correct array size)");
 	    p = a2[1].getParagraph();
 	    check(p.length == book.getChapter(1).sizeParagraph(),
 	    "(correct array size)");
 	    p = a2[2].getParagraph();
 	    check(p.length == book.getChapter(2).sizeParagraph(),
 	    "(correct array size)");
 	    setTest("change the Chapter[] order");
 	    int []s = new int[3];
 	    s[0] = a2[0].sizeParagraph();
 	    s[1] = a2[1].sizeParagraph();
 	    s[2] = a2[2].sizeParagraph();
 	    Chapter []a3 = new Chapter[3];
 	    a3[2] = (Chapter)a2[0];
 	    a3[1] = (Chapter)a2[1];
 	    a3[0] = (Chapter)a2[2];
 	    book.setChapter(a3);
 	    check(book.getChapter(2).sizeParagraph()==s[0],
 	    "(reversed first element)");
 	    check(book.getChapter(1).sizeParagraph()==s[1],
 	    "(same second element)");
 	    check(book.getChapter(0).sizeParagraph()==s[2],
 	    "(reversed third element)");

         setTest("Chapter going in and out of Book");
         out("Make sure the contents of a Chapter object remain intact after removing that Chapter from the Book");
         Chapter undecidedChapter = new Chapter();
         undecidedChapter.setComment("This chapter may not make it into the book.");
         out(undecidedChapter.getComment());
         book.addChapter(undecidedChapter);
         out(book.sizeChapter());
         check(book.getChapter(book.sizeChapter()-1) == undecidedChapter, "undecided chapter is in there");
         book.removeChapter(undecidedChapter);
         out("make sure undecidedChapter is intact");
         out(undecidedChapter.getComment());
         out("make sure book is intact");
         out(book.sizeChapter());
         out("Put the chapter back in.");
         book.addChapter(undecidedChapter);
         out(book);
 	}

 	//	Read again the document and play with the choice properties
 	this.readDocument();
 	out("creating the bean graph");
 	book = Book.createGraph(doc);

 	setTest("check if the root has any choice prop");
 	Iterator it = book.listChoiceProperties();
 	check(!it.hasNext(), "(none found)");
 	check(book.listChoiceProperties("Chapter") == null, "(none found on Chapter prop)");
 	check(book.listChoiceProperties("index") == null, "(none found on index prop)");
 	setTest("test extra prop");

 	BaseProperty[] bps;
 	Extra e = book.getExtra();
 	it = e.listChoiceProperties();
 	check(it.hasNext(), "(at least one)");
         //#90905: the iterator returns the elements in different order
         // for jdk5 and 6, so we need to put them to a list to maintain the order.
 	List<BaseProperty[]> propertiesList = new ArrayList<BaseProperty[]>();
         while (it.hasNext()) {
 	    propertiesList.add((BaseProperty[])it.next());
 	}
         Collections.sort(propertiesList, new Comparator<BaseProperty[]>(){
             public int compare(BaseProperty[] o1, BaseProperty []o2) {
                 return o1[0].getName().compareTo(o2[0].getName());
             }});

         for (BaseProperty[] each : propertiesList){
             out("Getting a set of choice properties:");
 	    this.printChoiceProperties(each);
         }

 	out("Getting the same list 3 times:");
 	bps = e.listChoiceProperties("Size");
 	this.printChoiceProperties(bps);
 	bps = e.listChoiceProperties("size-cm");
 	this.printChoiceProperties(bps);
 	bps = e.listChoiceProperties("size-inches");
 	this.printChoiceProperties(bps);

 	out("Getting twice the same list:");
 	bps = e.listChoiceProperties("WeightKg");
 	this.printChoiceProperties(bps);
 	bps = e.listChoiceProperties("weight-lb");
 	this.printChoiceProperties(bps);

 	check(!e.isChoiceProperty("color"), " color not choice prop");

 	//
 	//	This tests the DDParser class
 	//
 	//this.out(book.dumpBeanNode());

 	this.parse(book, "/Book/Good");
 	this.parse(book, "/Good");
 	this.parse(book, "Summary/");
 	book.setSummary(null);
 	this.parse(book, "Summary");
 	this.parse(book, "Available");
 	this.parse(book, "Extra");
 	this.parse(book, "Chapter");
 	this.parse(book, "Chapter/Comment");
 	this.parse(book, "Chapter/Paragraph");
 	this.parse(book, "index/ref/line");

 	out(book.dumpBeanNode());
 	this.parse(book, "/Book/Index.Word=E-Tools/Ref/Page");
 	this.parse(book, "/Book/Index.Word=E-Tool/Ref/Page");
 	this.parse(book, "/Book/Index.Word=E-Tool/Ref.Line=15/Page");
 	this.parse(book, "/Book/Index.Word=E-Tool/Ref.Line=15/Page=22");
 	this.parse(book, "/Book/Index.Word=E-Tool/Ref.Line=15/Page=5");

 	book = new Book();
 	out(book.dumpBeanNode());
 	this.parse(book, "/Book/Index.Word=E-Tools/Ref.Line=15/Page!");
 	out(book.dumpBeanNode());
 	this.parse(book, "/Book/Chapter.Comment=My Comment");
 	out(book.dumpBeanNode());
 	this.parse(book, "/Book/Chapter.Comment=My Comment!");
 	out(book.dumpBeanNode());
 	this.parse(book, "/Book/Index.Word=the word/Ref.Line=10/Page=20!");
 	out(book.dumpBeanNode());

 	//  Make sure that we can merge (this test the case of merge
 	//  without attribute which is covered by TestMerge)
 	setTest("simple merge");
 	this.readDocument();
 	out("creating the bean graph");
 	book = Book.createGraph(doc);
 	Book b2 = (Book)book.clone();
 	s1 = "Some more dynamic notes on the summary.";
 	b2.setSummary(s1);
 	b2.getChapter(0).setComment("New Comment");
 	book.merge(b2);
 	check(book.isEqualTo(b2), "identical graphs");

 	//  Merge two elements that are not part of the graph
 	Chapter c1 = new Chapter();
 	Chapter c2 = new Chapter();
 	c1.merge(c2);

     }


     void parse(BaseBean bean, String parse) {
 	out("Parsing " + parse);
 	DDParser p = new DDParser(bean, parse);
 	while (p.hasNext()) {
 	    Object o = p.next();
 	    if (o != null) {
 		if (o instanceof BaseBean)
 		    this.out(((BaseBean)o).dumpBeanNode());
 		else
 		    this.out(o.toString());
 	    }
 	    else
 		this.out("null");
 	}
     }

     void printChoiceProperties(BaseProperty[] bps) {
 	if (bps == null)
 	    err("got null instead a BaseProperty[] instance");
 	else {
 	    for (int l=0; l<bps.length; l++)
 		check(bps[l].isChoiceProperty(), bps[l].getDtdName());
 	}
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	/*
	* TestBook - test the basic features.
	*
	* The following test assumes that we know the content of the
	* graph as we get elements, add and change them. Therefore, the TestBook.xml
	* file and this java test should be kept in sync.
	*
	* Test the following:
	*
	* single String: get/set/remove/set/get
	* boolean (from true): get/set true/get/set false/get/set true/get
	* boolean (from false): get/set false/get/set true/get/set false/get
	* String[]: get/set (null & !null)/add/remove
	* Bean: remove/set(null)/create bean and graph of beans/set/add
	*
	*/

	import java.io.*;
	import java.util.*;
	import org.w3c.dom.*;

	import org.netbeans.modules.schema2beans.*;
	import book.*;


	public class TestBook extends BaseTest {
	public static void main(String[] argv) {
	TestBook o = new TestBook();
	if (argv.length > 0)
	o.setDocumentDir(argv[0]);
	try {
	o.run();
	} catch (Exception e) {
	e.printStackTrace();
	System.exit(1);
	}
	System.exit(0);
	}

	public void run()
	throws Exception {
	Book book;

	this.readDocument();

	out("creating the bean graph");
	book = Book.createGraph(doc);

	// Check that we can read the graph an it is complete
	out("bean graph created");

	//out(book.toString());
	//out(book.clone().toString());
	//((BaseBean)book.clone()).write(System.out);

	//
	// Single string test
	//

	String s1, s2;

	// Get a String element and change it
	{
	setTest("single String - get/set");
	s1 = book.getSummary();
	s1 += "Some more dynamic notes on the summary.";
	book.setSummary(s1);
	s2 = book.getSummary();
	check(s1.equals(s2));
	}

	// Remove a final string element
	{
	setTest("single String - remove");
	book.setSummary(null);
	s2 = book.getSummary();
	check(s2==null);
	out("should not have a 'summary' element:",
	book.dumpDomNode("summary", 1));
	}

	// Adding a final string
	{
	setTest("single String - set new");
	book.setSummary(s1);
	s2 = book.getSummary();
	check(s1.equals(s2));
	out("should have a 'summary' element:",
	book.dumpDomNode("summary", 1));
	}

	//
	// Boolean test - from initial value true
	//

	{
	boolean b1, b2;
	setTest("boolean - get value (from true)");
	b1 = book.isGood();
	check(b1==true);
	out("should have a 'good' element:",
	book.dumpDomNode("good", 1));

	setTest("boolean - change to same value (true)");
	book.setGood(b1);
	check(b1==book.isGood());
	out("should still have a 'good' element:",
	book.dumpDomNode("good", 1));

	setTest("boolean - change to false");
	book.setGood(!b1);
	check(b1!=book.isGood());
	out("should not have a 'good' element:",
	book.dumpDomNode("good", 1));

	setTest("boolean - change back to true");
	book.setGood(b1);
	check(b1==book.isGood());
	out("should have a 'good' element:",
	book.dumpDomNode("good", 1));
	}

	//
	// Boolean test - from initial value false
	//
	{
	boolean b1, b2;
	setTest("boolean - get value (from false)");
	b1 = book.isAvailable();
	check(b1==false);
	out("should not have an 'available' element:",
	book.dumpDomNode("available", 1));

	setTest("boolean - change to same value (false)");
	book.setAvailable(b1);
	check(b1==book.isAvailable());
	out("should not have an 'available' element:",
	book.dumpDomNode("available", 1));

	setTest("boolean - change to true");
	book.setAvailable(!b1);
	check(b1!=book.isAvailable());
	out("should have now an 'available' element:",
	book.dumpDomNode("available", 1));

	setTest("boolean - change back to false");
	book.setAvailable(b1);
	check(b1==book.isAvailable());
	out("should not have an 'available' element:",
	book.dumpDomNode("available", 1));
	}


	//
	// Array of string test
	//
	// The tests are performed on the Paragraph string array,
	// member of the Chapter bean.
	// The book contains three chapter. There is one chapter
	// with no paragraph, one with one paragraph and one with
	// two paragraph. This convers the three cases: empty array,
	// array with only one element, and array with more than one
	// element.
	//

	{
	out("String[] - search for the string arrays");
	out("found " + book.sizeChapter() + " chapter in book");
	for (int i=0; i<book.sizeChapter(); i++) {
	Chapter c = book.getChapter(i);
	out("chapter " + (i+1) + " has " + c.sizeParagraph() +
	" paragraphs:", c.dumpDomNode("paragraph", 1));
	}
	}

	// Test array size = 0
	{
	Chapter c = null;

	setTest("String[0] - search for empty array");
	for (int i=0; i<book.sizeChapter(); i++) {
	Chapter c2 = book.getChapter(i);
	if (c2.sizeParagraph() == 0) {
	c = c2;
	break;
	}
	}
	check(c != null);

	int tmp[] = {-1, 0, 1, 999};

	// Check for out of bound exception
	for (int i=0; i<tmp.length; i++) {
	setTest("String[0] - out of bounds access [" + tmp[i] +
	"]");
	s1 = "This is a new paragraph";
	try {
	c.setParagraph(tmp[i], s1);
	check(false, "didn't get an exception");
	}
	catch(IndexOutOfBoundsException e) {
	check(true, "(IndexOutOfBoundsException)");
	}
	catch(Exception ee) {
	check(false, ee.getMessage());
	}
	}

	// Adding an element
	setTest("String[0] - add a string to the array");
	c.addParagraph(s1);
	if (c.sizeParagraph() != 1)
	err("array size != 1");
	s2 = c.getParagraph(0);
	check(s1.equals(s2));
	out("should contain one paragraph:",
	c.dumpDomNode("paragraph", 1));

	setTest("String[0] - add another string to the array");
	c.addParagraph(s1);
	if (c.sizeParagraph() != 2)
	err("array size != 2");
	s2 = c.getParagraph(1);
	check(s1.equals(s2));
	out("should contain two paragraphs:",
	c.dumpDomNode("paragraph", 1));

	setTest("String[0] - compare paragraphs");
	s1 = c.getParagraph(0);
	s2 = c.getParagraph(1);
	check(s1.equals(s2), "(same content)");
	check(s1 != s2, "(different instances)");

	setTest("String[0] - remove element");
	c.setParagraph(0, null);
	check(c.sizeParagraph() == 2);
	out("should contain one paragraph:",
	c.dumpDomNode("paragraph", 1));

	setTest("String[0] - access elements");
	s2 = c.getParagraph(0);
	check(s2 == null, "(first, should be null)");
	s2 = c.getParagraph(1);
	check(s2 != null, "(second, should be !null)");

	s1 = "This is another new paragraph";
	setTest("String[0] - set again first element");
	c.setParagraph(0, s1);
	check(c.sizeParagraph() == 2);
	out("should contain two paragraphs:",
	c.dumpDomNode("paragraph", 1));

	setTest("String[0] - removing all elements");
	s1 = c.getParagraph(1);
	int i1 = c.removeParagraph(s1);
	check(i1 == 1, "(removed correct index)");
	check(c.sizeParagraph() == 1, "(size is now 1)");
	s1 = c.getParagraph(0);
	int i2 = c.removeParagraph(s1);
	check(i2 == 0, "(removed correct index)");
	check(c.sizeParagraph() == 0, "(size is now 0)");
	out("should contain no paragraph:",
	c.dumpDomNode("paragraph", 1));

	}

	// Test array size = 1
	{
	Chapter c = null;
	s1 = "This is again another new paragraph";

	setTest("String[0] - search for array of size 1");
	for (int i=0; i<book.sizeChapter(); i++) {
	Chapter c2 = book.getChapter(i);
	if (c2.sizeParagraph() == 1) {
	c = c2;
	break;
	}
	}
	check(c != null);

	int tmp[] = {-1, 1, 999};

	// Check for out of bound exception
	for (int i=0; i<tmp.length; i++) {
	setTest("String[0] - out of bounds access [" + tmp[i] +
	"]");
	try {
	c.setParagraph(tmp[i], s1);
	check(false, "didn't get an exception");
	}
	catch(IndexOutOfBoundsException e) {
	check(true, "(IndexOutOfBoundsException)");
	}
	catch(Exception ee) {
	check(false, ee.getMessage());
	}
	}

	// Adding an element
	setTest("String[0] - add a string to the array");
	c.addParagraph(s1);
	if (c.sizeParagraph() != 2)
	err("array size != 2");
	s2 = c.getParagraph(1);
	check(s1.equals(s2));
	out("should contain two paragraphs:",
	c.dumpDomNode("paragraph", 1));

	setTest("String[0] - compare paragraphs");
	s1 = c.getParagraph(0);
	s2 = c.getParagraph(1);
	check(!s1.equals(s2), "(different content)");

	setTest("String[0] - add more paragraphs");
	s1 = "I always wanted to be a kind of a big paragraph " +
	" as I always dreamed to fill an XML paragraph element " +
	" only to make sure it could be large enough stuffed with " +
	" useless characters.";
	int size = 100;
	for (int i=0; i<size; i++)
	c.addParagraph(s1);
	check(c.sizeParagraph() == size+2 ,
	"(" + size + " new paragraphs)");

	setTest("String[0] - removing paragraphs (leaving 10)");
	for (int i=0; i<size-8; i++)
	c.removeParagraph(s1);
	check(c.sizeParagraph() == 10);
	out("should contain 10 paragraphs:",
	c.dumpDomNode("paragraph", 1));
	}


	//
	// Bean elements test
	//
	// The following tests that we can create a brand new bean,
	// populate it with other beans an insert it into an existing
	// bean graph.
	//
	// The bean elements test are using the Index and Ref beans
	// of the Book bean graph:
	//
	// Book
	// Index[1,n]
	// Word - String
	// Ref[1,n]
	// Page - String
	// Line - String
	// ...
	//
	//
	{
	Index idx;

	int size = book.sizeIndex();
	out("book has " + size + " Index beans",
	book.dumpDomNode("index", 1));

	setTest("remove a bean w/ remove()");
	idx = book.getIndex(0);
	int i1 = book.removeIndex(idx);
	check(i1==0, "(correct element removed)");
	check(book.sizeIndex()==size-1, "(correct Index array size)");
	out("book should have " + (size - 1) + " Index beans",
	book.dumpDomNode("index", 1));

	setTest("remove another bean w/ set(null)");
	idx = book.getIndex(0);
	book.setIndex(0, null);
	check(book.sizeIndex()==size-1, "(correct Index array size)");
	out("book should have " + (size - 2) + " Index beans",
	book.dumpDomNode("index", 1));

	setTest("add an empty bean to the graph");
	idx = new Index();
	book.addIndex(idx);
	check(book.sizeIndex()==size, "(correct Index array size)");
	out("book should have " + (size - 1) + " Index beans",
	book.dumpDomNode("index", 1));

	setTest("add a subtree bean");
	Ref r = new Ref();
	r.setPage("122");
	r.setLine("32");
	idx = new Index();
	idx.addRef(r);
	r = new Ref();
	r.setPage("1");
	r.setLine("3");
	idx.addRef(r);
	idx.setWord("who");
	book.setIndex(0, idx);
	out("book should have " + size + " Index beans",
	book.dumpDomNode("index", 1));
	out("idx should have 2 refs",
	idx.dumpDomNode(3));
	check(book.sizeIndex() == size);

	setTest("add another subtree bean");
	r = new Ref();
	r.setPage("22");
	r.setLine("2");
	idx = new Index();
	idx.setWord("what");
	idx.addRef(r);
	book.addIndex(idx);
	out("book should have " + (size+1) + " Index beans",
	book.dumpDomNode("index", 1));
	out("idx should have 1 ref",
	idx.dumpDomNode(3));
	check(book.sizeIndex() == size+1);

	setTest("should failed adding the same instance subtree");
	try {
	book.addIndex(idx);
	check(false, "didn't get an exception");
	}
	catch(IllegalArgumentException e) {
	check(true, "\n >> caught: " + e);
	}
	catch(Exception ee) {
	ee.printStackTrace();
	check(false, "\n >> got wrong type of exception: " + ee);
	}

	setTest("add the same cloned tree");
	int i2 = book.addIndex((Index)book.getIndex(0).clone());
	out("book should have " + (i2+1) + " Index beans",
	book.dumpDomNode("index", 1));

	out("Initial Index is:",
	book.getIndex(0).dumpDomNode(3));
	out("New Index should be identical:",
	book.getIndex(i2).dumpDomNode(3));

	check(book.sizeIndex() == i2+1);
	}

	//
	// Bean elements test 2
	//
	// The following tests that we can create, add, remove beans
	// and values of a graph that is not attached to a DOM tree.
	//
	{
	Index idx = new Index();
	idx.setWord("oops");
	setTest("add beans");
	Ref r = new Ref();
	r.setPage("999");
	r.setLine("9");
	idx.addRef(r);
	r = new Ref();
	r.setPage("888");
	r.setLine("8");
	idx.addRef(r);
	check(idx.sizeRef()==2, "(correct size of array)");
	out("should have nothing to print: ", idx.dumpDomNode(1));
	setTest("remove an element");
	idx.removeRef(r);
	check(idx.sizeRef()==1, "(correct size of array)");
	setTest("remove last element");
	idx.setRef(0, null);
	check(idx.sizeRef()==1, "(correct size)");
	r = new Ref();
	r.setPage("77");
	r.setLine("7");
	idx.setRef(0, r);
	out("add an element and test getValues:", idx.dumpBeanNode());
	}

	//
	// The following test creates a brand new bean graph and therefore
	// a new DOM graph.
	//
	setTest("creating the root for a brand new graph");
	book = Book.createGraph();
	check(book != null);

	setTest("populating the graph");
	book.setGood(false);
	book.setAvailable(true);
	book.setSummary("This book is about avoiding summaries at the end of books");
	Chapter c = new Chapter();
	c.setComment("What's a good summary in chapter 1");
	c.setComment2("Additional comment");
	c.addParagraph("This is the first paragraph");
	c.addParagraph("This is a second paragraph");
	book.addChapter(c);

	c = new Chapter();
	book.addChapter(c);
	c.setComment("Yet another comment for chapter 2");
	c.addParagraph("only one paragraph in this second chapter");

	c = new Chapter();
	book.addChapter(c);

	Index i = new Index();
	i.setWord("summary");

	Ref r = new Ref();
	r.setPage("22");
	r.setLine("12");
	i.addRef(r);

	r = new Ref();
	i.addRef(r);
	r.setPage("4");
	r.setLine("5");

	book.addIndex(i);

	check(true);

	out("print the new graph DOM nodes:",
	book.dumpDomNode(9));

	out("Re-read the original XML file for array getter/setter testing");
	this.readDocument();
	book = Book.createGraph(doc);
	out("bean graph created");

	{
	setTest("check Index[] getter() method");
	Index []a1 = book.getIndex();
	check(a1.length == book.sizeIndex(), "(correct array size)");
	check(a1[0] == book.getIndex(0), "(same first element)");
	check(a1[1] == book.getIndex(1), "(same second element)");
	check(a1[0] != book.getIndex(1), "([0] != [1])");
	setTest("check Chapter[] getter() method");
	Chapter []a2 = book.getChapter();
	check(a2.length == book.sizeChapter(), "(correct array size)");
	check(a2[0] == book.getChapter(0), "(same first element)");
	check(a2[1] == book.getChapter(1), "(same second element)");
	check(a2[2] == book.getChapter(2), "(same third element)");
	check(a2[0] != book.getChapter(2), "([0] != [2])");
	setTest("check Chapter.Paragraph getter() method");
	String []p = a2[0].getParagraph();
	check(p.length == book.getChapter(0).sizeParagraph(),
	"(correct array size)");
	p = a2[1].getParagraph();
	check(p.length == book.getChapter(1).sizeParagraph(),
	"(correct array size)");
	p = a2[2].getParagraph();
	check(p.length == book.getChapter(2).sizeParagraph(),
	"(correct array size)");
	setTest("change the Chapter[] order");
	int []s = new int[3];
	s[0] = a2[0].sizeParagraph();
	s[1] = a2[1].sizeParagraph();
	s[2] = a2[2].sizeParagraph();
	Chapter []a3 = new Chapter[3];
	a3[2] = (Chapter)a2[0];
	a3[1] = (Chapter)a2[1];
	a3[0] = (Chapter)a2[2];
	book.setChapter(a3);
	check(book.getChapter(2).sizeParagraph()==s[0],
	"(reversed first element)");
	check(book.getChapter(1).sizeParagraph()==s[1],
	"(same second element)");
	check(book.getChapter(0).sizeParagraph()==s[2],
	"(reversed third element)");

	setTest("Chapter going in and out of Book");
	out("Make sure the contents of a Chapter object remain intact after removing that Chapter from the Book");
	Chapter undecidedChapter = new Chapter();
	undecidedChapter.setComment("This chapter may not make it into the book.");
	out(undecidedChapter.getComment());
	book.addChapter(undecidedChapter);
	out(book.sizeChapter());
	check(book.getChapter(book.sizeChapter()-1) == undecidedChapter, "undecided chapter is in there");
	book.removeChapter(undecidedChapter);
	out("make sure undecidedChapter is intact");
	out(undecidedChapter.getComment());
	out("make sure book is intact");
	out(book.sizeChapter());
	out("Put the chapter back in.");
	book.addChapter(undecidedChapter);
	out(book);
	}

	// Read again the document and play with the choice properties
	this.readDocument();
	out("creating the bean graph");
	book = Book.createGraph(doc);

	setTest("check if the root has any choice prop");
	Iterator it = book.listChoiceProperties();
	check(!it.hasNext(), "(none found)");
	check(book.listChoiceProperties("Chapter") == null, "(none found on Chapter prop)");
	check(book.listChoiceProperties("index") == null, "(none found on index prop)");
	setTest("test extra prop");

	BaseProperty[] bps;
	Extra e = book.getExtra();
	it = e.listChoiceProperties();
	check(it.hasNext(), "(at least one)");
	//#90905: the iterator returns the elements in different order
	// for jdk5 and 6, so we need to put them to a list to maintain the order.
	List<BaseProperty[]> propertiesList = new ArrayList<BaseProperty[]>();
	while (it.hasNext()) {
	propertiesList.add((BaseProperty[])it.next());
	}
	Collections.sort(propertiesList, new Comparator<BaseProperty[]>(){
	public int compare(BaseProperty[] o1, BaseProperty []o2) {
	return o1[0].getName().compareTo(o2[0].getName());
	}});

	for (BaseProperty[] each : propertiesList){
	out("Getting a set of choice properties:");
	this.printChoiceProperties(each);
	}

	out("Getting the same list 3 times:");
	bps = e.listChoiceProperties("Size");
	this.printChoiceProperties(bps);
	bps = e.listChoiceProperties("size-cm");
	this.printChoiceProperties(bps);
	bps = e.listChoiceProperties("size-inches");
	this.printChoiceProperties(bps);

	out("Getting twice the same list:");
	bps = e.listChoiceProperties("WeightKg");
	this.printChoiceProperties(bps);
	bps = e.listChoiceProperties("weight-lb");
	this.printChoiceProperties(bps);

	check(!e.isChoiceProperty("color"), " color not choice prop");

	//
	// This tests the DDParser class
	//
	//this.out(book.dumpBeanNode());

	this.parse(book, "/Book/Good");
	this.parse(book, "/Good");
	this.parse(book, "Summary/");
	book.setSummary(null);
	this.parse(book, "Summary");
	this.parse(book, "Available");
	this.parse(book, "Extra");
	this.parse(book, "Chapter");
	this.parse(book, "Chapter/Comment");
	this.parse(book, "Chapter/Paragraph");
	this.parse(book, "index/ref/line");

	out(book.dumpBeanNode());
	this.parse(book, "/Book/Index.Word=E-Tools/Ref/Page");
	this.parse(book, "/Book/Index.Word=E-Tool/Ref/Page");
	this.parse(book, "/Book/Index.Word=E-Tool/Ref.Line=15/Page");
	this.parse(book, "/Book/Index.Word=E-Tool/Ref.Line=15/Page=22");
	this.parse(book, "/Book/Index.Word=E-Tool/Ref.Line=15/Page=5");

	book = new Book();
	out(book.dumpBeanNode());
	this.parse(book, "/Book/Index.Word=E-Tools/Ref.Line=15/Page!");
	out(book.dumpBeanNode());
	this.parse(book, "/Book/Chapter.Comment=My Comment");
	out(book.dumpBeanNode());
	this.parse(book, "/Book/Chapter.Comment=My Comment!");
	out(book.dumpBeanNode());
	this.parse(book, "/Book/Index.Word=the word/Ref.Line=10/Page=20!");
	out(book.dumpBeanNode());

	// Make sure that we can merge (this test the case of merge
	// without attribute which is covered by TestMerge)
	setTest("simple merge");
	this.readDocument();
	out("creating the bean graph");
	book = Book.createGraph(doc);
	Book b2 = (Book)book.clone();
	s1 = "Some more dynamic notes on the summary.";
	b2.setSummary(s1);
	b2.getChapter(0).setComment("New Comment");
	book.merge(b2);
	check(book.isEqualTo(b2), "identical graphs");

	// Merge two elements that are not part of the graph
	Chapter c1 = new Chapter();
	Chapter c2 = new Chapter();
	c1.merge(c2);

	}


	void parse(BaseBean bean, String parse) {
	out("Parsing " + parse);
	DDParser p = new DDParser(bean, parse);
	while (p.hasNext()) {
	Object o = p.next();
	if (o != null) {
	if (o instanceof BaseBean)
	this.out(((BaseBean)o).dumpBeanNode());
	else
	this.out(o.toString());
	}
	else
	this.out("null");
	}
	}

	void printChoiceProperties(BaseProperty[] bps) {
	if (bps == null)
	err("got null instead a BaseProperty[] instance");
	else {
	for (int l=0; l<bps.length; l++)
	check(bps[l].isChoiceProperty(), bps[l].getDtdName());
	}
	}
	}