public void read(Document doc) {
try {
Element root = doc.getDocumentElement();
NodeList nList = doc.getElementsByTagName("user");
for (int i = 0; i < nList.getLength(); i++) {
Node node = nList.item(i);
if (node.getNodeType() == Node.ELEMENT_NODE) {
Element element = (Element) node;
}
}
// Element e1 = (Element) nList.item(0);
} catch (Exception e) {
}
}
/**
* Method that reads a XML-file, and returns a Model that contains the information
*
* @param file
* @return
* @return
*/
public static Model readXML(String file) {
// initialize table to be filled with content of XML file
Model t = new Model();
try {
// Create file to be parsed by document parser
File xmlfile = new File(file);
// create parser
DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
// parse the file
Document parsedfile = parser.parse(xmlfile);
// normalize the parsed file (make it more user-friendly)
parsedfile.getDocumentElement().normalize();
NodeList cells = parsedfile.getElementsByTagName("CELL");
for (int i = 0; i < cells.getLength(); i++) {
// Get cell at list index i
Node currentcell = cells.item(i);
// read the elements "location" attributes row/column
if (Node.ELEMENT_NODE == currentcell.getNodeType()) {
Element cellinfo = (Element) currentcell;
// get the row number from node attribute
int row = Integer.parseInt(cellinfo.getAttribute("row")) - 1;
// get the column number from the node attribute
int col = Integer.parseInt(cellinfo.getAttribute("column")) - 1;
// get content from node
String content = cellinfo.getTextContent();
if (content != null) {
content = content.replace("\n", "");
}
// Make the content an Integer (if it is a number), easier
// for
// using it later on
// put content in table, with row/column inserted as x/y
t.setContent(row, col, (String) content);
}
}
} catch (ParserConfigurationException e) {
System.out.println("Fileparser could not be made");
} catch (IOException f) {
System.out.println("File could not be parsed, did you enter the correct file name?");
} catch (SAXException g) {
System.out.println("Something went wrong in parsing the file");
}
return t;
}
/**
* Gets the definitions of a word, sets the main one if necessary, and returns it.
*
* @param overwrite if true, then function will attempt to retrieve from online even if the
* definition is already set.
* @return String containing the main definition of the word.
*/
public static Word[] getWordsFromFile(ByteArrayInputStream inputStream) {
try {
// now to parse the XML
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(inputStream);
removeEmptyTextNodes(doc);
NodeList wordList = doc.getElementsByTagName("WordDefinitions");
int wordCount = wordList.getLength();
Word[] returnWords = new Word[wordCount];
for (int wordi = 0; wordi < wordCount; wordi++) {
NodeList list = ((Element) wordList.item(wordi)).getElementsByTagName("Definition");
Element wordElement = (Element) wordList.item(wordi);
String word = wordElement.getAttribute("word");
String mainDefinition = wordElement.getAttribute("mainDefinition");
int numDefinitions = list.getLength();
Definition[] wordOtherDefinitions = new Definition[numDefinitions];
for (int i = 0; i < numDefinitions; i++) {
Node node = list.item(i);
NodeList children = node.getChildNodes(); // gets each child node of the definition
// get all data
String definition = children.item(XML_DEFINITION_LOC).getTextContent();
String theWord = children.item(XML_WORD_LOC).getTextContent();
NodeList dictionaryNode = children.item(XML_DICTIONARY_BRANCH_LOC).getChildNodes();
String dictionaryId = dictionaryNode.item(XML_DICTIONARY_ID_LOC).getTextContent();
String dictionaryName = dictionaryNode.item(XML_DICTIONARY_NAME_LOC).getTextContent();
// now we've got all the data lets add it to the array
wordOtherDefinitions[i] =
new Definition(dictionaryName, dictionaryId, definition, theWord);
}
if (wordOtherDefinitions.length == 0) {
wordOtherDefinitions =
new Definition[] {new Definition("nil", "nil", "NO DEFINITION FOUND", word)};
}
Word currentWord = new Word(word, mainDefinition);
currentWord.setOtherDefinitions(wordOtherDefinitions);
returnWords[wordi] = currentWord;
}
return returnWords;
} catch (Exception ex) {
ex.printStackTrace();
return null;
}
}
/**
* Gets the definitions of a word, sets the main one if necessary, and returns it.
*
* @param overwrite if true, then function will attempt to retrieve from online even if the
* definition is already set.
* @return String containing the main definition of the word.
*/
public String getDefinitions(ByteArrayInputStream inputStream, boolean overwrite) {
if (overwrite || (definition == null || definition.isEmpty())) {
// get definition from online service
// if not able to access internet, then do something
try {
// now to parse the XML
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(inputStream);
removeEmptyTextNodes(doc);
NodeList list = doc.getElementsByTagName("Definition");
int numDefinitions = list.getLength();
otherDefinitions = new Definition[numDefinitions];
for (int i = 0; i < numDefinitions; i++) {
Node node = list.item(i);
NodeList children = node.getChildNodes(); // gets each child node of the definition
// get all data
String definition = children.item(XML_DEFINITION_LOC).getTextContent();
String word = children.item(XML_WORD_LOC).getTextContent();
NodeList dictionaryNode = children.item(XML_DICTIONARY_BRANCH_LOC).getChildNodes();
String dictionaryId = dictionaryNode.item(XML_DICTIONARY_ID_LOC).getTextContent();
String dictionaryName = dictionaryNode.item(XML_DICTIONARY_NAME_LOC).getTextContent();
// now we've got all the data lets add it to the array
otherDefinitions[i] = new Definition(dictionaryName, dictionaryId, definition, word);
}
if (otherDefinitions.length == 0) {
otherDefinitions =
new Definition[] {new Definition("nil", "nil", "NO DEFINITION FOUND", word)};
}
this.setMainDefinition(otherDefinitions[0].getDefinition());
return otherDefinitions[0].getDefinition();
} catch (Exception ex) {
ex.printStackTrace();
return "ERROR! " + ex;
}
} else {
return this.definition;
}
}
/**
* XML Circuit constructor
*
* @param file the file that contains the XML description of the circuit
* @param g the graphics that will paint the node
* @throws CircuitLoadingException if the internal circuit can not be loaded
*/
public CircuitUI(File file, Graphics g) throws CircuitLoadingException {
this("");
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder;
Document doc;
Element root;
Hashtable<Integer, Link> linkstable = new Hashtable<Integer, Link>();
try {
builder = factory.newDocumentBuilder();
doc = builder.parse(file);
} catch (SAXException sxe) {
throw new CircuitLoadingException("SAX exception raised, invalid XML file.");
} catch (ParserConfigurationException pce) {
throw new CircuitLoadingException(
"Parser exception raised, parser configuration is invalid.");
} catch (IOException ioe) {
throw new CircuitLoadingException("I/O exception, file cannot be loaded.");
}
root = (Element) doc.getElementsByTagName("Circuit").item(0);
this.setName(root.getAttribute("name"));
NodeList nl = root.getElementsByTagName("Node");
Element e;
Node n;
Class cl;
for (int i = 0; i < nl.getLength(); ++i) {
e = (Element) nl.item(i);
try {
cl = Class.forName(e.getAttribute("class"));
} catch (Exception exc) {
System.err.println(exc.getMessage());
throw new RuntimeException("Circuit creation from xml.");
}
try {
n = ((Node) cl.newInstance());
} catch (Exception exc) {
System.err.println(exc.getMessage());
throw new RuntimeException("Circuit creation from xml.");
}
this.nodes.add(n);
n.setLocation(new Integer(e.getAttribute("x")), new Integer(e.getAttribute("y")));
if (n instanceof giraffe.ui.Nameable) ((Nameable) n).setNodeName(e.getAttribute("node_name"));
if (n instanceof giraffe.ui.CompositeNode) {
try {
((CompositeNode) n)
.load(new File(file.getParent() + "/" + e.getAttribute("file_name")), g);
} catch (Exception exc) {
/* try to load from the lib */
((CompositeNode) n)
.load(new File(giraffe.Giraffe.PATH + "/lib/" + e.getAttribute("file_name")), g);
}
}
NodeList nlist = e.getElementsByTagName("Anchor");
Element el;
for (int j = 0; j < nlist.getLength(); ++j) {
el = (Element) nlist.item(j);
Anchor a = n.getAnchor(new Integer(el.getAttribute("id")));
NodeList linklist = el.getElementsByTagName("Link");
Element link;
Link l;
for (int k = 0; k < linklist.getLength(); ++k) {
link = (Element) linklist.item(k);
int id = new Integer(link.getAttribute("id"));
int index = new Integer(link.getAttribute("index"));
if (id >= this.linkID) linkID = id + 1;
if (linkstable.containsKey(id)) {
l = linkstable.get(id);
l.addLinkedAnchorAt(a, index);
a.addLink(l);
} else {
l = new Link(id);
l.addLinkedAnchorAt(a, index);
this.links.add(l);
linkstable.put(id, l);
a.addLink(l);
}
}
}
}
}
public boolean runTest(Test test) throws Exception {
String filename = test.file.toString();
if (this.verbose) {
System.out.println(
"Running "
+ filename
+ " against "
+ this.host
+ ":"
+ this.port
+ " with "
+ this.browser);
}
this.document = parseDocument(filename);
if (this.baseUrl == null) {
NodeList links = this.document.getElementsByTagName("link");
if (links.getLength() != 0) {
Element link = (Element) links.item(0);
setBaseUrl(link.getAttribute("href"));
}
}
if (this.verbose) {
System.out.println("Base URL=" + this.baseUrl);
}
Node body = this.document.getElementsByTagName("body").item(0);
Element resultContainer = document.createElement("div");
resultContainer.setTextContent("Result: ");
Element resultElt = document.createElement("span");
resultElt.setAttribute("id", "result");
resultElt.setIdAttribute("id", true);
resultContainer.appendChild(resultElt);
body.insertBefore(resultContainer, body.getFirstChild());
Element executionLogContainer = document.createElement("div");
executionLogContainer.setTextContent("Execution Log:");
Element executionLog = document.createElement("div");
executionLog.setAttribute("id", "log");
executionLog.setIdAttribute("id", true);
executionLog.setAttribute("style", "white-space: pre;");
executionLogContainer.appendChild(executionLog);
body.appendChild(executionLogContainer);
NodeList tableRows = document.getElementsByTagName("tr");
Element theadRow = (Element) tableRows.item(0);
test.name = theadRow.getTextContent();
appendCellToRow(theadRow, "Result");
this.commandProcessor =
new HtmlCommandProcessor(this.host, this.port, this.browser, this.baseUrl);
String resultState;
String resultLog;
test.result = true;
try {
this.commandProcessor.start();
test.commands = new Command[tableRows.getLength() - 1];
for (int i = 1; i < tableRows.getLength(); i++) {
Element stepRow = (Element) tableRows.item(i);
Command command = executeStep(stepRow);
appendCellToRow(stepRow, command.result);
test.commands[i - 1] = command;
if (command.error) {
test.result = false;
}
if (command.failure) {
test.result = false;
// break;
}
}
resultState = test.result ? "PASSED" : "FAILED";
resultLog = (test.result ? "Test Complete" : "Error");
this.commandProcessor.stop();
} catch (Exception e) {
test.result = false;
resultState = "ERROR";
resultLog = "Failed to initialize session\n" + e;
e.printStackTrace();
}
document.getElementById("result").setTextContent(resultState);
Element log = document.getElementById("log");
log.setTextContent(log.getTextContent() + resultLog + "\n");
return test.result;
}
