/*
 * 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());
	}
    }
}