java类javax.xml.stream.FactoryConfigurationError的实例源码

@Test
public void readIntAttribute() throws XMLStreamException, FactoryConfigurationError, IOException {
  URL url = XmlHelperTest.class.getResource("/xml/kb-layout.xml");
  XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(url.openStream());
  reader.next();
  reader.require(XMLStreamConstants.START_ELEMENT, null, XmlHelper.KEYBOARD);

  assertEquals(Integer.valueOf(40),
      XmlHelper.readIntAttribute(reader, XmlHelper.ATTR_KEY_WIDTH).orElse(-1));
  assertEquals(Integer.valueOf(30),
      XmlHelper.readIntAttribute(reader, XmlHelper.ATTR_KEY_HEIGHT).orElse(-1));
  assertEquals(Integer.valueOf(0),
      XmlHelper.readIntAttribute(reader, XmlHelper.ATTR_H_GAP).orElse(-1));
  assertEquals(Integer.valueOf(0),
      XmlHelper.readIntAttribute(reader, XmlHelper.ATTR_V_GAP).orElse(-1));
  assertNull(XmlHelper.readIntAttribute(reader, "verticalGapX").orElse(null));

  assertEquals(40, XmlHelper.readIntAttribute(reader, XmlHelper.ATTR_KEY_WIDTH, 1));
  assertEquals(30, XmlHelper.readIntAttribute(reader, XmlHelper.ATTR_KEY_HEIGHT, 1));
  assertEquals(0, XmlHelper.readIntAttribute(reader, XmlHelper.ATTR_H_GAP, 1));
  assertEquals(0, XmlHelper.readIntAttribute(reader, XmlHelper.ATTR_V_GAP, 1));
  assertEquals(1, XmlHelper.readIntAttribute(reader, "verticalGapX", 1));
  assertEquals(1, XmlHelper.readIntAttribute(reader, "", 1));
  assertEquals(1, XmlHelper.readIntAttribute(reader, null, 1));
}

@Test
public void readBooleanAttribute()
    throws XMLStreamException, FactoryConfigurationError, IOException {
  URL url = XmlHelperTest.class.getResource("/xml/kb-layout.xml");
  XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(url.openStream());
  reader.next();
  reader.require(XMLStreamConstants.START_ELEMENT, null, XmlHelper.KEYBOARD);

  assertFalse(XmlHelper.readBooleanAttribute(reader, XmlHelper.ATTR_REPEATABLE, false));
  assertFalse(XmlHelper.readBooleanAttribute(reader, "", false));

  while (reader.hasNext()) {
    reader.next();
    if (!reader.isStartElement() || !XmlHelper.KEY.equals(reader.getLocalName())) {
      continue;
    }
    if (32 == XmlHelper.readIntAttribute(reader, XmlHelper.ATTR_CODES, -1)) {
      assertTrue(XmlHelper.readBooleanAttribute(reader, XmlHelper.ATTR_REPEATABLE, false));
      assertTrue(XmlHelper.readBooleanAttribute(reader, XmlHelper.ATTR_MOVABLE, false));
    }

    if (-1 == XmlHelper.readIntAttribute(reader, XmlHelper.ATTR_CODES, 0)) {
      assertTrue(XmlHelper.readBooleanAttribute(reader, XmlHelper.ATTR_STICKY, false));
    }
  }
}

protected void write(Source object, XMLStreamWriter writer) throws FactoryConfigurationError,
    XMLStreamException, DatabindingException {
    if (object == null) {
        return;
    }

    if (object instanceof DOMSource) {
        DOMSource ds = (DOMSource)object;

        Element element = null;
        if (ds.getNode() instanceof Element) {
            element = (Element)ds.getNode();
        } else if (ds.getNode() instanceof Document) {
            element = ((Document)ds.getNode()).getDocumentElement();
        } else {
            throw new DatabindingException("Node type " + ds.getNode().getClass()
                                           + " was not understood.");
        }

        StaxUtils.writeElement(element, writer, false);
    } else {
        StaxUtils.copy(object, writer);
    }
}

private void open(File file) throws XMLStreamException,
        FactoryConfigurationError, FileNotFoundException {
    // open writer
    FileOutputStream fos = new FileOutputStream(file);
    writer = XMLOutputFactory.newInstance().createXMLStreamWriter(fos,
            "UTF-8");

    // start document
    writer.setDefaultNamespace(URI_NS);
    writer.writeStartDocument("UTF-8", "1.0");
    writer.writeCharacters("\n");
    writer.writeStartElement(URI_NS, "journal");
    if (URI_NS.length() > 0) {
        writer.writeDefaultNamespace(URI_NS);
    }
    writer.writeCharacters("\n");

    writer.writeStartElement(URI_NS, "participant");
    writer.writeCharacters(participantId);
    writer.writeEndElement();
}

private void open(File file) throws FileNotFoundException,
        XMLStreamException, FactoryConfigurationError,
        DatatypeConfigurationException {
    // open writer
    FileOutputStream fos = new FileOutputStream(file);
    writer = XMLOutputFactory.newInstance().createXMLStreamWriter(fos,
            "UTF-8");

    // start document
    writer.setDefaultNamespace(URI_NS);
    writer.writeStartDocument("UTF-8", "1.0");
    writer.writeCharacters("\n");
    writer.writeStartElement(URI_NS, "insights");
    if (URI_NS.length() > 0) {
        writer.writeDefaultNamespace(URI_NS);
    }
    writer.writeNamespace("html", URI_NS_XHTML);
    writer.writeCharacters("\n");
    // writer.writeStartElement(URI_NS, "participant");
    // writer.writeCharacters(participantId);
    // writer.writeEndElement();

    // reset index
    index = 0;
    timeConv = new XmlCalendarConverter();
}

/**
 * Test serialization of empty syndication title property. EmployeeName is set to NULL after the update (which is allowed because EmployeeName has default Nullable behavior which is true).
 * Write of an empty atom title tag is allowed within RFC4287 (http://tools.ietf.org/html/rfc4287#section-4.2.14).   
 */
@Test
public void serializeEmployeeWithNullSyndicationTitleProperty() throws IOException, XpathException, SAXException, XMLStreamException, FactoryConfigurationError, ODataException {
  AtomEntityProvider ser = createAtomEntityProvider();
  EntityProviderWriteProperties properties = EntityProviderWriteProperties.serviceRoot(BASE_URI).build();
  employeeData.put("EmployeeName", null);
  ODataResponse response = ser.writeEntry(MockFacade.getMockEdm().getDefaultEntityContainer().getEntitySet("Employees"), employeeData, properties);
  String xmlString = verifyResponse(response);

  assertXpathExists("/a:entry/a:title", xmlString);
  assertXpathEvaluatesTo("", "/a:entry/a:title", xmlString);

  assertXpathExists("/a:entry", xmlString);
  assertXpathEvaluatesTo(BASE_URI.toASCIIString(), "/a:entry/@xml:base", xmlString);

  assertXpathExists("/a:entry/a:content", xmlString);
  assertXpathEvaluatesTo("Employees('1')/$value", "/a:entry/a:content/@src", xmlString);
  assertXpathExists("/a:entry/m:properties", xmlString);
}

@Test
public void serializeEmployeeAndCheckOrderOfPropertyTags() throws IOException, XpathException, SAXException, XMLStreamException, FactoryConfigurationError, ODataException {
  AtomEntityProvider ser = createAtomEntityProvider();
  EntityProviderWriteProperties properties = EntityProviderWriteProperties.serviceRoot(BASE_URI).mediaResourceMimeType("abc").build();
  EdmEntitySet employeeEntitySet = MockFacade.getMockEdm().getDefaultEntityContainer().getEntitySet("Employees");
  ODataResponse response = ser.writeEntry(employeeEntitySet, employeeData, properties);
  String xmlString = verifyResponse(response);

  //        log.debug(xmlString);

  assertXpathExists("/a:entry", xmlString);
  assertXpathExists("/a:entry/a:content", xmlString);
  // verify properties
  assertXpathExists("/a:entry/m:properties", xmlString);
  assertXpathEvaluatesTo("9", "count(/a:entry/m:properties/*)", xmlString);

  // verify order of tags
  List<String> expectedPropertyNamesFromEdm = employeeEntitySet.getEntityType().getPropertyNames();
  verifyTagOrdering(xmlString, expectedPropertyNamesFromEdm.toArray(new String[0]));
}

@Test
public void serializeETagEncoding() throws IOException, XpathException, SAXException, XMLStreamException, FactoryConfigurationError, ODataException {
  Edm edm = MockFacade.getMockEdm();
  EdmTyped roomIdProperty = edm.getEntityType("RefScenario", "Room").getProperty("Id");
  EdmFacets facets = mock(EdmFacets.class);
  when(facets.getConcurrencyMode()).thenReturn(EdmConcurrencyMode.Fixed);
  when(facets.getMaxLength()).thenReturn(3);
  when(((EdmProperty) roomIdProperty).getFacets()).thenReturn(facets);

  roomData.put("Id", "<\">");
  AtomEntityProvider ser = createAtomEntityProvider();
  ODataResponse response = ser.writeEntry(edm.getDefaultEntityContainer().getEntitySet("Rooms"), roomData, DEFAULT_PROPERTIES);

  assertNotNull(response);
  assertNotNull(response.getEntity());
  assertEquals(ContentType.APPLICATION_ATOM_XML_ENTRY_CS_UTF_8.toContentTypeString(), response.getContentHeader());
  assertEquals("W/\"<\">.3\"", response.getETag());

  String xmlString = StringHelper.inputStreamToString((InputStream) response.getEntity());

  assertXpathExists("/a:entry", xmlString);
  assertXpathExists("/a:entry/@m:etag", xmlString);
  assertXpathEvaluatesTo("W/\"<\">.3\"", "/a:entry/@m:etag", xmlString);
}

public FromXMLStreamIterator() throws XMLStreamException {
    XMLInputFactory fac = XMLInputFactory.newInstance();
    try { 
        this.xr = fac.createXMLStreamReader(Files.newInputStream(MzMLStAXParser.this.xml, StandardOpenOption.READ));
    } catch (FactoryConfigurationError | IOException e) {
        LOGGER.log(Level.ERROR, e.getMessage());
        System.exit(-1);
    }
    if (!this.moveToNextSpectrum()){
        LOGGER.log(Level.WARN,  "no spectrum found in mzml file");
    }
}

private T getNextSpectrumFromSeekable() {
    FromXMLStreamBuilder<T> spectrumBuilder = null;
    try {
        InputStream is = Channels.newInputStream(this.seekable);
        XMLStreamReader xr = XMLInputFactory.newInstance()
            .createXMLStreamReader(is);

        while (xr.hasNext()) {
            xr.next();

            if (spectrumBuilder != null) {
                spectrumBuilder.accept(xr);
            }

            if(xr.getEventType() == XMLStreamReader.START_ELEMENT){
                if(xr.getLocalName().equals("spectrum")) {
                    spectrumBuilder = this.factory.create(this.xml.toString(), xr);
                } else if( xr.getLocalName().equals("referenceableParamGroupRef")) {
                    LOGGER.log(Level.WARN, "Random access to spectra will not parse referenceable params");
                }
            } else if(xr.getEventType() == XMLStreamReader.END_ELEMENT) {
                if(xr.getLocalName().equals("spectrum")) {
                    return spectrumBuilder.build();
                }                   
            }
        }
    } catch (XMLStreamException | FactoryConfigurationError e) {
        LOGGER.log(Level.ERROR, e.toString());
    } 

    return null;
}