/**
* Performs an XPATH lookup in an xml document whose filename is specified by the first parameter
* (assumed to be in the auxiliary subdirectory) The XPATH expression is supplied as the second
* string parameter The return value is of type string e.g. this is currently used primarily for
* looking up the Company Prefix Index for encoding a GS1 Company Prefix into a 64-bit EPC tag
*/
private String xpathlookup(String xml, String expression) {
try {
// Parse the XML as a W3C document.
DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document document =
builder.parse(new File(xmldir + File.separator + "auxiliary" + File.separator + xml));
XPath xpath = XPathFactory.newInstance().newXPath();
String rv = (String) xpath.evaluate(expression, document, XPathConstants.STRING);
return rv;
} catch (ParserConfigurationException e) {
System.err.println("ParserConfigurationException caught...");
e.printStackTrace();
return null;
} catch (XPathExpressionException e) {
System.err.println("XPathExpressionException caught...");
e.printStackTrace();
return null;
} catch (SAXException e) {
System.err.println("SAXException caught...");
e.printStackTrace();
return null;
} catch (IOException e) {
System.err.println("IOException caught...");
e.printStackTrace();
return null;
}
}
Document parseDocument(String filename) throws Exception {
FileReader reader = new FileReader(filename);
String firstLine = new BufferedReader(reader).readLine();
reader.close();
Document document = null;
if (firstLine.startsWith("<?xml")) {
System.err.println("XML detected; using default XML parser.");
} else {
try {
Class nekoParserClass = Class.forName("org.cyberneko.html.parsers.DOMParser");
Object parser = nekoParserClass.newInstance();
Method parse = nekoParserClass.getMethod("parse", new Class[] {String.class});
Method getDocument = nekoParserClass.getMethod("getDocument", new Class[0]);
parse.invoke(parser, filename);
document = (Document) getDocument.invoke(parser);
} catch (Exception e) {
System.err.println("NekoHTML HTML parser not found; HTML4 support disabled.");
}
}
if (document == null) {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
try { // http://www.w3.org/blog/systeam/2008/02/08/w3c_s_excessive_dtd_traffic
factory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
} catch (ParserConfigurationException e) {
System.err.println("Warning: Could not disable external DTD loading");
}
DocumentBuilder builder = factory.newDocumentBuilder();
document = builder.parse(filename);
}
return document;
}
private void guardaRes(String resu, CliGol cliGol)
throws ParserConfigurationException, SAXException, IOException {
String[] nodos = {"NoHit", "Hit", "Buro"};
DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
InputSource is = new InputSource(new StringReader(resu));
Document xml = db.parse(is);
Element raiz = xml.getDocumentElement();
String nombre = obtenerNombre(raiz);
for (String s : nodos) {
Node nodo =
raiz.getElementsByTagName(s) == null ? null : raiz.getElementsByTagName(s).item(0);
if (nodo != null) {
String informacion = sustraerInformacionNodo(cliGol, nodo);
guardarEnListas(nodo.getNodeName(), nombre + "," + informacion);
}
}
}
public ArrayList<String> parseXML() throws Exception {
ArrayList<String> ret = new ArrayList<String>();
handshake();
URL url =
new URL(
"http://mangaonweb.com/page.do?cdn="
+ cdn
+ "&cpn=book.xml&crcod="
+ crcod
+ "&rid="
+ (int) (Math.random() * 10000));
String page = DownloaderUtils.getPage(url.toString(), "UTF-8", cookies);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
InputSource is = new InputSource(new StringReader(page));
Document d = builder.parse(is);
Element doc = d.getDocumentElement();
NodeList pages = doc.getElementsByTagName("page");
total = pages.getLength();
for (int i = 0; i < pages.getLength(); i++) {
Element e = (Element) pages.item(i);
ret.add(e.getAttribute("path"));
}
return (ret);
}
public List parsePage(String pageCode) {
List sections = new ArrayList();
List folders = new ArrayList();
List files = new ArrayList();
int start = pageCode.indexOf("<div id=\"list-view\" class=\"view\"");
int end = pageCode.indexOf("<div id=\"gallery-view\" class=\"view\"");
String usefulSection = "";
if (start != -1 && end != -1) {
usefulSection = pageCode.substring(start, end);
} else {
debug("Could not parse page");
}
try {
DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
InputSource is = new InputSource();
is.setCharacterStream(new StringReader(usefulSection));
Document doc = db.parse(is);
NodeList divs = doc.getElementsByTagName("div");
for (int i = 0; i < divs.getLength(); i++) {
Element div = (Element) divs.item(i);
boolean isFolder = false;
if (div.getAttribute("class").equals("filename")) {
NodeList imgs = div.getElementsByTagName("img");
for (int j = 0; j < imgs.getLength(); j++) {
Element img = (Element) imgs.item(j);
if (img.getAttribute("class").indexOf("folder") > 0) {
isFolder = true;
} else {
isFolder = false; // it's a file
}
}
NodeList anchors = div.getElementsByTagName("a");
Element anchor = (Element) anchors.item(0);
String attr = anchor.getAttribute("href");
String fileName = anchor.getAttribute("title");
String fileURL;
if (isFolder && !attr.equals("#")) {
folders.add(attr);
folders.add(fileName);
} else if (!isFolder && !attr.equals("#")) {
// Dropbox uses ajax to get the file for download, so the url isn't enough. We must be
// sneaky here.
fileURL = "https://dl.dropbox.com" + attr.substring(23) + "?dl=1";
files.add(fileURL);
files.add(fileName);
}
}
}
} catch (Exception e) {
debug(e.toString());
}
sections.add(files);
sections.add(folders);
return sections;
}
public static Document newXMLDocument() {
DocumentBuilder dbuilder = null;
try {
dbuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
} catch (ParserConfigurationException e) {
e.printStackTrace();
return null;
}
return dbuilder.newDocument();
}
/** Возвращает объект Document, который является объектным представлением XML документа. */
private static Document getDocument() throws Exception {
try {
DocumentBuilderFactory f = DocumentBuilderFactory.newInstance();
f.setValidating(false);
DocumentBuilder builder = f.newDocumentBuilder();
return builder.parse(new File("app.xml"));
} catch (Exception exception) {
String message = "XML parsing error!";
throw new Exception(message);
}
}
public WikipediaMinerAnnotator(String configFile)
throws ParserConfigurationException, FileNotFoundException, SAXException, IOException,
XPathExpressionException {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(new FileInputStream(configFile));
url = getConfigValue("access", "url", doc);
if (url.equals(""))
throw new AnnotationException(
"Configuration file " + configFile + " has missing value 'url'.");
}
protected void doGet(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
try {
DateFormat df = DateFormat.getDateTimeInstance();
String titleStr = "C3P0 Status - " + df.format(new Date());
DocumentBuilderFactory fact = DocumentBuilderFactory.newInstance();
DocumentBuilder db = fact.newDocumentBuilder();
Document doc = db.newDocument();
Element htmlElem = doc.createElement("html");
Element headElem = doc.createElement("head");
Element titleElem = doc.createElement("title");
titleElem.appendChild(doc.createTextNode(titleStr));
Element bodyElem = doc.createElement("body");
Element h1Elem = doc.createElement("h1");
h1Elem.appendChild(doc.createTextNode(titleStr));
Element h3Elem = doc.createElement("h3");
h3Elem.appendChild(doc.createTextNode("PooledDataSources"));
Element pdsDlElem = doc.createElement("dl");
pdsDlElem.setAttribute("class", "PooledDataSources");
for (Iterator ii = C3P0Registry.getPooledDataSources().iterator(); ii.hasNext(); ) {
PooledDataSource pds = (PooledDataSource) ii.next();
StatusReporter sr = findStatusReporter(pds, doc);
pdsDlElem.appendChild(sr.reportDtElem());
pdsDlElem.appendChild(sr.reportDdElem());
}
headElem.appendChild(titleElem);
htmlElem.appendChild(headElem);
bodyElem.appendChild(h1Elem);
bodyElem.appendChild(h3Elem);
bodyElem.appendChild(pdsDlElem);
htmlElem.appendChild(bodyElem);
res.setContentType("application/xhtml+xml");
TransformerFactory tf = TransformerFactory.newInstance();
Transformer transformer = tf.newTransformer();
Source src = new DOMSource(doc);
Result result = new StreamResult(res.getOutputStream());
transformer.transform(src, result);
} catch (IOException e) {
throw e;
} catch (Exception e) {
throw new ServletException(e);
}
}
public static final Skeleton loadSkeleton(File file) {
try {
FileInputStream input_stream = new FileInputStream(file);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(true);
DocumentBuilder builder = factory.newDocumentBuilder();
builder.setErrorHandler(new GeometryErrorHandler());
Document document = builder.parse(input_stream);
Element root = document.getDocumentElement();
return parseSkeleton(root);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static {
try {
URL url = SpellCheckActivator.bundleContext.getBundle().getResource(RESOURCE_LOC);
InputStream stream = url.openStream();
if (stream == null) throw new IOException();
// strict parsing options
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(false);
factory.setIgnoringComments(true);
factory.setIgnoringElementContentWhitespace(true);
// parses configuration xml
/*-
* Warning: Felix is unable to import the com.sun.rowset.internal
* package, meaning this can't use the XmlErrorHandler. This causes
* a warning and a default handler to be attached. Otherwise this
* should have: builder.setErrorHandler(new XmlErrorHandler());
*/
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(stream);
// iterates over nodes, parsing contents
Node root = doc.getChildNodes().item(1);
NodeList categories = root.getChildNodes();
for (int i = 0; i < categories.getLength(); ++i) {
Node node = categories.item(i);
if (node.getNodeName().equals(NODE_DEFAULTS)) {
parseDefaults(node.getChildNodes());
} else if (node.getNodeName().equals(NODE_LOCALES)) {
parseLocales(node.getChildNodes());
} else {
logger.warn("Unrecognized category: " + node.getNodeName());
}
}
} catch (IOException exc) {
logger.error("Unable to load spell checker parameters", exc);
} catch (SAXException exc) {
logger.error("Unable to parse spell checker parameters", exc);
} catch (ParserConfigurationException exc) {
logger.error("Unable to parse spell checker parameters", exc);
}
}
public void CaricamentoFile() {
DocumentBuilderFactory factory;
DocumentBuilder parser;
Document document;
try {
factory = DocumentBuilderFactory.newInstance();
parser = factory.newDocumentBuilder();
InputStream is = getClass().getClassLoader().getResource("text/caselle.xml").openStream();
document = parser.parse(is);
handleDocument(document);
} catch (Exception ex) {
System.out.println("Errore." + ex);
ex.printStackTrace();
}
}
/**
* Given a DICOM object encoded as a list of attributes, get an XML document as a DOM tree.
*
* @param list the list of DICOM attributes
*/
public Document getDocument(AttributeList list) {
Document document = db.newDocument();
org.w3c.dom.Node element = document.createElement("DicomObject");
document.appendChild(element);
addAttributesFromListToNode(list, document, element);
return document;
}
public static void testEnum() throws Exception {
Builder b = new Builder();
b.addClasspath(new File("bin"));
b.setProperty("Export-Package", "test.metatype");
b.setProperty("-metatype", "*");
b.build();
assertEquals(0, b.getErrors().size());
assertEquals(0, b.getWarnings().size());
Resource r = b.getJar().getResource("OSGI-INF/metatype/test.metatype.MetatypeTest$Enums.xml");
IO.copy(r.openInputStream(), System.err);
Document d = db.parse(r.openInputStream());
assertEquals(
"http://www.osgi.org/xmlns/metatype/v1.1.0", d.getDocumentElement().getNamespaceURI());
Properties p = new Properties();
p.setProperty("r", "requireConfiguration");
p.setProperty("i", "ignoreConfiguration");
p.setProperty("o", "optionalConfiguration");
Enums enums = Configurable.createConfigurable(Enums.class, (Map<Object, Object>) p);
assertEquals(Enums.X.requireConfiguration, enums.r());
assertEquals(Enums.X.ignoreConfiguration, enums.i());
assertEquals(Enums.X.optionalConfiguration, enums.o());
}
private void createDOM() throws ParserConfigurationException {
if (dbf == null) {
dbf = DocumentBuilderFactory.newInstance();
db = dbf.newDocumentBuilder();
dil = (DOMImplementationLS) db.getDOMImplementation();
dw = dil.createDOMWriter();
}
}
private void processXml(Node operation)
throws ParserConfigurationException, TransformerConfigurationException {
List<Node> targets = getChildNodes(operation, "target");
List<Node> appendOpNodes = getChildNodes(operation, "append");
List<Node> setOpNodes = getChildNodes(operation, "set");
List<Node> replaceOpNodes = getChildNodes(operation, "replace");
List<Node> removeOpNodes = getChildNodes(operation, "remove");
if (targets.isEmpty()) {
return;
}
for (int t = 0; t < targets.size(); t++) {
File target = new File(absolutePath(targets.get(t).getTextContent()));
if (!target.exists()) {
Utils.onError(new Error.FileNotFound(target.getPath()));
return;
}
DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document doc = null;
try {
doc = db.parse(target);
} catch (Exception ex) {
Utils.onError(new Error.FileParse(target.getPath()));
return;
}
for (int i = 0; i < removeOpNodes.size(); i++) removeXmlEntry(doc, removeOpNodes.get(i));
for (int i = 0; i < replaceOpNodes.size(); i++) replaceXmlEntry(doc, replaceOpNodes.get(i));
for (int i = 0; i < setOpNodes.size(); i++) setXmlEntry(doc, setOpNodes.get(i));
for (int i = 0; i < appendOpNodes.size(); i++) appendXmlEntry(doc, appendOpNodes.get(i));
try {
OutputFormat format = new OutputFormat(doc);
format.setOmitXMLDeclaration(true);
format.setLineWidth(65);
format.setIndenting(true);
format.setIndent(4);
Writer out = new FileWriter(target);
XMLSerializer serializer = new XMLSerializer(out, format);
serializer.serialize(doc);
} catch (IOException e) {
Utils.onError(new Error.WriteXmlConfig(target.getPath()));
}
}
}
/**
* Reads an XML document from an input source and copies its values into the specified object
*
* @param ob The object to receive the values
* @param source The location of the XML document
* @throws IOException If there is an error reading the document
*/
public void readObject(Object ob, InputSource source) throws IOException {
try {
// Create a document builder to read the document
DocumentBuilder builder = factory.newDocumentBuilder();
// Read the document
Document doc = builder.parse(source);
// Get the root element
Element element = doc.getDocumentElement();
// Copy the root element into the bean
readObject(ob, element);
} catch (SAXException exc) {
throw new IOException("Error parsing XML document: " + exc.toString());
} catch (ParserConfigurationException exc) {
throw new IOException("Error parsing XML document: " + exc.toString());
}
}
protected static Document GetXMLDocument(String url, int timeoutMS) {
try {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
InputStream input = HTMLTools.inputStream_GET(url, timeoutMS);
InputStreamReader reader = new InputStreamReader(input, ENCODING_UTF8);
InputSource inSrc = new InputSource(reader);
inSrc.setEncoding(ENCODING_UTF8);
return db.parse(inSrc);
} catch (ParserConfigurationException pce) {
Print.logError("Parse error: " + pce);
return null;
} catch (SAXException se) {
Print.logError("Parse error: " + se);
return null;
} catch (IOException ioe) {
Print.logError("IO error: " + ioe);
return null;
}
}
/**
* Save the XML description of the circuit
*
* @param output an output stream to write in
* @return true if the dump was successful, false either
*/
public boolean dumpToXml(OutputStream output) {
Document doc;
Element root;
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder;
try {
builder = factory.newDocumentBuilder();
doc = builder.newDocument();
} catch (ParserConfigurationException pce) {
System.err.println("dumpToXmlFile: unable to write XML save file.");
return false;
}
root = doc.createElement("Circuit");
root.setAttribute("name", this.getName());
for (iterNodes = this.nodes.iterator(); iterNodes.hasNext(); )
iterNodes.next().dumpToXml(doc, root);
root.normalize();
doc.appendChild(root);
try {
TransformerFactory tffactory = TransformerFactory.newInstance();
Transformer transformer = tffactory.newTransformer();
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
DOMSource source = new DOMSource(doc);
StreamResult result = new StreamResult(output);
transformer.transform(source, result);
} catch (TransformerConfigurationException tce) {
System.err.println("dumpToXmlFile: Configuration Transformer exception.");
return false;
} catch (TransformerException te) {
System.err.println("dumpToXmlFile: Transformer exception.");
return false;
}
return true;
}
private void create() {
try {
tracks = new Vector();
hash = new Hashtable();
createDOM();
doc = db.newDocument();
docElt = doc.createElement(docElementName);
doc.appendChild(docElt);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Marshall a Genotype to an XML Document representation, including its population of Chromosome
* instances.
*
* @param a_subject the genotype to represent as an XML document
* @return a Document object representing the given Genotype
* @author Neil Rotstan
* @since 1.0
* @deprecated use XMLDocumentBuilder instead
*/
public static Document representGenotypeAsDocument(final Genotype a_subject) {
// DocumentBuilders do not have to be thread safe, so we have to
// protect creation of the Document with a synchronized block.
// -------------------------------------------------------------
Document genotypeDocument;
synchronized (m_lock) {
genotypeDocument = m_documentCreator.newDocument();
}
Element genotypeElement = representGenotypeAsElement(a_subject, genotypeDocument);
genotypeDocument.appendChild(genotypeElement);
return genotypeDocument;
}
/**
* Marshall a Chromosome instance to an XML Document representation, including its contained Gene
* instances.
*
* @param a_subject the chromosome to represent as an XML document
* @return a Document object representing the given Chromosome
* @author Neil Rotstan
* @since 1.0
* @deprecated use XMLDocumentBuilder instead
*/
public static Document representChromosomeAsDocument(final IChromosome a_subject) {
// DocumentBuilders do not have to be thread safe, so we have to
// protect creation of the Document with a synchronized block.
// -------------------------------------------------------------
Document chromosomeDocument;
synchronized (m_lock) {
chromosomeDocument = m_documentCreator.newDocument();
}
Element chromosomeElement = representChromosomeAsElement(a_subject, chromosomeDocument);
chromosomeDocument.appendChild(chromosomeElement);
return chromosomeDocument;
}
protected Object exec(Object[] args, Context context) {
int nargs = args.length;
Object schema = null;
Map properties = null;
Object errorHandler;
Object input;
switch (nargs) {
case 4:
schema = args[3];
case 3:
properties = (Map) args[2];
case 2:
errorHandler = args[1];
break;
case 1:
errorHandler = Util.getDefaultErrorHandler(context);
break;
default:
undefined(args, context);
return null;
}
input = args[0];
if (properties == null) {
properties = new LinkedHashMap();
}
if (schema != null) {
properties.put(Util.KEY_SCHEMA, schema);
}
DocumentBuilder builder = Util.getDocumentBuilder(properties, context);
if (errorHandler != null) {
builder.setErrorHandler((ErrorHandler) Util.contentHandler(errorHandler, context));
}
try {
return builder.parse(Util.inputSource(input, context));
} catch (IOException e1) {
throw new PnutsException(e1, context);
} catch (SAXException e2) {
throw new PnutsException(e2, context);
}
}
public void load(InputStream is) throws IOException, ParserConfigurationException, SAXException {
doc = db.parse(is);
docElt = doc.getDocumentElement();
if (docElt.getTagName().equals(docElementName)) {
NodeList nl = docElt.getElementsByTagName(trackElementName);
for (int i = 0; i < nl.getLength(); i++) {
Element elt = (Element) nl.item(i);
Track track = new Track(elt);
tracks.add(track);
hash.put(track.getKey(), track);
}
}
}
private void call(String script)
throws ParserConfigurationException, TransformerConfigurationException {
File callerScript = this.currentScript;
Document doc = null;
try {
this.currentScript = new File(script);
DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
doc = db.parse(this.currentScript);
} catch (Exception ex) {
this.currentScript = callerScript;
Utils.onError(new Error.FileParse(script));
return;
}
NodeList operations = doc.getDocumentElement().getChildNodes();
for (int i = 0; i < operations.getLength(); i++) {
Node operation = operations.item(i);
if (operation.getNodeType() != Node.ELEMENT_NODE) continue;
call(operation);
}
this.currentScript = callerScript;
}
public void handlePageBody(PageContext pc) throws ServletException, IOException {
ServletContext context = pc.getServletContext();
Document doc = null;
try {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
doc = builder.newDocument();
} catch (Exception e) {
throw new ServletException(e);
}
Element rootElem = doc.createElement("xaf");
doc.appendChild(rootElem);
try {
DatabaseContextFactory.createCatalog(pc, rootElem);
transform(pc, doc, ACE_CONFIG_ITEM_PROPBROWSERXSL);
} catch (NamingException e) {
PrintWriter out = pc.getResponse().getWriter();
out.write(e.toString());
e.printStackTrace(out);
}
}
public String getFolderName(String pageCode) {
String usefulSection =
pageCode.substring(
pageCode.indexOf("<h3 id=\"breadcrumb\">"),
pageCode.indexOf("<div id=\"list-view\" class=\"view\""));
String folderName;
try {
DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
InputSource is = new InputSource();
is.setCharacterStream(new StringReader(usefulSection));
Document doc = db.parse(is);
NodeList divs = doc.getElementsByTagName("h3");
for (int i = 0; i < divs.getLength(); i++) {
Element div = (Element) divs.item(i);
String a = div.getTextContent();
folderName = a.substring(a.indexOf("/>") + 2).trim();
return folderName;
}
} catch (Exception e) {
debug(e.toString());
}
return "Error!";
}
public static void testADWithInheritance() throws Exception {
Builder b = new Builder();
b.addClasspath(new File("bin"));
b.setProperty("Export-Package", "test.metatype");
b.setProperty("-metatype", "*");
b.setProperty("-metatype-inherit", "true");
b.build();
Resource r =
b.getJar()
.getResource(
"OSGI-INF/metatype/test.metatype.MetatypeTest$TestADWithInheritanceChild.xml");
assertEquals(0, b.getErrors().size());
assertEquals(0, b.getWarnings().size());
System.err.println(b.getJar().getResources().keySet());
assertNotNull(r);
IO.copy(r.openInputStream(), System.err);
Document d = db.parse(r.openInputStream());
assertAD(
d, "fromChild", "From child", "fromChild", null, null, null, 0, "String", null, null, null);
assertAD(
d,
"fromSuperOne",
"From super one",
"fromSuperOne",
null,
null,
null,
0,
"String",
null,
null,
null);
assertAD(
d,
"fromSuperTwo",
"From super two",
"fromSuperTwo",
null,
null,
null,
0,
"String",
null,
null,
null);
}
public static void testSimple() throws Exception {
Builder b = new Builder();
b.addClasspath(new File("bin"));
b.setProperty("Export-Package", "test.metatype");
b.setProperty("-metatype", "*");
b.build();
Resource r =
b.getJar().getResource("OSGI-INF/metatype/test.metatype.MetatypeTest$TestSimple.xml");
assertEquals(0, b.getErrors().size());
assertEquals(0, b.getWarnings().size());
System.err.println(b.getJar().getResources().keySet());
assertNotNull(r);
IO.copy(r.openInputStream(), System.err);
Document d = db.parse(r.openInputStream());
assertEquals("TestSimple", xpath.evaluate("//OCD/@name", d));
assertEquals("simple", xpath.evaluate("//OCD/@description", d));
assertEquals("test.metatype.MetatypeTest$TestSimple", xpath.evaluate("//OCD/@id", d));
assertEquals("test.metatype.MetatypeTest$TestSimple", xpath.evaluate("//Designate/@pid", d));
assertEquals("test.metatype.MetatypeTest$TestSimple", xpath.evaluate("//Object/@ocdref", d));
assertEquals("simple", xpath.evaluate("//OCD/AD[@id='simple']/@id", d));
assertEquals("Simple", xpath.evaluate("//OCD/AD[@id='simple']/@name", d));
assertEquals("String", xpath.evaluate("//OCD/AD[@id='simple']/@type", d));
assertEquals("true", xpath.evaluate("//OCD/AD[@id='notSoSimple']/@required", d));
/**
* https://github.com/bndtools/bnd/issues/281
*
* <p>Using the Bnd annotations library (1.52.3), the generated metatype file will have
* required='false' for all fields annotated with @Meta.AD(). When this annotation is omitted,
* or when the required property is explicitly set, the field is correctly marked as required.
* Taking a glance at the code, the bug appears to be due to aQute.bnd.osgi.Annotation using
* aQute.bnd.annotation.metatype.Configurable internally for bridging Bnd-annotations to
* Java-annotations. This configurable only obtains the values from the Bnd-annotation, omitting
* the defaults defined in the Java annotation. The workaround is to explicitly mention the
* required property on each field annotated with @Meta.AD.
*/
assertEquals("true", xpath.evaluate("//OCD/AD[@id='simple']/@required", d));
assertEquals(
Integer.MAX_VALUE + "", xpath.evaluate("//OCD/AD[@id='notSoSimple']/@cardinality", d));
}
static void assertOCD(
Builder b,
String cname,
String id,
String name,
String description,
String designate,
boolean factory,
String localization)
throws Exception {
Resource r = b.getJar().getResource("OSGI-INF/metatype/" + cname + ".xml");
assertNotNull(r);
IO.copy(r.openInputStream(), System.err);
Document d = db.parse(r.openInputStream());
assertEquals(id, xpath.evaluate("//OCD/@id", d, XPathConstants.STRING));
assertEquals(name, xpath.evaluate("//OCD/@name", d, XPathConstants.STRING));
assertEquals(
localization == null ? cname : localization,
xpath.evaluate("//OCD/@localization", d, XPathConstants.STRING));
assertEquals(
description == null ? "" : description,
xpath.evaluate("//OCD/@description", d, XPathConstants.STRING));
if (designate == null) {
assertEquals(id, xpath.evaluate("//Designate/@pid", d, XPathConstants.STRING));
if (factory)
assertEquals(id, xpath.evaluate("//Designate/@factoryPid", d, XPathConstants.STRING));
} else {
assertEquals(designate, xpath.evaluate("//Designate/@pid", d, XPathConstants.STRING));
if (factory)
assertEquals(
designate, xpath.evaluate("//Designate/@factoryPid", d, XPathConstants.STRING));
}
assertEquals(id, xpath.evaluate("//Object/@ocdref", d, XPathConstants.STRING));
}