public void testForCyclicFalse() { ComplexTypeDescriptor a = new ComplexTypeDescriptor(); a.setName("a"); a.setType("person"); ComplexTypeDescriptor b = new ComplexTypeDescriptor(); b.setName("b"); b.setType("name"); ComplexTypeDescriptor c = new ComplexTypeDescriptor(); c.setName("c"); c.setType("age"); a.getElements().add(b); a.getElements().add(c); assertFalse("should be not identified as cyclic", TypeDescriptor .isCyclic(a)); }
if (outputNameList.contains(child.getName())) { int i = outputNameList.indexOf(child.getName()); TypeDescriptor descriptorForChild = ((ComplexTypeDescriptor)typeDescriptor).elementForName(outputNames[i]); if (outputTypes[i].startsWith("l(") && descriptorForChild instanceof ArrayTypeDescriptor && !((ArrayTypeDescriptor)descriptorForChild).isWrapped()) { boolean isXMLContent=outputTypes[i].contains("text/xml");
public void testQNameAsString() { ComplexTypeDescriptor a = new ComplexTypeDescriptor(); a.setQnameFromString("{URI}localPart"); assertEquals("URI", a.getQname().getNamespaceURI()); assertEquals("localPart", a.getQname().getLocalPart()); a = new ComplexTypeDescriptor(); a.setQnameFromString("{}localPart"); assertEquals("", a.getQname().getNamespaceURI()); assertEquals("localPart", a.getQname().getLocalPart()); }
/** * {@inheritDoc} * */ public Map<String, TypeDescriptor> getTypeDescriptorsForInputPorts() throws UnknownOperationException, IOException { Map<String, TypeDescriptor> descriptors = new HashMap<String, TypeDescriptor>(); if (typeDescriptor instanceof ComplexTypeDescriptor) { for (TypeDescriptor desc : ((ComplexTypeDescriptor)typeDescriptor).getElements()) { descriptors.put(desc.getName(), desc); } } else if (typeDescriptor instanceof ArrayTypeDescriptor) { TypeDescriptor desc = ((ArrayTypeDescriptor)typeDescriptor).getElementType(); descriptors.put(typeDescriptor.getName(), desc); } return descriptors; } }
List<TypeDescriptor> elements = ((ComplexTypeDescriptor) descriptor).getElements(); String[] names = new String[elements.size()]; Class<?>[] types = new Class<?>[elements.size()]; List<TypeDescriptor> attributes = ((ComplexTypeDescriptor) descriptor).getAttributes(); String[] elementNames = Arrays.copyOf(names, names.length); Arrays.sort(elementNames);
.getElements().size()); assertEquals("wrong name for first element", "bid", (typeDesc.getElements().get(0)).getName()); assertEquals("wrong name for 2nd element", "spokeModel", (typeDesc.getElements().get(1)).getName()); assertEquals("wrong name for 3rd element", "subunit", (typeDesc.getElements().get(2)).getName()); typeDesc.getElements().get(2) instanceof ArrayTypeDescriptor); ArrayTypeDescriptor arrayTypeDesc = (ArrayTypeDescriptor) typeDesc .getElements().get(2); .getType()); typeDesc.getElements().size()); assertEquals("wrong name for first element", "id", (typeDesc.getElements().get(0)).getName()); assertEquals("wrong type for first element", "int", (typeDesc.getElements().get(0)).getType()); (typeDesc.getElements().get(6)).getName()); assertEquals("wrong type for last element", "int", (typeDesc.getElements().get(6)).getType());
ComplexTypeDescriptor complexTypeDesc = (ComplexTypeDescriptor) inputs .get(0); assertEquals("wrong name", "parameters", complexTypeDesc.getName()); assertEquals("wrong number of elements", 3, complexTypeDesc .getElements().size()); .getElements().get(0); assertFalse("db should not be unbounded", typeDesc.isUnbounded()); typeDesc = complexTypeDesc.getElements().get(1); assertEquals("wrong name", "tool", typeDesc.getName()); assertEquals("wrong type", "string", typeDesc.getType()); assertFalse("tool should not be unbounded", typeDesc.isUnbounded()); typeDesc = complexTypeDesc.getElements().get(2); assertEquals("wrong name", "email", typeDesc.getName()); assertEquals("wrong type", "string", typeDesc.getType());
public void testRetrieveSignitureForArrayDescriptor2() { ArrayTypeDescriptor desc = new ArrayTypeDescriptor(); desc.setName("AnArray"); desc.setType("complextype"); ComplexTypeDescriptor complex = new ComplexTypeDescriptor(); complex.setName("complex"); complex.setType("complextype"); desc.setElementType(complex); String[] names = new String[1]; Class<?>[] types = new Class[1]; List<TypeDescriptor> params = new ArrayList<TypeDescriptor>(); params.add(desc); TypeDescriptor.retrieveSignature(params, names, types); assertEquals("AnArray", names[0]); assertEquals(org.w3c.dom.Element.class, types[0]); }
@SuppressWarnings("unchecked") @Test public void testLiteralParserResultInTextBlock() throws Exception { List response = new ArrayList(); String xml = "<testResponse><out><data name="a">some data</data><data name="b">some more data</data></out></testResponse>"; DocumentBuilder builder = DocumentBuilderFactory.newInstance() .newDocumentBuilder(); Document doc = builder.parse(new ByteArrayInputStream(xml.getBytes())); response.add(new SOAPBodyElement(doc.getDocumentElement())); TypeDescriptor descriptor = new ComplexTypeDescriptor(); descriptor.setName("testResponse"); SOAPResponseLiteralParser parser = new SOAPResponseLiteralParser( Collections.singletonList(descriptor)); Map outputMap = parser.parse(response); assertNotNull("no output map returned", outputMap); assertEquals("map should contain 1 element", 1, outputMap.size()); Object testResponse = outputMap.get("testResponse"); assertNotNull("there should be an output named 'testReponse'", testResponse); assertEquals("output data should be a string", String.class, testResponse.getClass()); assertEquals( "xml is wrong", "<testResponse><out><data name="a">some data</data><data name="b">some more data</data></out></testResponse>", testResponse.toString()); }
/** * {@inheritDoc} * */ public Map<String, TypeDescriptor> getTypeDescriptorsForOutputPorts() throws UnknownOperationException, IOException { Map<String, TypeDescriptor> descriptors = new HashMap<String, TypeDescriptor>(); if (typeDescriptor instanceof ComplexTypeDescriptor) { for (TypeDescriptor desc : ((ComplexTypeDescriptor) typeDescriptor) .getElements()) { descriptors.put(desc.getName(), desc); } } else if (typeDescriptor instanceof ArrayTypeDescriptor) { TypeDescriptor desc = ((ArrayTypeDescriptor)typeDescriptor).getElementType(); descriptors.put(typeDescriptor.getName(), desc); } return descriptors; } }
List<TypeDescriptor> elements = ((ComplexTypeDescriptor) descriptor).getElements(); String[] names = new String[elements.size()]; Class<?>[] types = new Class<?>[elements.size()]; List<TypeDescriptor> attributes = ((ComplexTypeDescriptor) descriptor).getAttributes(); String[] elementNames = Arrays.copyOf(names, names.length); Arrays.sort(elementNames);
@SuppressWarnings("unchecked") @Test public void testLiteralParser() throws Exception { List response = new ArrayList(); String xml = "<testResponse><out><data name=\"a\">some data</data><data name=\"b\">some more data</data></out></testResponse>"; DocumentBuilder builder = DocumentBuilderFactory.newInstance() .newDocumentBuilder(); Document doc = builder.parse(new ByteArrayInputStream(xml.getBytes())); response.add(new SOAPBodyElement(doc.getDocumentElement())); TypeDescriptor descriptor = new ComplexTypeDescriptor(); descriptor.setName("testResponse"); SOAPResponseLiteralParser parser = new SOAPResponseLiteralParser( Collections.singletonList(descriptor)); Map outputMap = parser.parse(response); assertNotNull("no output map returned", outputMap); assertEquals("map should contain 1 element", 1, outputMap.size()); Object testResponse = outputMap.get("testResponse"); assertNotNull("there should be an output named 'testReponse'", testResponse); assertEquals("output data should be a string", String.class, testResponse.getClass()); assertEquals( "xml is wrong", "<testResponse><out><data name=\"a\">some data</data><data name=\"b\">some more data</data></out></testResponse>", testResponse.toString()); }
public void testForCyclicTrue() { ComplexTypeDescriptor a = new ComplexTypeDescriptor(); a.setName("a"); a.setType("outertype"); ComplexTypeDescriptor b = new ComplexTypeDescriptor(); b.setName("b"); b.setType("middletype"); ComplexTypeDescriptor c = new ComplexTypeDescriptor(); c.setName("c"); c.setType("innertype"); a.getElements().add(b); b.getElements().add(c); c.getElements().add(a); assertTrue("should be identified as cyclic", TypeDescriptor.isCyclic(a)); }
public TypeDescriptor getTypeDescriptorForOutputPort(String portName) { TypeDescriptor result = null; if (typeDescriptor instanceof ComplexTypeDescriptor) { for (TypeDescriptor desc : ((ComplexTypeDescriptor) typeDescriptor) .getElements()) { if (desc.getName().equals(portName)) { result = desc; break; } } } else if (typeDescriptor instanceof ArrayTypeDescriptor) { TypeDescriptor desc = ((ArrayTypeDescriptor)typeDescriptor).getElementType(); if (typeDescriptor.getName().equals(portName)) { result = desc; } } return result; }
TypeDescriptor descriptor = new ComplexTypeDescriptor(); descriptor.setName("result"); SOAPResponseEncodedMultiRefParser parser = new SOAPResponseEncodedMultiRefParser(
private void setDataElementNamespace(String key, Element dataElement) { if (typeDescriptor instanceof ComplexTypeDescriptor) { TypeDescriptor elementTypeDescriptor = ((ComplexTypeDescriptor) typeDescriptor) .elementForName(key); if (elementTypeDescriptor != null) { String nsURI=null; if (elementTypeDescriptor instanceof BaseTypeDescriptor) { nsURI=elementTypeDescriptor.getNamespaceURI(); //this is some protective code against old workflows that had the base element namespace incorrectly //declared (it was using the type NS, rather than the element NS. if (nsURI.contains("XMLSchema") && nsURI.contains("http://www.w3.org")) { nsURI=typeDescriptor.getNamespaceURI(); } } else { nsURI=elementTypeDescriptor.getNamespaceURI(); } if (nsURI!=null && nsURI.length()>0) { updateElementNamespace(dataElement, nsURI); } } } }
@Test public void testCyclicToElement() throws Exception { ComplexTypeDescriptor a = new ComplexTypeDescriptor(); a.setName("a"); a.setType("typename"); a.setQnameFromString("{namespace}typename"); ComplexTypeDescriptor b = new ComplexTypeDescriptor(); b.setName("b"); b.setType("typename2"); b.setQnameFromString("{namespace}typename2"); a.getElements().add(b); b.getElements().add(a); Element el = XMLSplitterSerialisationHelper .typeDescriptorToExtensionXML(a); String xml = new XMLOutputter().outputString(el); assertEquals( "unexpected xml", "<s:extensions xmlns:s=\"http://org.embl.ebi.escience/xscufl/0.1alpha\"><s:complextype optional=\"false\" unbounded=\"false\" typename=\"typename\" name=\"a\" qname=\"{namespace}typename\"><s:elements><s:complextype optional=\"false\" unbounded=\"false\" typename=\"typename2\" name=\"b\" qname=\"{namespace}typename2\"><s:elements><s:complextype id=\"{namespace}typename\" optional=\"false\" unbounded=\"false\" typename=\"typename\" name=\"a\" /></s:elements></s:complextype></s:elements></s:complextype></s:extensions>", xml); }
/** * Returns a TypeDescriptor for the given port name. If the port cannot be found, or is not based upon a complex type, then null is returned. * @param portName * @return */ public TypeDescriptor getTypeDescriptorForInputPort(String portName) { TypeDescriptor result = null; if (typeDescriptor instanceof ComplexTypeDescriptor) { for (TypeDescriptor desc : ((ComplexTypeDescriptor)typeDescriptor).getElements()) { if (desc.getName().equals(portName)) { result = desc; break; } } } else if (typeDescriptor instanceof ArrayTypeDescriptor) { TypeDescriptor desc = ((ArrayTypeDescriptor)typeDescriptor).getElementType(); if (typeDescriptor.getName().equals(portName)) { result = desc; } } return result; }
public void testComplex() { TypeDescriptor complex=new ComplexTypeDescriptor(); complex.setName("acomplex"); complex.setType("complextype"); List<TypeDescriptor> params=new ArrayList<TypeDescriptor>(); String [] names=new String[1]; Class<?> [] types=new Class[1]; params.add(complex); TypeDescriptor.retrieveSignature(params, names, types); assertEquals("should only be 1 type",1,types.length); assertEquals("should only be 1 name",1,names.length); assertEquals("name should be adecimal","acomplex",names[0]); assertEquals("type should be string",org.w3c.dom.Element.class,types[0]); }
public void testForCyclicTrueWithArray() { ComplexTypeDescriptor a = new ComplexTypeDescriptor(); a.setName("a"); a.setType("outertype"); ArrayTypeDescriptor b = new ArrayTypeDescriptor(); b.setName("b"); b.setType("arraytype"); ComplexTypeDescriptor c = new ComplexTypeDescriptor(); c.setName("c"); c.setType("innertype"); a.getElements().add(b); b.setElementType(c); c.getElements().add(a); assertTrue("should be identified as cyclic", TypeDescriptor.isCyclic(a)); }