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

quality92%

¤ Dauer der Verarbeitung: 0.15 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.