Quelle  TestBook.java   Sprache: JAVA

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