method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
ServiceMetadataBuilder { public static ServiceMetadataBuilder update(ServiceMetadata metadata) { if (!ServiceMetadataImpl.class.isInstance(metadata)) { throw APIMessages.MESSAGES.unableUpdateMetadataType(metadata.getClass().toString()); } return new ServiceMetadataBuilder((ServiceMetadataImpl)metadata); } private ServiceMetadataBuilder(); private ServiceMetadataBuilder(ServiceMetadataImpl metadata); ServiceMetadataBuilder security(ServiceSecurity security); ServiceMetadataBuilder requiredPolicies(List<Policy> requiredPolicies); ServiceMetadataBuilder providedPolicies(List<Policy> providedPolicies); ServiceMetadataBuilder registrant(Registrant registrant); ServiceMetadataBuilder throttling(Throttling throttling); ServiceMetadata build(); static ServiceMetadataBuilder create(); static ServiceMetadataBuilder update(ServiceMetadata metadata); static ServiceMetadataBuilder createFrom(ServiceMetadata metadata); }### Answer:
@Test public void testUpdate() { Throttling throttling1 = new Throttling().setMaxRequests(50); ServiceMetadata metadata = ServiceMetadataBuilder.create() .throttling(throttling1) .build(); Assert.assertEquals(50, metadata.getThrottling().getMaxRequests()); Throttling throttling2 = new Throttling().setMaxRequests(150); ServiceMetadataBuilder.update(metadata).throttling(throttling2); Assert.assertEquals(150, metadata.getThrottling().getMaxRequests()); }
|
### Question:
BaseValidator implements Validator<T> { @SuppressWarnings("unchecked") @Override public Class<T> getType() { try { ParameterizedType pt = (ParameterizedType) getClass().getGenericSuperclass(); return (Class<T>) pt.getActualTypeArguments()[0]; } catch (Exception e) { return (Class<T>) Object.class; } } BaseValidator(); BaseValidator(QName name); @Override Validator<T> setName(QName name); @Override QName getName(); @SuppressWarnings("unchecked") @Override Class<T> getType(); static ValidationResult validResult(); static ValidationResult invalidResult(String error); static ValidationResult invalidResult(); }### Answer:
@Test public void testTypedValidator() throws Exception { Validator<?> t = new StringValidator(); Assert.assertEquals(String.class, t.getType()); }
@Test public void testUntypedValidator() throws Exception { Validator<?> t = new UntypedValidator(); Assert.assertEquals(Object.class, t.getType()); }
@Test public void testImplementsValidator() throws Exception { Validator<?> t = new ImplementsValidator(); Assert.assertEquals(String.class, t.getType()); }
|
### Question:
Configurations { public static Configuration merge(Configuration fromConfig, Configuration toConfig) { return merge(fromConfig, toConfig, true); } private Configurations(); static Configuration newConfiguration(); static Configuration newConfiguration(String name); static Configuration newConfiguration(QName qname); static Configuration merge(Configuration fromConfig, Configuration toConfig); static Configuration merge(Configuration fromConfig, Configuration toConfig, boolean fromOverridesTo); }### Answer:
@Test public void testMerge() throws Exception { XMLUnit.setIgnoreWhitespace(true); Diff diff; String from_overrides_to_xml = _str_puller.pull(FROM_OVERRIDES_TO_XML, getClass()); diff = XMLUnit.compareXML(from_overrides_to_xml, merge(true)); Assert.assertTrue(diff.toString(), diff.identical()); String from_doesnt_override_to_xml = _str_puller.pull(FROM_DOESNT_OVERRIDE_TO_XML, getClass()); diff = XMLUnit.compareXML(from_doesnt_override_to_xml, merge(false)); Assert.assertTrue(diff.toString(), diff.identical()); }
|
### Question:
ClasspathScanner { public void scan(URL url) throws IOException { File file = toClassPathFile(url); if (file.exists()) { if (file.isDirectory()) { handleDirectory(file, url.getRef()); } else { handleArchive(file); } } else { CommonCoreLogger.ROOT_LOGGER.unknownClasspathURL(file.getAbsolutePath()); } } ClasspathScanner(Filter filter); void scan(URL url); static File toClassPathFile(URL classPathURL); }### Answer:
@Test public void test_folder_with_plus_chars_scan() throws IOException { String resourceName = "some_resource.txt"; ResourceExistsFilter filter = new ResourceExistsFilter(resourceName); ClasspathScanner scanner = new ClasspathScanner(filter); File scanDir = new File("./target/folder+with+plus"); scanDir.delete(); scanDir.mkdirs(); FileWriter writer = new FileWriter(new File(scanDir, resourceName)); try { writer.write("something...."); writer.flush(); } finally { writer.close(); } scanner.scan(scanDir.toURI().toURL()); Assert.assertTrue(filter.resourceExists()); }
@Test public void test_archive_scan() throws IOException { InstanceOfFilter filter = new InstanceOfFilter(CommandMap.class); ClasspathScanner scanner = new ClasspathScanner(filter); scanner.scan(new File("./src/test/resources/classpathscan-test.jar").toURI().toURL()); List<Class<?>> classes = filter.getMatchedTypes(); Assert.assertTrue(classes.contains(CommandMap.class)); Assert.assertTrue(classes.contains(MailcapCommandMap.class)); }
|
### Question:
CamelContextConfigurator { private static void configureShutdownTimeout(CamelContext context, Object value) { int timeout = Integer.parseInt(value.toString()); context.getShutdownStrategy().setTimeout(timeout); } private CamelContextConfigurator(); static final void configure(CamelContext context, ServiceDomain domain); static final void configure(CamelContext context, Map<String, Object> properties); static final void configure(CamelContext context, String name, Object value); static final String SHUTDOWN_TIMEOUT; static final String PERFORMANCE_STATISTICS; static final String CAMEL_CONTEXT_CONFIG; }### Answer:
@Test public void configureShutdownTimeout() throws Exception { final int timeout = 12345; domain.setProperty(CamelContextConfigurator.SHUTDOWN_TIMEOUT, timeout); CamelContextConfigurator.configure(context, domain); Assert.assertEquals(timeout, context.getShutdownStrategy().getTimeout()); }
|
### Question:
CamelContextConfigurator { private static void configurePerformanceStatistics(CamelContext context, Object value) { ManagementStatisticsLevel level = ManagementStatisticsLevel.valueOf(value.toString()); context.getManagementStrategy().setStatisticsLevel(level); } private CamelContextConfigurator(); static final void configure(CamelContext context, ServiceDomain domain); static final void configure(CamelContext context, Map<String, Object> properties); static final void configure(CamelContext context, String name, Object value); static final String SHUTDOWN_TIMEOUT; static final String PERFORMANCE_STATISTICS; static final String CAMEL_CONTEXT_CONFIG; }### Answer:
@Test public void configurePerformanceStatistics() throws Exception { domain.setProperty(CamelContextConfigurator.PERFORMANCE_STATISTICS, "RoutesOnly"); CamelContextConfigurator.configure(context, domain); Assert.assertEquals(ManagementStatisticsLevel.RoutesOnly, context.getManagementStrategy().getStatisticsLevel()); domain.setProperty(CamelContextConfigurator.PERFORMANCE_STATISTICS, "Off"); CamelContextConfigurator.configure(context, domain); Assert.assertEquals(ManagementStatisticsLevel.Off, context.getManagementStrategy().getStatisticsLevel()); domain.setProperty(CamelContextConfigurator.PERFORMANCE_STATISTICS, "All"); CamelContextConfigurator.configure(context, domain); Assert.assertEquals(ManagementStatisticsLevel.All, context.getManagementStrategy().getStatisticsLevel()); }
|
### Question:
CamelContextConfigurator { private static void configureCamelContextAware(CamelContext context, Object value) throws Exception { Class<?> contextAwareClass = Classes.forName(value.toString()); CamelContextAware contextAware = (CamelContextAware)contextAwareClass.newInstance(); contextAware.setCamelContext(context); } private CamelContextConfigurator(); static final void configure(CamelContext context, ServiceDomain domain); static final void configure(CamelContext context, Map<String, Object> properties); static final void configure(CamelContext context, String name, Object value); static final String SHUTDOWN_TIMEOUT; static final String PERFORMANCE_STATISTICS; static final String CAMEL_CONTEXT_CONFIG; }### Answer:
@Test public void configureCamelContextAware() throws Exception { domain.setProperty(CamelContextConfigurator.CAMEL_CONTEXT_CONFIG, MyCustomContextAware.class.getName()); CamelContextConfigurator.configure(context, domain); Assert.assertNotNull(context.getProperty("abc")); Assert.assertEquals("xyz", context.getProperty("abc")); }
|
### Question:
ComponentNames { public static QName qualify(QName componentName, QName referenceName) { return qualify(componentName.getLocalPart(), referenceName.getLocalPart(), componentName.getNamespaceURI()); } private ComponentNames(); static QName qualify(QName componentName, QName referenceName); static QName qualify(String componentName, String referenceName, String namespaceURI); static QName unqualify(ServiceReference reference); static QName unqualify(QName refName); }### Answer:
@Test public void testQualifyQNames() { QName qualified = ComponentNames.qualify(COMPONENT_NAME, SERVICE_NAME); Assert.assertEquals(COMPONENT_NAME.getNamespaceURI(), qualified.getNamespaceURI()); Assert.assertEquals( COMPONENT_NAME.getLocalPart() + "/" + SERVICE_NAME.getLocalPart(), qualified.getLocalPart()); }
@Test public void testQualifyStrings() { QName qualified = ComponentNames.qualify( COMPONENT_NAME.getLocalPart(), SERVICE_NAME.getLocalPart(), COMPONENT_NAME.getNamespaceURI()); Assert.assertEquals(COMPONENT_NAME.getNamespaceURI(), qualified.getNamespaceURI()); Assert.assertEquals( COMPONENT_NAME.getLocalPart() + "/" + SERVICE_NAME.getLocalPart(), qualified.getLocalPart()); }
|
### Question:
Deployment extends AbstractDeployment { public List<String> getActivationTypes() { HashSet<String> types = new HashSet<String>(); CompositeModel composite = getConfig().getComposite(); if (composite != null) { for (CompositeReferenceModel reference : composite.getReferences()) { for (BindingModel binding : reference.getBindings()) { types.add(binding.getType()); } } for (CompositeServiceModel service : composite.getServices()) { for (BindingModel binding : service.getBindings()) { types.add(binding.getType()); } } for (ComponentModel component : composite.getComponents()) { if (component.getImplementation() != null) { types.add(component.getImplementation().getType()); } } } return new ArrayList<String>(types); } Deployment(InputStream configStream); Deployment(SwitchYardModel configModel); void start(); void stop(); void destroy(); @Override Lifecycle getGatwayLifecycle(final QName serviceName, final String bindingName); Activator findActivator(String type); List<String> getActivationTypes(); }### Answer:
@Test public void testActivationTypes() throws Exception { InputStream swConfigStream = Classes.getResourceAsStream("/switchyard-config-mock-01.xml", getClass()); Deployment deployment = new Deployment(swConfigStream); swConfigStream.close(); List<String> types = deployment.getActivationTypes(); Assert.assertEquals(1, types.size()); Assert.assertEquals("mock", types.iterator().next()); }
|
### Question:
ServiceDomainManager { public ServiceDomain createDomain() { return createDomain(ROOT_DOMAIN, null); } ServiceDomainManager(); ServiceDomainManager(SystemSecurity systemSecurity); ServiceDomain createDomain(); ServiceDomain createDomain(QName domainName, SwitchYardModel switchyardConfig); EventManager getEventManager(); ServiceRegistry getRegistry(); static final QName ROOT_DOMAIN; }### Answer:
@Test public void testHandlerRegistration() throws Exception { SwitchYardModel switchyard = new ModelPuller<SwitchYardModel>().pull( "/switchyard-config-properties-01.xml", getClass()); ServiceDomain domain = new ServiceDomainManager().createDomain( new QName("test"), switchyard); Assert.assertEquals("abc-value", domain.getProperty("abc")); Assert.assertEquals("xyz-value", domain.getProperty("xyz")); Assert.assertNull(domain.getProperty("nothing")); }
|
### Question:
RemoteMessage { public Context getContext() { return _context; } RemoteMessage(); RemoteMessage(QName domain, QName service); Context getContext(); Object getContent(); RemoteMessage setContent(Object content); QName getService(); RemoteMessage setService(QName service); QName getDomain(); RemoteMessage setDomain(QName domain); String getOperation(); RemoteMessage setOperation(String operation); RemoteMessage setFault(boolean isFault); boolean isFault(); }### Answer:
@Test public void testDOMProperty() throws Exception { final String expectedXML = "<one number=\"1\"><two number=\"2\"/></one>"; final Element expectedDOM = new ElementPuller().pull(new StringReader(expectedXML)); RemoteMessage msg = new RemoteMessage(); msg.getContext().setProperty("one", expectedDOM); msg = serDeser(msg, RemoteMessage.class); final Element actualDOM = (Element)msg.getContext().getProperty("one").getValue(); final String actualXML = XMLHelper.toString(actualDOM); Assert.assertEquals(expectedXML, actualXML); }
|
### Question:
RoundRobinStrategy extends BaseStrategy { @Override public RemoteEndpoint selectEndpoint(QName serviceName) { if (getRegistry() == null) { return null; } RemoteEndpoint selectedEp = null; List<RemoteEndpoint> eps = getRegistry().getEndpoints(serviceName); if (!eps.isEmpty()) { _endpointIdxs.putIfAbsent(serviceName, new AtomicInteger(0)); AtomicInteger idx = _endpointIdxs.get(serviceName); synchronized (idx) { idx.set(idx.get() % eps.size()); selectedEp = eps.get(idx.getAndIncrement()); } } return selectedEp; } RoundRobinStrategy(); @Override RemoteEndpoint selectEndpoint(QName serviceName); }### Answer:
@Test public void noEndpoints() { Assert.assertNull(robin.selectEndpoint(TEST_SERVICE1)); }
@Test public void oneEndpoint() { registry.addEndpoint(new RemoteEndpoint().setServiceName(TEST_SERVICE1)); Assert.assertNotNull(robin.selectEndpoint(TEST_SERVICE1)); }
@Test public void multipleEndpoints() { RemoteEndpoint ep1 = new RemoteEndpoint().setServiceName(TEST_SERVICE1).setEndpoint("ep1"); RemoteEndpoint ep2 = new RemoteEndpoint().setServiceName(TEST_SERVICE1).setEndpoint("ep2"); RemoteEndpoint ep3 = new RemoteEndpoint().setServiceName(TEST_SERVICE2).setEndpoint("ep3"); RemoteEndpoint ep4 = new RemoteEndpoint().setServiceName(TEST_SERVICE2).setEndpoint("ep4"); registry.addEndpoint(ep1); registry.addEndpoint(ep2); registry.addEndpoint(ep3); registry.addEndpoint(ep4); Assert.assertEquals(ep1, robin.selectEndpoint(TEST_SERVICE1)); Assert.assertEquals(ep3, robin.selectEndpoint(TEST_SERVICE2)); Assert.assertEquals(ep2, robin.selectEndpoint(TEST_SERVICE1)); Assert.assertEquals(ep4, robin.selectEndpoint(TEST_SERVICE2)); Assert.assertEquals(ep1, robin.selectEndpoint(TEST_SERVICE1)); }
|
### Question:
RandomStrategy extends BaseStrategy { @Override public RemoteEndpoint selectEndpoint(QName serviceName) { if (getRegistry() == null) { return null; } RemoteEndpoint selectedEp = null; List<RemoteEndpoint> eps = getRegistry().getEndpoints(serviceName); if (!eps.isEmpty()) { int idx = _random.nextInt(Integer.MAX_VALUE) % eps.size(); selectedEp = eps.get(idx); } return selectedEp; } RandomStrategy(); @Override RemoteEndpoint selectEndpoint(QName serviceName); }### Answer:
@Test public void noEndpoints() { Assert.assertNull(random.selectEndpoint(TEST_SERVICE)); }
@Test public void oneEndpoint() { registry.addEndpoint(new RemoteEndpoint().setServiceName(TEST_SERVICE)); Assert.assertNotNull(random.selectEndpoint(TEST_SERVICE)); }
@Test public void multipleEndpoints() { RemoteEndpoint ep1 = new RemoteEndpoint().setServiceName(TEST_SERVICE).setEndpoint("ep1"); RemoteEndpoint ep2 = new RemoteEndpoint().setServiceName(TEST_SERVICE).setEndpoint("ep2"); registry.addEndpoint(ep1); registry.addEndpoint(ep2); Map<String, AtomicInteger> epCounts = new HashMap<String, AtomicInteger>(); epCounts.put(ep1.getEndpoint(), new AtomicInteger()); epCounts.put(ep2.getEndpoint(), new AtomicInteger()); for (int i = 0; i < 1000; i++) { RemoteEndpoint ep = random.selectEndpoint(TEST_SERVICE); epCounts.get(ep.getEndpoint()).incrementAndGet(); } Assert.assertTrue(epCounts.get(ep1.getEndpoint()).get() > 0); Assert.assertTrue(epCounts.get(ep2.getEndpoint()).get() > 0); }
|
### Question:
BasicDOMTransformer extends AbstractDOMTransformer { @Override public Object transform(Object from) { if (from instanceof Node) { return transformFromDOMNode((Node) from); } else if (from instanceof String) { return transformFromInputSource(new InputSource(new StringReader((String) from))); } else if (from instanceof char[]) { return transformFromInputSource(new InputSource(new StringReader(new String((char[]) from)))); } else if (from instanceof byte[]) { return transformFromInputSource(new InputSource(new ByteArrayInputStream((byte[]) from))); } else if (from instanceof Reader) { return transformFromInputSource(new InputSource((Reader) from)); } else if (from instanceof InputStream) { return transformFromInputSource(new InputSource((InputStream) from)); } else if (from instanceof InputSource) { return transformFromInputSource((InputSource) from); } else if (from instanceof DOMSource) { return transformFromDOMSource((DOMSource) from); } return null; } @Override Object transform(Object from); }### Answer:
@Test public void test_String2DOMSource() throws IOException, SAXException, TransformerException { DefaultMessage message = newMessage(); message.setContent("<x><y/></x>"); DOMSource doms = message.getContent(DOMSource.class); StringWriter writer = new StringWriter(); StreamResult result = new StreamResult(writer); TransformerFactory.newInstance().newTransformer().transform(doms, result); XMLAssert.assertXMLEqual("<x><y/></x>", writer.toString()); }
|
### Question:
JavaService extends BaseService { public static Class<?> parseType(final QName type) { if (type == null) { return null; } final String localPart = type.getLocalPart(); int indexOf = localPart.indexOf(':'); if (indexOf != -1) { return Classes.forName(localPart.substring(indexOf + 1)); } else { return null; } } private JavaService(Set<ServiceOperation> operations, Class<?> serviceInterface); static JavaService fromClass(Class<?> serviceInterface); Class<?> getJavaInterface(); static Class<?> parseType(final QName type); static final String TYPE; }### Answer:
@Test public void testParseType() { final QName intType = new QName("java:java.lang.Integer"); final Class<?> intClass = JavaService.parseType(intType); Assert.assertEquals(Integer.class, intClass); }
@Test public void testParseTypeNull() { final Class<?> intClass = JavaService.parseType(null); Assert.assertEquals(null, intClass); }
@Test public void testParseTypeMissingJavaPrefix() { final QName missingPrefix = new QName("java.lang.Integer"); final Class<?> intClass = JavaService.parseType(missingPrefix); Assert.assertEquals(null, intClass); }
|
### Question:
InputSourceTransforms { @Transformer public String toString(InputSource inSource) { Reader reader = inSource.getCharacterStream(); if (reader != null) { return ReaderTransforms.TRANSFORMER.toString(reader); } InputStream stream = inSource.getByteStream(); if (stream != null) { return InputStreamTransforms.TRANSFORMER.toString(stream); } return null; } @Transformer String toString(InputSource inSource); @Transformer Reader toReader(InputSource inSource); @Transformer InputStream toInputStream(InputSource inSource); @Transformer Integer toInteger(InputSource inSource); @Transformer Long toLong(InputSource inSource); @Transformer Short toShort(InputSource inSource); @Transformer char[] toChars(InputSource inSource); @Transformer Character toCharacter(InputSource inSource); @Transformer byte[] toBytes(InputSource inSource); @Transformer Double toDouble(InputSource inSource); @Transformer Float toFloat(InputSource inSource); static final InputSourceTransforms TRANSFORMER; }### Answer:
@Test public void testToString() throws Exception { Assert.assertEquals("Hello SwitchYard", InputSourceTransforms.TRANSFORMER.toString(newInputSource("Hello SwitchYard"))); }
|
### Question:
WSDLReader { String createRelativePath(String baseURI, String path) { int lastPathIdx = baseURI.lastIndexOf('/'); if (lastPathIdx > 0) { return baseURI.substring(0, lastPathIdx + 1) + path; } else { return path; } } HashSet<ServiceOperation> readWSDL(final String wsdlURI, final String portName); Element readWSDL(final String wsdlURI); }### Answer:
@Test public void testRelativePaths() { String base1 = "base.wsdl"; String base2 = "wsdl/one/base.wsdl"; String base3 = "wsdl/one/two/base.wsdl"; String wsdl = "example.wsdl"; Assert.assertEquals("example.wsdl", reader.createRelativePath(base1, wsdl)); Assert.assertEquals("wsdl/one/example.wsdl", reader.createRelativePath(base2, wsdl)); Assert.assertEquals("wsdl/one/two/example.wsdl", reader.createRelativePath(base3, wsdl)); }
|
### Question:
WSDLReader { public HashSet<ServiceOperation> readWSDL(final String wsdlURI, final String portName) throws WSDLReaderException { Element defEl = readWSDL(wsdlURI); Map<String, String> namespaces = parseNamespaces(defEl); Element portType = getPortType(defEl, portName, namespaces); if (portType == null) { throw WSDLExtensionsMessages.MESSAGES.unableFindPort(portName); } String style = getStyle(defEl, portType, namespaces); _documentStyle = style.equals(DOCUMENT) ? true : false; Map<QName, QName> parts = getParts(defEl, portType, namespaces); HashSet<ServiceOperation> ops = new HashSet<ServiceOperation>(); List<Element> operations = getOperations(portType); int size = operations.size(); for (int i = 0; i < size; i++) { ops.add(createServiceOperation(operations.get(i), parts, namespaces)); } return ops; } HashSet<ServiceOperation> readWSDL(final String wsdlURI, final String portName); Element readWSDL(final String wsdlURI); }### Answer:
@Test public void importedWSDLs() throws Exception { Assert.assertNotNull(reader.readWSDL(ORDER_WSDL)); Set<ServiceOperation> ops = reader.readWSDL(ORDER_WSDL, "OrderService"); Assert.assertEquals(1, ops.size()); }
|
### Question:
InputSourceTransforms { @Transformer public Reader toReader(InputSource inSource) { Reader reader = inSource.getCharacterStream(); if (reader != null) { return new StringReader(ReaderTransforms.TRANSFORMER.toString(reader)); } return null; } @Transformer String toString(InputSource inSource); @Transformer Reader toReader(InputSource inSource); @Transformer InputStream toInputStream(InputSource inSource); @Transformer Integer toInteger(InputSource inSource); @Transformer Long toLong(InputSource inSource); @Transformer Short toShort(InputSource inSource); @Transformer char[] toChars(InputSource inSource); @Transformer Character toCharacter(InputSource inSource); @Transformer byte[] toBytes(InputSource inSource); @Transformer Double toDouble(InputSource inSource); @Transformer Float toFloat(InputSource inSource); static final InputSourceTransforms TRANSFORMER; }### Answer:
@Test public void testToReader() throws Exception { Assert.assertNotNull(InputSourceTransforms.TRANSFORMER.toReader(newInputSource("Hello SwitchYard"))); }
|
### Question:
InputSourceTransforms { @Transformer public InputStream toInputStream(InputSource inSource) { InputStream stream = inSource.getByteStream(); if (stream != null) { return new ByteArrayInputStream(InputStreamTransforms.TRANSFORMER.toBytes(stream)); } return null; } @Transformer String toString(InputSource inSource); @Transformer Reader toReader(InputSource inSource); @Transformer InputStream toInputStream(InputSource inSource); @Transformer Integer toInteger(InputSource inSource); @Transformer Long toLong(InputSource inSource); @Transformer Short toShort(InputSource inSource); @Transformer char[] toChars(InputSource inSource); @Transformer Character toCharacter(InputSource inSource); @Transformer byte[] toBytes(InputSource inSource); @Transformer Double toDouble(InputSource inSource); @Transformer Float toFloat(InputSource inSource); static final InputSourceTransforms TRANSFORMER; }### Answer:
@Test public void testToInputStream() throws Exception { Assert.assertNotNull(InputSourceTransforms.TRANSFORMER.toInputStream(newInputSource("Hello SwitchYard"))); }
|
### Question:
InputSourceTransforms { @Transformer public Integer toInteger(InputSource inSource) { return Integer.parseInt(toString(inSource)); } @Transformer String toString(InputSource inSource); @Transformer Reader toReader(InputSource inSource); @Transformer InputStream toInputStream(InputSource inSource); @Transformer Integer toInteger(InputSource inSource); @Transformer Long toLong(InputSource inSource); @Transformer Short toShort(InputSource inSource); @Transformer char[] toChars(InputSource inSource); @Transformer Character toCharacter(InputSource inSource); @Transformer byte[] toBytes(InputSource inSource); @Transformer Double toDouble(InputSource inSource); @Transformer Float toFloat(InputSource inSource); static final InputSourceTransforms TRANSFORMER; }### Answer:
@Test public void testToInteger() throws Exception { Assert.assertEquals((Integer)1, InputSourceTransforms.TRANSFORMER.toInteger(newInputSource("1"))); }
|
### Question:
InputSourceTransforms { @Transformer public Long toLong(InputSource inSource) { return Long.parseLong(toString(inSource)); } @Transformer String toString(InputSource inSource); @Transformer Reader toReader(InputSource inSource); @Transformer InputStream toInputStream(InputSource inSource); @Transformer Integer toInteger(InputSource inSource); @Transformer Long toLong(InputSource inSource); @Transformer Short toShort(InputSource inSource); @Transformer char[] toChars(InputSource inSource); @Transformer Character toCharacter(InputSource inSource); @Transformer byte[] toBytes(InputSource inSource); @Transformer Double toDouble(InputSource inSource); @Transformer Float toFloat(InputSource inSource); static final InputSourceTransforms TRANSFORMER; }### Answer:
@Test public void testToLong() throws Exception { Assert.assertEquals((Long)1L, InputSourceTransforms.TRANSFORMER.toLong(newInputSource("1"))); }
|
### Question:
InputSourceTransforms { @Transformer public Short toShort(InputSource inSource) { return Short.parseShort(toString(inSource)); } @Transformer String toString(InputSource inSource); @Transformer Reader toReader(InputSource inSource); @Transformer InputStream toInputStream(InputSource inSource); @Transformer Integer toInteger(InputSource inSource); @Transformer Long toLong(InputSource inSource); @Transformer Short toShort(InputSource inSource); @Transformer char[] toChars(InputSource inSource); @Transformer Character toCharacter(InputSource inSource); @Transformer byte[] toBytes(InputSource inSource); @Transformer Double toDouble(InputSource inSource); @Transformer Float toFloat(InputSource inSource); static final InputSourceTransforms TRANSFORMER; }### Answer:
@Test public void testToShort() throws Exception { Assert.assertEquals(new Short("1"), InputSourceTransforms.TRANSFORMER.toShort(newInputSource("1"))); }
|
### Question:
CamelExchangeBus implements ExchangeBus { @Override public Dispatcher getDispatcher(ServiceReference reference) { return _dispatchers.get(reference.getName()); } CamelExchangeBus(SwitchYardCamelContext context); @Override void init(ServiceDomain domain); @Override synchronized void start(); @Override synchronized void stop(); @Override Dispatcher getDispatcher(ServiceReference reference); @Override ExchangeDispatcher createDispatcher(final ServiceReference reference); }### Answer:
@Test public void testGetDispatcher() throws Exception { ServiceReference ref = new ServiceReferenceImpl( new QName("testGetDispatcher"), new InOnlyService(), null, null); Dispatcher dispatch = _provider.createDispatcher(ref); assertEquals(dispatch, _provider.getDispatcher(ref)); }
|
### Question:
InputSourceTransforms { @Transformer public char[] toChars(InputSource inSource) { return toString(inSource).toCharArray(); } @Transformer String toString(InputSource inSource); @Transformer Reader toReader(InputSource inSource); @Transformer InputStream toInputStream(InputSource inSource); @Transformer Integer toInteger(InputSource inSource); @Transformer Long toLong(InputSource inSource); @Transformer Short toShort(InputSource inSource); @Transformer char[] toChars(InputSource inSource); @Transformer Character toCharacter(InputSource inSource); @Transformer byte[] toBytes(InputSource inSource); @Transformer Double toDouble(InputSource inSource); @Transformer Float toFloat(InputSource inSource); static final InputSourceTransforms TRANSFORMER; }### Answer:
@Test public void testToChars() throws Exception { Assert.assertEquals("12345", new String(InputSourceTransforms.TRANSFORMER.toChars(newInputSource("12345")))); }
|
### Question:
InputSourceTransforms { @Transformer public Character toCharacter(InputSource inSource) { return toString(inSource).charAt(0); } @Transformer String toString(InputSource inSource); @Transformer Reader toReader(InputSource inSource); @Transformer InputStream toInputStream(InputSource inSource); @Transformer Integer toInteger(InputSource inSource); @Transformer Long toLong(InputSource inSource); @Transformer Short toShort(InputSource inSource); @Transformer char[] toChars(InputSource inSource); @Transformer Character toCharacter(InputSource inSource); @Transformer byte[] toBytes(InputSource inSource); @Transformer Double toDouble(InputSource inSource); @Transformer Float toFloat(InputSource inSource); static final InputSourceTransforms TRANSFORMER; }### Answer:
@Test public void testToCharacter() throws Exception { Assert.assertEquals((Character) '1', InputSourceTransforms.TRANSFORMER.toCharacter(newInputSource("12345"))); }
|
### Question:
InputSourceTransforms { @Transformer public byte[] toBytes(InputSource inSource) { InputStream stream = inSource.getByteStream(); if (stream != null) { return InputStreamTransforms.TRANSFORMER.toBytes(stream); } Reader reader = inSource.getCharacterStream(); if (reader != null) { return ReaderTransforms.TRANSFORMER.toBytes(reader); } return null; } @Transformer String toString(InputSource inSource); @Transformer Reader toReader(InputSource inSource); @Transformer InputStream toInputStream(InputSource inSource); @Transformer Integer toInteger(InputSource inSource); @Transformer Long toLong(InputSource inSource); @Transformer Short toShort(InputSource inSource); @Transformer char[] toChars(InputSource inSource); @Transformer Character toCharacter(InputSource inSource); @Transformer byte[] toBytes(InputSource inSource); @Transformer Double toDouble(InputSource inSource); @Transformer Float toFloat(InputSource inSource); static final InputSourceTransforms TRANSFORMER; }### Answer:
@Test public void testToBytes() throws Exception { Assert.assertNotNull(new String(InputSourceTransforms.TRANSFORMER.toBytes(newInputSource("12345")))); }
|
### Question:
InputSourceTransforms { @Transformer public Double toDouble(InputSource inSource) { return Double.parseDouble(toString(inSource)); } @Transformer String toString(InputSource inSource); @Transformer Reader toReader(InputSource inSource); @Transformer InputStream toInputStream(InputSource inSource); @Transformer Integer toInteger(InputSource inSource); @Transformer Long toLong(InputSource inSource); @Transformer Short toShort(InputSource inSource); @Transformer char[] toChars(InputSource inSource); @Transformer Character toCharacter(InputSource inSource); @Transformer byte[] toBytes(InputSource inSource); @Transformer Double toDouble(InputSource inSource); @Transformer Float toFloat(InputSource inSource); static final InputSourceTransforms TRANSFORMER; }### Answer:
@Test public void testToDouble() throws Exception { Assert.assertEquals((Double)1D, InputSourceTransforms.TRANSFORMER.toDouble(newInputSource("1"))); }
|
### Question:
InputSourceTransforms { @Transformer public Float toFloat(InputSource inSource) { return Float.parseFloat(toString(inSource)); } @Transformer String toString(InputSource inSource); @Transformer Reader toReader(InputSource inSource); @Transformer InputStream toInputStream(InputSource inSource); @Transformer Integer toInteger(InputSource inSource); @Transformer Long toLong(InputSource inSource); @Transformer Short toShort(InputSource inSource); @Transformer char[] toChars(InputSource inSource); @Transformer Character toCharacter(InputSource inSource); @Transformer byte[] toBytes(InputSource inSource); @Transformer Double toDouble(InputSource inSource); @Transformer Float toFloat(InputSource inSource); static final InputSourceTransforms TRANSFORMER; }### Answer:
@Test public void testToFloat() throws Exception { Assert.assertEquals((Float)1F, InputSourceTransforms.TRANSFORMER.toFloat(newInputSource("1"))); }
|
### Question:
InputStreamTransforms { @Transformer public String toString(InputStream inStream) { return ReaderTransforms.TRANSFORMER.toString(new InputStreamReader(inStream)); } @Transformer String toString(InputStream inStream); @Transformer Reader toReader(InputStream inStream); @Transformer InputSource toInputSource(InputStream inStream); @Transformer Integer toInteger(InputStream inStream); @Transformer Long toLong(InputStream inStream); @Transformer Short toShort(InputStream inStream); @Transformer char[] toChars(InputStream inStream); @Transformer Character toCharacter(InputStream inStream); @Transformer byte[] toBytes(InputStream inStream); @Transformer Double toDouble(InputStream inStream); @Transformer Float toFloat(InputStream inStream); static final InputStreamTransforms TRANSFORMER; }### Answer:
@Test public void testToString() throws Exception { Assert.assertEquals("Hello SwitchYard", InputStreamTransforms.TRANSFORMER.toString(newInputStream("Hello SwitchYard"))); }
|
### Question:
InputStreamTransforms { @Transformer public Reader toReader(InputStream inStream) { return new StringReader(toString(inStream)); } @Transformer String toString(InputStream inStream); @Transformer Reader toReader(InputStream inStream); @Transformer InputSource toInputSource(InputStream inStream); @Transformer Integer toInteger(InputStream inStream); @Transformer Long toLong(InputStream inStream); @Transformer Short toShort(InputStream inStream); @Transformer char[] toChars(InputStream inStream); @Transformer Character toCharacter(InputStream inStream); @Transformer byte[] toBytes(InputStream inStream); @Transformer Double toDouble(InputStream inStream); @Transformer Float toFloat(InputStream inStream); static final InputStreamTransforms TRANSFORMER; }### Answer:
@Test public void testToReader() throws Exception { Assert.assertNotNull(InputStreamTransforms.TRANSFORMER.toReader(newInputStream("Hello SwitchYard"))); }
|
### Question:
InputStreamTransforms { @Transformer public InputSource toInputSource(InputStream inStream) { byte[] bytes = toBytes(inStream); InputSource inputSource = new InputSource(); inputSource.setByteStream(new ByteArrayInputStream(bytes)); return inputSource; } @Transformer String toString(InputStream inStream); @Transformer Reader toReader(InputStream inStream); @Transformer InputSource toInputSource(InputStream inStream); @Transformer Integer toInteger(InputStream inStream); @Transformer Long toLong(InputStream inStream); @Transformer Short toShort(InputStream inStream); @Transformer char[] toChars(InputStream inStream); @Transformer Character toCharacter(InputStream inStream); @Transformer byte[] toBytes(InputStream inStream); @Transformer Double toDouble(InputStream inStream); @Transformer Float toFloat(InputStream inStream); static final InputStreamTransforms TRANSFORMER; }### Answer:
@Test public void testToInputSource() throws Exception { Assert.assertNotNull(InputStreamTransforms.TRANSFORMER.toInputSource(newInputStream("Hello SwitchYard"))); }
|
### Question:
InputStreamTransforms { @Transformer public Integer toInteger(InputStream inStream) { return Integer.parseInt(toString(inStream)); } @Transformer String toString(InputStream inStream); @Transformer Reader toReader(InputStream inStream); @Transformer InputSource toInputSource(InputStream inStream); @Transformer Integer toInteger(InputStream inStream); @Transformer Long toLong(InputStream inStream); @Transformer Short toShort(InputStream inStream); @Transformer char[] toChars(InputStream inStream); @Transformer Character toCharacter(InputStream inStream); @Transformer byte[] toBytes(InputStream inStream); @Transformer Double toDouble(InputStream inStream); @Transformer Float toFloat(InputStream inStream); static final InputStreamTransforms TRANSFORMER; }### Answer:
@Test public void testToInteger() throws Exception { Assert.assertEquals((Integer)1, InputStreamTransforms.TRANSFORMER.toInteger(newInputStream("1"))); }
|
### Question:
InputStreamTransforms { @Transformer public Long toLong(InputStream inStream) { return Long.parseLong(toString(inStream)); } @Transformer String toString(InputStream inStream); @Transformer Reader toReader(InputStream inStream); @Transformer InputSource toInputSource(InputStream inStream); @Transformer Integer toInteger(InputStream inStream); @Transformer Long toLong(InputStream inStream); @Transformer Short toShort(InputStream inStream); @Transformer char[] toChars(InputStream inStream); @Transformer Character toCharacter(InputStream inStream); @Transformer byte[] toBytes(InputStream inStream); @Transformer Double toDouble(InputStream inStream); @Transformer Float toFloat(InputStream inStream); static final InputStreamTransforms TRANSFORMER; }### Answer:
@Test public void testToLong() throws Exception { Assert.assertEquals((Long)1L, InputStreamTransforms.TRANSFORMER.toLong(newInputStream("1"))); }
|
### Question:
InputStreamTransforms { @Transformer public Short toShort(InputStream inStream) { return Short.parseShort(toString(inStream)); } @Transformer String toString(InputStream inStream); @Transformer Reader toReader(InputStream inStream); @Transformer InputSource toInputSource(InputStream inStream); @Transformer Integer toInteger(InputStream inStream); @Transformer Long toLong(InputStream inStream); @Transformer Short toShort(InputStream inStream); @Transformer char[] toChars(InputStream inStream); @Transformer Character toCharacter(InputStream inStream); @Transformer byte[] toBytes(InputStream inStream); @Transformer Double toDouble(InputStream inStream); @Transformer Float toFloat(InputStream inStream); static final InputStreamTransforms TRANSFORMER; }### Answer:
@Test public void testToShort() throws Exception { Assert.assertEquals(new Short("1"), InputStreamTransforms.TRANSFORMER.toShort(newInputStream("1"))); }
|
### Question:
InputStreamTransforms { @Transformer public char[] toChars(InputStream inStream) { return toString(inStream).toCharArray(); } @Transformer String toString(InputStream inStream); @Transformer Reader toReader(InputStream inStream); @Transformer InputSource toInputSource(InputStream inStream); @Transformer Integer toInteger(InputStream inStream); @Transformer Long toLong(InputStream inStream); @Transformer Short toShort(InputStream inStream); @Transformer char[] toChars(InputStream inStream); @Transformer Character toCharacter(InputStream inStream); @Transformer byte[] toBytes(InputStream inStream); @Transformer Double toDouble(InputStream inStream); @Transformer Float toFloat(InputStream inStream); static final InputStreamTransforms TRANSFORMER; }### Answer:
@Test public void testToChars() throws Exception { Assert.assertEquals("12345", new String(InputStreamTransforms.TRANSFORMER.toChars(newInputStream("12345")))); }
|
### Question:
InputStreamTransforms { @Transformer public Character toCharacter(InputStream inStream) { return toString(inStream).charAt(0); } @Transformer String toString(InputStream inStream); @Transformer Reader toReader(InputStream inStream); @Transformer InputSource toInputSource(InputStream inStream); @Transformer Integer toInteger(InputStream inStream); @Transformer Long toLong(InputStream inStream); @Transformer Short toShort(InputStream inStream); @Transformer char[] toChars(InputStream inStream); @Transformer Character toCharacter(InputStream inStream); @Transformer byte[] toBytes(InputStream inStream); @Transformer Double toDouble(InputStream inStream); @Transformer Float toFloat(InputStream inStream); static final InputStreamTransforms TRANSFORMER; }### Answer:
@Test public void testToCharacter() throws Exception { Assert.assertEquals((Character) '1', InputStreamTransforms.TRANSFORMER.toCharacter(newInputStream("12345"))); }
|
### Question:
InputStreamTransforms { @Transformer public byte[] toBytes(InputStream inStream) { ByteArrayOutputStream byteBuffer = new ByteArrayOutputStream(); try { byte[] readBuffer = new byte[56]; int readCount; while ((readCount = inStream.read(readBuffer)) != -1) { byteBuffer.write(readBuffer, 0, readCount); } } catch (IOException e) { LOGGER.debug("Error reading from InputStream.", e); } finally { try { inStream.close(); } catch (IOException e) { LOGGER.debug("Failed to close InputStream instance.", e); } } return byteBuffer.toByteArray(); } @Transformer String toString(InputStream inStream); @Transformer Reader toReader(InputStream inStream); @Transformer InputSource toInputSource(InputStream inStream); @Transformer Integer toInteger(InputStream inStream); @Transformer Long toLong(InputStream inStream); @Transformer Short toShort(InputStream inStream); @Transformer char[] toChars(InputStream inStream); @Transformer Character toCharacter(InputStream inStream); @Transformer byte[] toBytes(InputStream inStream); @Transformer Double toDouble(InputStream inStream); @Transformer Float toFloat(InputStream inStream); static final InputStreamTransforms TRANSFORMER; }### Answer:
@Test public void testToBytes() throws Exception { Assert.assertNotNull(new String(InputStreamTransforms.TRANSFORMER.toBytes(newInputStream("12345")))); }
|
### Question:
InputStreamTransforms { @Transformer public Double toDouble(InputStream inStream) { return Double.parseDouble(toString(inStream)); } @Transformer String toString(InputStream inStream); @Transformer Reader toReader(InputStream inStream); @Transformer InputSource toInputSource(InputStream inStream); @Transformer Integer toInteger(InputStream inStream); @Transformer Long toLong(InputStream inStream); @Transformer Short toShort(InputStream inStream); @Transformer char[] toChars(InputStream inStream); @Transformer Character toCharacter(InputStream inStream); @Transformer byte[] toBytes(InputStream inStream); @Transformer Double toDouble(InputStream inStream); @Transformer Float toFloat(InputStream inStream); static final InputStreamTransforms TRANSFORMER; }### Answer:
@Test public void testToDouble() throws Exception { Assert.assertEquals((Double)1D, InputStreamTransforms.TRANSFORMER.toDouble(newInputStream("1"))); }
|
### Question:
InputStreamTransforms { @Transformer public Float toFloat(InputStream inStream) { return Float.parseFloat(toString(inStream)); } @Transformer String toString(InputStream inStream); @Transformer Reader toReader(InputStream inStream); @Transformer InputSource toInputSource(InputStream inStream); @Transformer Integer toInteger(InputStream inStream); @Transformer Long toLong(InputStream inStream); @Transformer Short toShort(InputStream inStream); @Transformer char[] toChars(InputStream inStream); @Transformer Character toCharacter(InputStream inStream); @Transformer byte[] toBytes(InputStream inStream); @Transformer Double toDouble(InputStream inStream); @Transformer Float toFloat(InputStream inStream); static final InputStreamTransforms TRANSFORMER; }### Answer:
@Test public void testToFloat() throws Exception { Assert.assertEquals((Float)1F, InputStreamTransforms.TRANSFORMER.toFloat(newInputStream("1"))); }
|
### Question:
ReaderTransforms { @Transformer public String toString(Reader reader) { StringBuilder builder = new StringBuilder(); try { char[] readBuffer = new char[56]; int readCount; while ((readCount = reader.read(readBuffer)) != -1) { builder.append(readBuffer, 0, readCount); } } catch (IOException e) { LOGGER.debug("Error reading from reader.", e); } finally { try { reader.close(); } catch (IOException e) { LOGGER.debug("Failed to close reader instance.", e); } } return builder.toString(); } @Transformer String toString(Reader reader); @Transformer InputStream toInputStream(Reader reader); @Transformer InputSource toInputSource(Reader reader); @Transformer Integer toInteger(Reader reader); @Transformer Long toLong(Reader reader); @Transformer Short toShort(Reader reader); @Transformer char[] toChars(Reader reader); @Transformer Character toCharacter(Reader reader); @Transformer byte[] toBytes(Reader reader); @Transformer Double toDouble(Reader reader); @Transformer Float toFloat(Reader reader); static final ReaderTransforms TRANSFORMER; }### Answer:
@Test public void testToString() throws Exception { Assert.assertEquals("Hello SwitchYard", ReaderTransforms.TRANSFORMER.toString(newReader("Hello SwitchYard"))); }
|
### Question:
ReaderTransforms { @Transformer public InputStream toInputStream(Reader reader) { return new ByteArrayInputStream(toString(reader).getBytes()); } @Transformer String toString(Reader reader); @Transformer InputStream toInputStream(Reader reader); @Transformer InputSource toInputSource(Reader reader); @Transformer Integer toInteger(Reader reader); @Transformer Long toLong(Reader reader); @Transformer Short toShort(Reader reader); @Transformer char[] toChars(Reader reader); @Transformer Character toCharacter(Reader reader); @Transformer byte[] toBytes(Reader reader); @Transformer Double toDouble(Reader reader); @Transformer Float toFloat(Reader reader); static final ReaderTransforms TRANSFORMER; }### Answer:
@Test public void testToInputStream() throws Exception { Assert.assertNotNull(ReaderTransforms.TRANSFORMER.toInputStream(newReader("Hello SwitchYard"))); }
|
### Question:
ReaderTransforms { @Transformer public InputSource toInputSource(Reader reader) { String string = toString(reader); InputSource inputSource = new InputSource(); inputSource.setByteStream(new ByteArrayInputStream(string.getBytes())); inputSource.setCharacterStream(new StringReader(string)); return inputSource; } @Transformer String toString(Reader reader); @Transformer InputStream toInputStream(Reader reader); @Transformer InputSource toInputSource(Reader reader); @Transformer Integer toInteger(Reader reader); @Transformer Long toLong(Reader reader); @Transformer Short toShort(Reader reader); @Transformer char[] toChars(Reader reader); @Transformer Character toCharacter(Reader reader); @Transformer byte[] toBytes(Reader reader); @Transformer Double toDouble(Reader reader); @Transformer Float toFloat(Reader reader); static final ReaderTransforms TRANSFORMER; }### Answer:
@Test public void testToInputSource() throws Exception { Assert.assertNotNull(ReaderTransforms.TRANSFORMER.toInputSource(newReader("Hello SwitchYard"))); }
|
### Question:
ReaderTransforms { @Transformer public Integer toInteger(Reader reader) { return Integer.parseInt(toString(reader)); } @Transformer String toString(Reader reader); @Transformer InputStream toInputStream(Reader reader); @Transformer InputSource toInputSource(Reader reader); @Transformer Integer toInteger(Reader reader); @Transformer Long toLong(Reader reader); @Transformer Short toShort(Reader reader); @Transformer char[] toChars(Reader reader); @Transformer Character toCharacter(Reader reader); @Transformer byte[] toBytes(Reader reader); @Transformer Double toDouble(Reader reader); @Transformer Float toFloat(Reader reader); static final ReaderTransforms TRANSFORMER; }### Answer:
@Test public void testToInteger() throws Exception { Assert.assertEquals((Integer)1, ReaderTransforms.TRANSFORMER.toInteger(newReader("1"))); }
|
### Question:
ReaderTransforms { @Transformer public Long toLong(Reader reader) { return Long.parseLong(toString(reader)); } @Transformer String toString(Reader reader); @Transformer InputStream toInputStream(Reader reader); @Transformer InputSource toInputSource(Reader reader); @Transformer Integer toInteger(Reader reader); @Transformer Long toLong(Reader reader); @Transformer Short toShort(Reader reader); @Transformer char[] toChars(Reader reader); @Transformer Character toCharacter(Reader reader); @Transformer byte[] toBytes(Reader reader); @Transformer Double toDouble(Reader reader); @Transformer Float toFloat(Reader reader); static final ReaderTransforms TRANSFORMER; }### Answer:
@Test public void testToLong() throws Exception { Assert.assertEquals((Long)1L, ReaderTransforms.TRANSFORMER.toLong(newReader("1"))); }
|
### Question:
ReaderTransforms { @Transformer public Short toShort(Reader reader) { return Short.parseShort(toString(reader)); } @Transformer String toString(Reader reader); @Transformer InputStream toInputStream(Reader reader); @Transformer InputSource toInputSource(Reader reader); @Transformer Integer toInteger(Reader reader); @Transformer Long toLong(Reader reader); @Transformer Short toShort(Reader reader); @Transformer char[] toChars(Reader reader); @Transformer Character toCharacter(Reader reader); @Transformer byte[] toBytes(Reader reader); @Transformer Double toDouble(Reader reader); @Transformer Float toFloat(Reader reader); static final ReaderTransforms TRANSFORMER; }### Answer:
@Test public void testToShort() throws Exception { Assert.assertEquals(new Short("1"), ReaderTransforms.TRANSFORMER.toShort(newReader("1"))); }
|
### Question:
ReaderTransforms { @Transformer public char[] toChars(Reader reader) { return toString(reader).toCharArray(); } @Transformer String toString(Reader reader); @Transformer InputStream toInputStream(Reader reader); @Transformer InputSource toInputSource(Reader reader); @Transformer Integer toInteger(Reader reader); @Transformer Long toLong(Reader reader); @Transformer Short toShort(Reader reader); @Transformer char[] toChars(Reader reader); @Transformer Character toCharacter(Reader reader); @Transformer byte[] toBytes(Reader reader); @Transformer Double toDouble(Reader reader); @Transformer Float toFloat(Reader reader); static final ReaderTransforms TRANSFORMER; }### Answer:
@Test public void testToChars() throws Exception { Assert.assertEquals("12345", new String(ReaderTransforms.TRANSFORMER.toChars(newReader("12345")))); }
|
### Question:
ReaderTransforms { @Transformer public Character toCharacter(Reader reader) { return toString(reader).charAt(0); } @Transformer String toString(Reader reader); @Transformer InputStream toInputStream(Reader reader); @Transformer InputSource toInputSource(Reader reader); @Transformer Integer toInteger(Reader reader); @Transformer Long toLong(Reader reader); @Transformer Short toShort(Reader reader); @Transformer char[] toChars(Reader reader); @Transformer Character toCharacter(Reader reader); @Transformer byte[] toBytes(Reader reader); @Transformer Double toDouble(Reader reader); @Transformer Float toFloat(Reader reader); static final ReaderTransforms TRANSFORMER; }### Answer:
@Test public void testToCharacter() throws Exception { Assert.assertEquals((Character) '1', ReaderTransforms.TRANSFORMER.toCharacter(newReader("12345"))); }
|
### Question:
ReaderTransforms { @Transformer public byte[] toBytes(Reader reader) { return toString(reader).getBytes(); } @Transformer String toString(Reader reader); @Transformer InputStream toInputStream(Reader reader); @Transformer InputSource toInputSource(Reader reader); @Transformer Integer toInteger(Reader reader); @Transformer Long toLong(Reader reader); @Transformer Short toShort(Reader reader); @Transformer char[] toChars(Reader reader); @Transformer Character toCharacter(Reader reader); @Transformer byte[] toBytes(Reader reader); @Transformer Double toDouble(Reader reader); @Transformer Float toFloat(Reader reader); static final ReaderTransforms TRANSFORMER; }### Answer:
@Test public void testToBytes() throws Exception { Assert.assertNotNull(new String(ReaderTransforms.TRANSFORMER.toBytes(newReader("12345")))); }
|
### Question:
ReaderTransforms { @Transformer public Double toDouble(Reader reader) { return Double.parseDouble(toString(reader)); } @Transformer String toString(Reader reader); @Transformer InputStream toInputStream(Reader reader); @Transformer InputSource toInputSource(Reader reader); @Transformer Integer toInteger(Reader reader); @Transformer Long toLong(Reader reader); @Transformer Short toShort(Reader reader); @Transformer char[] toChars(Reader reader); @Transformer Character toCharacter(Reader reader); @Transformer byte[] toBytes(Reader reader); @Transformer Double toDouble(Reader reader); @Transformer Float toFloat(Reader reader); static final ReaderTransforms TRANSFORMER; }### Answer:
@Test public void testToDouble() throws Exception { Assert.assertEquals((Double)1D, ReaderTransforms.TRANSFORMER.toDouble(newReader("1"))); }
|
### Question:
ReaderTransforms { @Transformer public Float toFloat(Reader reader) { return Float.parseFloat(toString(reader)); } @Transformer String toString(Reader reader); @Transformer InputStream toInputStream(Reader reader); @Transformer InputSource toInputSource(Reader reader); @Transformer Integer toInteger(Reader reader); @Transformer Long toLong(Reader reader); @Transformer Short toShort(Reader reader); @Transformer char[] toChars(Reader reader); @Transformer Character toCharacter(Reader reader); @Transformer byte[] toBytes(Reader reader); @Transformer Double toDouble(Reader reader); @Transformer Float toFloat(Reader reader); static final ReaderTransforms TRANSFORMER; }### Answer:
@Test public void testToFloat() throws Exception { Assert.assertEquals((Float)1F, ReaderTransforms.TRANSFORMER.toFloat(newReader("1"))); }
|
### Question:
StringTransforms { @Transformer public Reader toReader(String string) { return new StringReader(string); } @Transformer Reader toReader(String string); @Transformer InputStream toInputStream(String string); @Transformer InputSource toInputSource(String string); @Transformer Integer toInteger(String string); @Transformer Long toLong(String string); @Transformer Short toShort(String string); @Transformer char[] toChars(String string); @Transformer Character toCharacter(String string); @Transformer byte[] toBytes(String string); @Transformer Double toDouble(String string); @Transformer Float toFloat(String string); static final StringTransforms TRANSFORMER; }### Answer:
@Test public void testToReader() throws Exception { Assert.assertNotNull(StringTransforms.TRANSFORMER.toReader("reader")); }
|
### Question:
StringTransforms { @Transformer public InputStream toInputStream(String string) { return new ByteArrayInputStream(string.getBytes()); } @Transformer Reader toReader(String string); @Transformer InputStream toInputStream(String string); @Transformer InputSource toInputSource(String string); @Transformer Integer toInteger(String string); @Transformer Long toLong(String string); @Transformer Short toShort(String string); @Transformer char[] toChars(String string); @Transformer Character toCharacter(String string); @Transformer byte[] toBytes(String string); @Transformer Double toDouble(String string); @Transformer Float toFloat(String string); static final StringTransforms TRANSFORMER; }### Answer:
@Test public void testToInputStream() throws Exception { Assert.assertNotNull(StringTransforms.TRANSFORMER.toInputStream("stream")); }
|
### Question:
StringTransforms { @Transformer public InputSource toInputSource(String string) { InputSource inputSource = new InputSource(); inputSource.setByteStream(new ByteArrayInputStream(string.getBytes())); inputSource.setCharacterStream(new StringReader(string)); return inputSource; } @Transformer Reader toReader(String string); @Transformer InputStream toInputStream(String string); @Transformer InputSource toInputSource(String string); @Transformer Integer toInteger(String string); @Transformer Long toLong(String string); @Transformer Short toShort(String string); @Transformer char[] toChars(String string); @Transformer Character toCharacter(String string); @Transformer byte[] toBytes(String string); @Transformer Double toDouble(String string); @Transformer Float toFloat(String string); static final StringTransforms TRANSFORMER; }### Answer:
@Test public void testToInputSource() throws Exception { Assert.assertNotNull(StringTransforms.TRANSFORMER.toInputSource("source")); }
|
### Question:
StringTransforms { @Transformer public Integer toInteger(String string) { return Integer.parseInt(string); } @Transformer Reader toReader(String string); @Transformer InputStream toInputStream(String string); @Transformer InputSource toInputSource(String string); @Transformer Integer toInteger(String string); @Transformer Long toLong(String string); @Transformer Short toShort(String string); @Transformer char[] toChars(String string); @Transformer Character toCharacter(String string); @Transformer byte[] toBytes(String string); @Transformer Double toDouble(String string); @Transformer Float toFloat(String string); static final StringTransforms TRANSFORMER; }### Answer:
@Test public void testToInteger() throws Exception { Assert.assertEquals(new Integer(1), StringTransforms.TRANSFORMER.toInteger("1")); }
|
### Question:
StringTransforms { @Transformer public Long toLong(String string) { return Long.parseLong(string); } @Transformer Reader toReader(String string); @Transformer InputStream toInputStream(String string); @Transformer InputSource toInputSource(String string); @Transformer Integer toInteger(String string); @Transformer Long toLong(String string); @Transformer Short toShort(String string); @Transformer char[] toChars(String string); @Transformer Character toCharacter(String string); @Transformer byte[] toBytes(String string); @Transformer Double toDouble(String string); @Transformer Float toFloat(String string); static final StringTransforms TRANSFORMER; }### Answer:
@Test public void testToLong() throws Exception { Assert.assertEquals(new Long(1), StringTransforms.TRANSFORMER.toLong("1")); }
|
### Question:
StringTransforms { @Transformer public Short toShort(String string) { return Short.parseShort(string); } @Transformer Reader toReader(String string); @Transformer InputStream toInputStream(String string); @Transformer InputSource toInputSource(String string); @Transformer Integer toInteger(String string); @Transformer Long toLong(String string); @Transformer Short toShort(String string); @Transformer char[] toChars(String string); @Transformer Character toCharacter(String string); @Transformer byte[] toBytes(String string); @Transformer Double toDouble(String string); @Transformer Float toFloat(String string); static final StringTransforms TRANSFORMER; }### Answer:
@Test public void testToShort() throws Exception { Assert.assertNotNull(StringTransforms.TRANSFORMER.toShort("1")); }
|
### Question:
StringTransforms { @Transformer public char[] toChars(String string) { return string.toCharArray(); } @Transformer Reader toReader(String string); @Transformer InputStream toInputStream(String string); @Transformer InputSource toInputSource(String string); @Transformer Integer toInteger(String string); @Transformer Long toLong(String string); @Transformer Short toShort(String string); @Transformer char[] toChars(String string); @Transformer Character toCharacter(String string); @Transformer byte[] toBytes(String string); @Transformer Double toDouble(String string); @Transformer Float toFloat(String string); static final StringTransforms TRANSFORMER; }### Answer:
@Test public void testToChars() throws Exception { Assert.assertEquals("ccc", new String(StringTransforms.TRANSFORMER.toChars("ccc"))); }
|
### Question:
StringTransforms { @Transformer public Character toCharacter(String string) { if (string.length() > 0) { return string.charAt(0); } else { return null; } } @Transformer Reader toReader(String string); @Transformer InputStream toInputStream(String string); @Transformer InputSource toInputSource(String string); @Transformer Integer toInteger(String string); @Transformer Long toLong(String string); @Transformer Short toShort(String string); @Transformer char[] toChars(String string); @Transformer Character toCharacter(String string); @Transformer byte[] toBytes(String string); @Transformer Double toDouble(String string); @Transformer Float toFloat(String string); static final StringTransforms TRANSFORMER; }### Answer:
@Test public void testToCharacter() throws Exception { Assert.assertNotNull(StringTransforms.TRANSFORMER.toCharacter("c")); }
|
### Question:
StringTransforms { @Transformer public Double toDouble(String string) { return Double.parseDouble(string); } @Transformer Reader toReader(String string); @Transformer InputStream toInputStream(String string); @Transformer InputSource toInputSource(String string); @Transformer Integer toInteger(String string); @Transformer Long toLong(String string); @Transformer Short toShort(String string); @Transformer char[] toChars(String string); @Transformer Character toCharacter(String string); @Transformer byte[] toBytes(String string); @Transformer Double toDouble(String string); @Transformer Float toFloat(String string); static final StringTransforms TRANSFORMER; }### Answer:
@Test public void testToDouble() throws Exception { Assert.assertEquals(new Double(1), StringTransforms.TRANSFORMER.toDouble("1")); }
|
### Question:
StringTransforms { @Transformer public Float toFloat(String string) { return Float.parseFloat(string); } @Transformer Reader toReader(String string); @Transformer InputStream toInputStream(String string); @Transformer InputSource toInputSource(String string); @Transformer Integer toInteger(String string); @Transformer Long toLong(String string); @Transformer Short toShort(String string); @Transformer char[] toChars(String string); @Transformer Character toCharacter(String string); @Transformer byte[] toBytes(String string); @Transformer Double toDouble(String string); @Transformer Float toFloat(String string); static final StringTransforms TRANSFORMER; }### Answer:
@Test public void testToFloat() throws Exception { Assert.assertEquals(new Float(1), StringTransforms.TRANSFORMER.toFloat("1")); }
|
### Question:
NumberTransforms { @Transformer public String toString(Number number) { return number.toString(); } @Transformer String toString(Number number); @Transformer Reader toReader(Number number); @Transformer InputStream toInputStream(Number number); @Transformer InputSource toInputSource(Number number); @Transformer char[] toChars(Number number); @Transformer Character toCharacter(Number number); @Transformer byte[] toBytes(Number number); static final NumberTransforms TRANSFORMER; }### Answer:
@Test public void testToString() throws Exception { Assert.assertEquals("1", new NumberTransforms().toString(1)); Assert.assertEquals("1", new NumberTransforms().toString(1L)); Assert.assertEquals("1.0", new NumberTransforms().toString(1D)); }
|
### Question:
NumberTransforms { @Transformer public Reader toReader(Number number) { return new StringReader(number.toString()); } @Transformer String toString(Number number); @Transformer Reader toReader(Number number); @Transformer InputStream toInputStream(Number number); @Transformer InputSource toInputSource(Number number); @Transformer char[] toChars(Number number); @Transformer Character toCharacter(Number number); @Transformer byte[] toBytes(Number number); static final NumberTransforms TRANSFORMER; }### Answer:
@Test public void testToReader() throws Exception { Assert.assertNotNull(NumberTransforms.TRANSFORMER.toReader(1D)); }
|
### Question:
NumberTransforms { @Transformer public InputStream toInputStream(Number number) { return new ByteArrayInputStream(number.toString().getBytes()); } @Transformer String toString(Number number); @Transformer Reader toReader(Number number); @Transformer InputStream toInputStream(Number number); @Transformer InputSource toInputSource(Number number); @Transformer char[] toChars(Number number); @Transformer Character toCharacter(Number number); @Transformer byte[] toBytes(Number number); static final NumberTransforms TRANSFORMER; }### Answer:
@Test public void testToInputStream() throws Exception { Assert.assertNotNull(NumberTransforms.TRANSFORMER.toInputStream(1D)); }
|
### Question:
NumberTransforms { @Transformer public InputSource toInputSource(Number number) { String string = toString(number); InputSource inputSource = new InputSource(); inputSource.setByteStream(new ByteArrayInputStream(string.getBytes())); inputSource.setCharacterStream(new StringReader(string)); return inputSource; } @Transformer String toString(Number number); @Transformer Reader toReader(Number number); @Transformer InputStream toInputStream(Number number); @Transformer InputSource toInputSource(Number number); @Transformer char[] toChars(Number number); @Transformer Character toCharacter(Number number); @Transformer byte[] toBytes(Number number); static final NumberTransforms TRANSFORMER; }### Answer:
@Test public void testToInputSource() throws Exception { Assert.assertNotNull(NumberTransforms.TRANSFORMER.toInputSource(1D)); }
|
### Question:
NumberTransforms { @Transformer public char[] toChars(Number number) { return toString(number).toCharArray(); } @Transformer String toString(Number number); @Transformer Reader toReader(Number number); @Transformer InputStream toInputStream(Number number); @Transformer InputSource toInputSource(Number number); @Transformer char[] toChars(Number number); @Transformer Character toCharacter(Number number); @Transformer byte[] toBytes(Number number); static final NumberTransforms TRANSFORMER; }### Answer:
@Test public void testToChars() throws Exception { Assert.assertEquals("12345.0", new String(NumberTransforms.TRANSFORMER.toChars(12345D))); }
|
### Question:
NumberTransforms { @Transformer public Character toCharacter(Number number) { return toString(number).charAt(0); } @Transformer String toString(Number number); @Transformer Reader toReader(Number number); @Transformer InputStream toInputStream(Number number); @Transformer InputSource toInputSource(Number number); @Transformer char[] toChars(Number number); @Transformer Character toCharacter(Number number); @Transformer byte[] toBytes(Number number); static final NumberTransforms TRANSFORMER; }### Answer:
@Test public void testToCharacter() throws Exception { Assert.assertEquals((Character)'1', NumberTransforms.TRANSFORMER.toCharacter(12345D)); }
|
### Question:
NumberTransforms { @Transformer public byte[] toBytes(Number number) { return toString(number).getBytes(); } @Transformer String toString(Number number); @Transformer Reader toReader(Number number); @Transformer InputStream toInputStream(Number number); @Transformer InputSource toInputSource(Number number); @Transformer char[] toChars(Number number); @Transformer Character toCharacter(Number number); @Transformer byte[] toBytes(Number number); static final NumberTransforms TRANSFORMER; }### Answer:
@Test public void testToBytes() throws Exception { Assert.assertEquals("12345.0", new String(NumberTransforms.TRANSFORMER.toBytes(12345D))); }
|
### Question:
ByteArrayToStringTransformer extends BaseTransformer<byte[],String> { @Override public String transform(final byte[] from) { if (from == null) { return null; } return new String(from); } ByteArrayToStringTransformer(); @Override String transform(final byte[] from); }### Answer:
@Test public void transformNullByteArray() { final ByteArrayToStringTransformer transformer = new ByteArrayToStringTransformer(); final String transformed = transformer.transform(null); assertThat(transformed, is(nullValue())); }
@Test public void transformByteArray() { final ByteArrayToStringTransformer transformer = new ByteArrayToStringTransformer(); final String payload = "some message body"; final String transformed = transformer.transform(payload.getBytes()); assertThat(transformed, is(equalTo(payload))); }
|
### Question:
ExceptionTransforms { @Transformer public String toString(Throwable t) { Throwable cause = t; StringBuilder result = new StringBuilder(cause.getClass().getName() + ": " + cause.getMessage()); while ((cause = cause.getCause()) != null) { result.append(NL + " --- Caused by " + cause.getClass().getName() + ": " + cause.getMessage()); } return result.toString(); } @Transformer String toString(Throwable t); static final ExceptionTransforms TRANSFORMER; }### Answer:
@Test public void testToString() throws Exception { Assert.assertEquals( "java.lang.Exception: level-1" + NL + " --- Caused by java.lang.IllegalStateException: level-2" + NL + " --- Caused by java.lang.NullPointerException: level-3", new ExceptionTransforms().toString( new Exception("level-1", new IllegalStateException("level-2", new NullPointerException("level-3"))))); }
|
### Question:
TransactionHandler implements ExchangeHandler { private boolean noManagedRequired(Exchange exchange) { return PolicyUtil.isRequired(exchange, TransactionPolicy.NO_MANAGED_TRANSACTION); } TransactionHandler(); @Override void handleMessage(Exchange exchange); @Override void handleFault(Exchange exchange); }### Answer:
@Test public void noManagedRequired() throws Exception { PolicyUtil.require(exchange, TransactionPolicy.NO_MANAGED_TRANSACTION); exchange.setPhase(ExchangePhase.IN); tm.begin(); Transaction tx1 = tm.getTransaction(); handler.handleMessage(exchange); Transaction tx2 = tm.getTransaction(); Assert.assertNotNull(tx1); Assert.assertNull(tx2); Assert.assertEquals(Status.STATUS_ACTIVE, tx1.getStatus()); Assert.assertTrue(PolicyUtil.isProvided(exchange, TransactionPolicy.NO_MANAGED_TRANSACTION)); exchange.setPhase(ExchangePhase.OUT); handler.handleMessage(exchange); Transaction tx3 = tm.getTransaction(); Assert.assertEquals(tx1, tx3); Assert.assertEquals(Status.STATUS_ACTIVE, tx3.getStatus()); }
|
### Question:
TransactionHandler implements ExchangeHandler { private boolean suspendsRequired(Exchange exchange) { return PolicyUtil.isRequired(exchange, TransactionPolicy.SUSPENDS_TRANSACTION); } TransactionHandler(); @Override void handleMessage(Exchange exchange); @Override void handleFault(Exchange exchange); }### Answer:
@Test public void suspendsRequired() throws Exception { PolicyUtil.require(exchange, TransactionPolicy.SUSPENDS_TRANSACTION); exchange.setPhase(ExchangePhase.IN); tm.begin(); Transaction tx1 = tm.getTransaction(); handler.handleMessage(exchange); Assert.assertNull(tm.getTransaction()); Assert.assertTrue(PolicyUtil.isProvided(exchange, TransactionPolicy.SUSPENDS_TRANSACTION)); exchange.setPhase(ExchangePhase.OUT); handler.handleMessage(exchange); Transaction tx2 = tm.getTransaction(); Assert.assertEquals(tx1, tx2); Assert.assertEquals(Status.STATUS_ACTIVE, tx2.getStatus()); }
@Test public void suspendAndNoManagedRequired() throws Exception { PolicyUtil.require(exchange, TransactionPolicy.NO_MANAGED_TRANSACTION); suspendsRequired(); Assert.assertTrue(PolicyUtil.isProvided(exchange, TransactionPolicy.NO_MANAGED_TRANSACTION)); }
|
### Question:
PolicyHandler extends BaseHandler { @Override public void handleMessage(Exchange exchange) throws HandlerException { if (ExchangePhase.IN.equals(exchange.getPhase())) { Set<Policy> required = PolicyUtil.getRequired(exchange); Iterator<Policy> reqIt = required.iterator(); while (reqIt.hasNext()) { if (PolicyUtil.isProvided(exchange, reqIt.next())) { reqIt.remove(); } } if (!required.isEmpty()) { Iterator<Policy> missing = required.iterator(); StringBuilder requires = new StringBuilder(missing.next().getQName().toString()); while (missing.hasNext()) { requires.append(" " + missing.next().getQName().toString()); } throw RuntimeMessages.MESSAGES.requiredPolicesNeeded(requires.toString()); } } } PolicyHandler(); @Override void handleMessage(Exchange exchange); }### Answer:
@Test public void requiredButNotProvided() { PolicyUtil.require(exchange, new FooPolicy()); PolicyUtil.require(exchange, new BarPolicy()); PolicyUtil.provide(exchange, new BarPolicy()); exchange.setPhase(ExchangePhase.IN); try { handler.handleMessage(exchange); } catch (HandlerException handlerEx) { System.out.println(handlerEx.toString()); return; } Assert.fail("Expected a handler exception due to incompatible policy"); }
@Test public void providedButNotRequired() { PolicyUtil.provide(exchange, new FooPolicy()); exchange.setPhase(ExchangePhase.IN); try { handler.handleMessage(exchange); } catch (HandlerException handlerEx) { Assert.fail("Exception not expected when policy is provided but not required: " + handlerEx); } }
@Test public void requiredAndProvided() { PolicyUtil.require(exchange, new FooPolicy()); PolicyUtil.provide(exchange, new FooPolicy()); exchange.setPhase(ExchangePhase.IN); try { handler.handleMessage(exchange); } catch (HandlerException handlerEx) { Assert.fail("Exception not expected, required policy is provided: " + handlerEx); } }
|
### Question:
DefaultContext implements Context { @Override @SuppressWarnings("unchecked") public <T> T getPropertyValue(String name) { Property prop = _properties.get(name); if (prop != null) { return (T) prop.getValue(); } return null; } DefaultContext(Scope defaultScope, Map<String, Property> properties); DefaultContext(Scope defaultScope); DefaultContext(); @Override @SuppressWarnings("unchecked") T getPropertyValue(String name); @Override void removeProperties(); @Override Context setProperties(Set<Property> properties); @Override Set<Property> getProperties(); @Override void removeProperty(Property property); @Override Property getProperty(String name); @Override Property setProperty(String name, Object val); @Override void mergeInto(Context context); @Override Set<Property> getProperties(String label); @Override void removeProperties(String label); @Override Property getProperty(String name, Scope scope); @Override Set<Property> getProperties(Scope scope); @Override void removeProperties(Scope scope); @Override Property setProperty(String name, Object val, Scope scope); void setScope(Scope scope); @Override String toString(); }### Answer:
@Test public void testGetPropertyValue() { final String key = "prop"; final String value = "exchange"; _context.setProperty(key, value); Assert.assertEquals(value, _context.getPropertyValue(key)); }
|
### Question:
XsltTransformer extends BaseTransformer<Message, Message> { TransformerPool getTransformerPool() { return _transformerPool; } XsltTransformer(QName from, QName to, Templates templates, boolean failOnWarning, int maxPoolSize); @Override Message transform(Message message); }### Answer:
@Test public void testNoPool() throws Exception { XsltTransformer xslt = (XsltTransformer)getTransformer("xslt-config-07.xml"); Assert.assertNull(xslt.getTransformerPool()); }
|
### Question:
DefaultContext implements Context { @Override public Set<Property> getProperties() { return new HashSet<Property>(_properties.values()); } DefaultContext(Scope defaultScope, Map<String, Property> properties); DefaultContext(Scope defaultScope); DefaultContext(); @Override @SuppressWarnings("unchecked") T getPropertyValue(String name); @Override void removeProperties(); @Override Context setProperties(Set<Property> properties); @Override Set<Property> getProperties(); @Override void removeProperty(Property property); @Override Property getProperty(String name); @Override Property setProperty(String name, Object val); @Override void mergeInto(Context context); @Override Set<Property> getProperties(String label); @Override void removeProperties(String label); @Override Property getProperty(String name, Scope scope); @Override Set<Property> getProperties(Scope scope); @Override void removeProperties(Scope scope); @Override Property setProperty(String name, Object val, Scope scope); void setScope(Scope scope); @Override String toString(); }### Answer:
@Test public void testGetProperties() { _context.setProperty(PROP_NAME, PROP_VAL); Set<Property> props = _context.getProperties(); Assert.assertTrue(props.size() == 1); Assert.assertEquals(PROP_VAL, props.iterator().next().getValue()); props.remove(PROP_NAME); Assert.assertTrue(_context.getProperties().size() == 1); }
|
### Question:
DefaultServiceRegistry implements ServiceRegistry { @Override public synchronized List<Service> getServices() { List<Service> serviceList = new LinkedList<Service>(); for (List<Service> services : _services.values()) { serviceList.addAll(services); } return serviceList; } @Override synchronized List<Service> getServices(); @Override synchronized List<Service> getServices(QName serviceName); @Override synchronized Service registerService(Service service); @Override synchronized void unregisterService(Service service); @Override void registerServiceReference(ServiceReference reference); @Override void unregisterServiceReference(ServiceReference reference); @Override List<ServiceReference> getServiceReferences(); @Override ServiceReference getServiceReference(QName serviceName); }### Answer:
@Test public void shouldBePossibleToSearchForNonRegisteredService() { DefaultServiceRegistry registry = new DefaultServiceRegistry(); List<Service> services = registry.getServices(new QName("unRegisteredService")); Assert.assertThat(services.size(), is(0)); }
|
### Question:
DefaultMessage implements Message { @Override public DefaultMessage addAttachment(final String name, final DataSource attachment) { _attachments.put(name, attachment); return this; } DefaultMessage(); DefaultMessage setTransformerRegistry(TransformerRegistry transformerRegistry); @Override DefaultMessage addAttachment(final String name, final DataSource attachment); @Override DataSource getAttachment(final String name); @Override void removeAttachment(final String name); @Override Map<String, DataSource> getAttachmentMap(); @Override Object getContent(); @Override Context getContext(); @Override T getContent(final Class<T> type); @Override DefaultMessage setContent(final Object content); @Override Message copy(); boolean isSent(); void send(); }### Answer:
@Test public void testAddAttachment() throws Exception { _message.addAttachment("attach1", new DummyDS("attach1", "text/xml")); Assert.assertNotNull(_message.getAttachment("attach1")); }
|
### Question:
ConnoteService { public ConnoteDTO createConnote() { Long nextConnote; do { nextConnote = connoteGenerator.randomNumber(); } while (!isUnique(nextConnote)); Connote connoteSaved = createConnote(nextConnote); ConnoteDTO connoteDTO = new ConnoteDTO(); connoteDTO.setConnote(connoteSaved.getConnote()); return connoteDTO; } @Autowired ConnoteService(ConnoteRepository connoteRepository, RandomConnoteGenerator connoteGenerator); ConnoteDTO createConnote(); }### Answer:
@Test public void nextConnote_Goodcase() throws Exception { Long uniqueConnote = 1L; Connote connoteToBeSaved = new Connote(uniqueConnote); connoteToBeSaved.setCreated(new LocalDateTime(2017, 01, 02, 12, 03, 10)); when(randomConnoteGeneratorMock.randomNumber()).thenReturn(342L, uniqueConnote); when(connoteRepositoryMock.findOne(342L)).thenReturn(new Connote(342L)); when(connoteRepositoryMock.findOne(uniqueConnote)).thenReturn(null); when(connoteRepositoryMock.save(any(Connote.class))).thenReturn(connoteToBeSaved); ConnoteDTO connote = connoteService.createConnote(); assertThat(connote.getConnote(), is(1L)); verify(randomConnoteGeneratorMock, times(2)).randomNumber(); }
|
### Question:
BookingController { @RequestMapping(value = "create", method = RequestMethod.POST) @ResponseBody public ResponseEntity<BookingServiceResponseDTO> create(@RequestBody BookingServiceRequestDTO bookingRequestDTO, HttpServletRequest request) { LOGGER.debug(LOGGER.isDebugEnabled() ? "BookingRequest: " + bookingRequestDTO.toString() : null); BookingServiceResponseDTO booking = bookingService.createBooking(bookingRequestDTO); appendSpan(booking == null || booking.getStatus() == null ? "ERROR" : booking.getStatus(),"booking-status"); return new ResponseEntity<>(booking, HttpStatus.OK); } @Autowired BookingController(BookingService bookingService, Tracer tracer); @RequestMapping(value = "create", method = RequestMethod.POST) @ResponseBody ResponseEntity<BookingServiceResponseDTO> create(@RequestBody BookingServiceRequestDTO bookingRequestDTO,
HttpServletRequest request); }### Answer:
@Test public void create() throws Exception { BookingServiceRequestDTO bookingRequestDTO = new BookingServiceRequestDTO(); bookingRequestDTO.setCustomerDTO(createCustomerDTO()); bookingRequestDTO.setReceiverAddress(createAddress()); bookingRequestDTO.setSenderAddress(createAddress()); BookingServiceResponseDTO bookingResponseDTO = new BookingServiceResponseDTO(); ConnoteDTO connoteDTO = new ConnoteDTO(); connoteDTO.setConnote(123L); bookingResponseDTO.setConnoteDTO(connoteDTO); bookingResponseDTO.setStatus("OK"); when(bookingServiceMock.createBooking(bookingRequestDTO)).thenReturn(bookingResponseDTO); mockMvc.perform(post("/rest/booking/create") .contentType(MediaType.APPLICATION_JSON_UTF8) .content(jsonStringFromObject(bookingRequestDTO)) ) .andExpect(status().isOk()); }
|
### Question:
Search { public String serialize() { ObjectMapper mapper = new ObjectMapper(); try { return mapper.writeValueAsString(this); } catch (JsonProcessingException ex) { LOG.error("Could not serialize search", ex); } return StringUtils.EMPTY; } Search(ElasticSearchService elasticSearchService, String index); SearchResult perform(); RootQuery query(); Search size(int size); Search from(int from); Search minScore(double minScore); Sort sort(); Highlight highlight(); String serialize(); }### Answer:
@Test public void testEmptySearch() { assertEquals("{}", underTest.serialize()); }
|
### Question:
PageSearch extends Search { public PageSearch templates(String... resourceTypes) { query().bool().filter().terms("cq:template", resourceTypes); return this; } PageSearch(ElasticSearchService elasticSearchService, String index); PageSearch templates(String... resourceTypes); PageSearch path(String path); PageSearch title(String title); PageSearch newestFirst(boolean newestFirst); }### Answer:
@Test public void testTemplateSearch() throws IOException { underTest.templates("/apps/foo", "/apps/bar"); assertEquals("{\"query\":" + "{\"bool\":" + "{\"filter\":" + "[" + "{\"terms\":" + "{\"cq:template\":" + "[" + "\"/apps/foo\"," + "\"/apps/bar\"" + "]" + "}" + "}]}}}", underTest.serialize()); }
|
### Question:
TrackerRegistry { public boolean removeTrackersForCore(String coreName) { return this.trackers.remove(coreName) != null; } Set<String> getCoreNames(); Collection<Tracker> getTrackersForCore(String coreName); boolean hasTrackersForCore(String coreName); @SuppressWarnings("unchecked") T getTrackerForCore(String coreName, Class<T> trackerClass); synchronized void register(String coreName, Tracker tracker); boolean removeTrackersForCore(String coreName); ModelTracker getModelTracker(); void setModelTracker(ModelTracker modelTracker); }### Answer:
@Test public void testRemoveTrackersForCore() { registerTrackers(CORE3_NAME); boolean thereWereTrackers = reg.removeTrackersForCore(CORE3_NAME); assertTrue(thereWereTrackers); assertTrue(reg.getTrackersForCore(CORE3_NAME).isEmpty()); thereWereTrackers = reg.removeTrackersForCore(NOT_A_CORE_NAME); assertFalse(thereWereTrackers); }
|
### Question:
LanguagePrefixedTokenStream extends Tokenizer { String localisedFieldTypeName(String language) { return LOCALISED_FIELD_TYPE_NAME_PREFIX + language; } LanguagePrefixedTokenStream(IndexSchema indexSchema, String fieldName, AlfrescoAnalyzerWrapper.Mode mode); @Override void reset(); @Override boolean incrementToken(); @Override void end(); @Override void close(); }### Answer:
@Test public void localisedFieldTypeName() { stream(Locale.getAvailableLocales()) .map(Locale::getLanguage) .forEach(language -> assertEquals( LOCALISED_FIELD_TYPE_NAME_PREFIX + language, classUnderTest.localisedFieldTypeName(language))); }
|
### Question:
LanguagePrefixedTokenStream extends Tokenizer { String highlightingFieldTypeName(String language) { return LOCALISED_HIGHLIGHTING_FIELD_TYPE_NAME_PREFIX + language; } LanguagePrefixedTokenStream(IndexSchema indexSchema, String fieldName, AlfrescoAnalyzerWrapper.Mode mode); @Override void reset(); @Override boolean incrementToken(); @Override void end(); @Override void close(); }### Answer:
@Test public void highlightingFieldTypeName() { stream(Locale.getAvailableLocales()) .map(Locale::getLanguage) .forEach(language -> assertEquals( LOCALISED_HIGHLIGHTING_FIELD_TYPE_NAME_PREFIX + language, classUnderTest.highlightingFieldTypeName(language))); }
|
### Question:
LanguagePrefixedTokenStream extends Tokenizer { int localeMarkerLength(Optional<String> language) { return language.map(String::length).map(length -> length + 2).orElse(0); } LanguagePrefixedTokenStream(IndexSchema indexSchema, String fieldName, AlfrescoAnalyzerWrapper.Mode mode); @Override void reset(); @Override boolean incrementToken(); @Override void end(); @Override void close(); }### Answer:
@Test public void localeMarkerLenghthWithValidLocale_shouldReturnTheMarkerLength() { stream(Locale.getAvailableLocales()) .map(Locale::getLanguage) .forEach(language -> assertEquals( language.length() + 2, classUnderTest.localeMarkerLength(Optional.of(language)))); }
@Test public void localeMarkerLenghthWithInvalidLocale_shouldReturnZero() { assertEquals(0, classUnderTest.localeMarkerLength(Optional.empty())); }
|
### Question:
LanguagePrefixedTokenStream extends Tokenizer { Pair<Optional<String>, Reader> languageAndReaderFrom(Reader reader) throws IOException { final char [] prefix = new char[5]; final int read = reader.read(prefix); if (read < prefix.length) { return new Pair<>(Optional.empty(), isValidLocaleMarker(prefix) ? new CharArrayReader(EMPTY_CHARSTREAM) : new CharArrayReader(prefix, 0, Math.max(read, 0))); } else { if (isValidLocaleMarker(prefix)) { if (isTwoCharsLanguageCode(prefix)) { Reader alreadyConsumedCharsReader = new CharArrayReader(prefix, prefix.length - 1, 1); return new Pair<>( of(new String(prefix, 1, 2).toLowerCase()), new CompositeReader(alreadyConsumedCharsReader, reader)); } else { return new Pair<>( of(new String(prefix, 1, 3).toLowerCase()), reader); } } else { Reader alreadyConsumedCharsReader = new CharArrayReader(prefix); return new Pair<>(Optional.empty(), new CompositeReader(alreadyConsumedCharsReader, reader)); } } } LanguagePrefixedTokenStream(IndexSchema indexSchema, String fieldName, AlfrescoAnalyzerWrapper.Mode mode); @Override void reset(); @Override boolean incrementToken(); @Override void end(); @Override void close(); }### Answer:
@Test public void languageAndReaderWithNoData() throws IOException { StringReader emptyReader = new StringReader(""); Pair<Optional<String>, Reader> data = classUnderTest.languageAndReaderFrom(emptyReader); assertTrue(data.getFirst().isEmpty()); }
|
### Question:
SolrCoreLoadListener extends AbstractSolrEventListener { void shutdownTrackers(SolrCore core, Collection<Tracker> coreTrackers, SolrTrackerScheduler scheduler, boolean coreHasBeenReloaded) { coreTrackers.forEach(tracker -> shutdownTracker(core, tracker, scheduler, coreHasBeenReloaded)); } SolrCoreLoadListener(SolrCore core); @Override void newSearcher(SolrIndexSearcher newSearcher, SolrIndexSearcher currentSearcher); }### Answer:
@Test public void trackersShutDownProcedure() { List<Tracker> coreTrackers = asList(mock(AclTracker.class), mock(ContentTracker.class), mock(MetadataTracker.class), mock(CascadeTracker.class)); listener.shutdownTrackers(core, coreTrackers, scheduler, false); coreTrackers.forEach(tracker -> verify(tracker).setShutdown(true)); coreTrackers.forEach(tracker -> verify(scheduler).deleteJobForTrackerInstance(core.getName(), tracker)); coreTrackers.forEach(tracker -> verify(tracker).shutdown()); }
|
### Question:
AclReaders { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + (int) (id ^ (id >>> 32)); return result; } AclReaders(long id, List<String> readers, List<String> denied, long aclChangeSetId, String tenantDomain); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); long getId(); List<String> getReaders(); void setReaders(List readers); List<String> getDenied(); long getAclChangeSetId(); String getTenantDomain(); }### Answer:
@Test public void testHashCode() { assertEquals(new AclReaders(123, null, null, 0, null).hashCode(), new AclReaders(123, null, null, 0, null).hashCode()); assertNotEquals(new AclReaders(123, null, null, 0, null).hashCode(), new AclReaders(124, null, null, 0, null).hashCode()); }
|
### Question:
AclReaders { @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; AclReaders other = (AclReaders) obj; if (id != other.id) return false; return true; } AclReaders(long id, List<String> readers, List<String> denied, long aclChangeSetId, String tenantDomain); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); long getId(); List<String> getReaders(); void setReaders(List readers); List<String> getDenied(); long getAclChangeSetId(); String getTenantDomain(); }### Answer:
@Test public void testEqualsObject() { final AclReaders aclReaders = new AclReaders(0, null, null, 0, null); assertTrue(aclReaders.equals(aclReaders)); assertEquals(new AclReaders(123, null, null, 0, null), new AclReaders(123, null, null, 0, null)); assertNotEquals(new AclReaders(123, null, null, 0, null), new AclReaders(124, null, null, 0, null)); }
|
### Question:
AclReaders { public List<String> getReaders() { return unmodifiableList(readers); } AclReaders(long id, List<String> readers, List<String> denied, long aclChangeSetId, String tenantDomain); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); long getId(); List<String> getReaders(); void setReaders(List readers); List<String> getDenied(); long getAclChangeSetId(); String getTenantDomain(); }### Answer:
@Test public void testGetReaders() { AclReaders aclReaders = new AclReaders(0, null, asList("d1", "d2"), 0, null); assertEquals(asList("d1", "d2"), aclReaders.getDenied()); }
|
### Question:
AclReaders { public List<String> getDenied() { return unmodifiableList(denied); } AclReaders(long id, List<String> readers, List<String> denied, long aclChangeSetId, String tenantDomain); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); long getId(); List<String> getReaders(); void setReaders(List readers); List<String> getDenied(); long getAclChangeSetId(); String getTenantDomain(); }### Answer:
@Test public void testGetDenied() { AclReaders aclReaders = new AclReaders(0, asList("r1", "r2", "r3"), null, 0, null); assertEquals(asList("r1", "r2", "r3"), aclReaders.getReaders()); }
|
### Question:
AlfrescoCoreAdminHandler extends CoreAdminHandler { NamedList<Object> actionDisableIndexing(SolrParams params) throws JSONException { return executeTrackerSubsystemLifecycleAction(params, this::disableIndexingOnSpecificCore); } AlfrescoCoreAdminHandler(); AlfrescoCoreAdminHandler(CoreContainer coreContainer); @Override void shutdown(); ConcurrentHashMap<String, InformationServer> getInformationServers(); TrackerRegistry getTrackerRegistry(); SolrTrackerScheduler getScheduler(); static final String ALFRESCO_DEFAULTS; }### Answer:
@Test public void unknownCoreNameInDisableIndexingCommand_shouldReturnAnErrorResponse() { String unknownCoreName = "ThisShouldBeAnInexistentCore"; CORE_PARAMETER_NAMES.forEach(parameter -> { params.set(parameter, unknownCoreName); NamedList<?> response = admin.actionDisableIndexing(params); assertEquals(UNKNOWN_CORE_MESSAGE + unknownCoreName, response.get(ACTION_ERROR_MESSAGE_LABEL)); }); }
|
### Question:
AlfrescoCoreAdminHandler extends CoreAdminHandler { NamedList<Object> actionEnableIndexing(SolrParams params) throws JSONException { return executeTrackerSubsystemLifecycleAction(params, this::enableIndexingOnSpecificCore); } AlfrescoCoreAdminHandler(); AlfrescoCoreAdminHandler(CoreContainer coreContainer); @Override void shutdown(); ConcurrentHashMap<String, InformationServer> getInformationServers(); TrackerRegistry getTrackerRegistry(); SolrTrackerScheduler getScheduler(); static final String ALFRESCO_DEFAULTS; }### Answer:
@Test public void unknownCoreNameInEnableIndexingCommand_shouldReturnAnErrorResponse() { String unknownCoreName = "ThisShouldBeAnInexistentCore"; CORE_PARAMETER_NAMES.forEach(parameter -> { params.set(parameter, unknownCoreName); NamedList<?> response = admin.actionEnableIndexing(params); assertEquals(UNKNOWN_CORE_MESSAGE + unknownCoreName, response.get(ACTION_ERROR_MESSAGE_LABEL)); }); }
|
### Question:
RewriteFacetParametersComponent extends SearchComponent { public static String[] parseFacetField(String line) { if(StringUtils.isEmpty(line)) { throw new RuntimeException("String input is requried"); } String[] tokens = line.split(",(?=(?:[^'|\"]*\"[^'|\"]*\")*[^'|\"]*$)", -1); return tokens; } @Override void prepare(ResponseBuilder rb); static String[] parseFacetField(String line); @Override void process(ResponseBuilder rb); @Override String getDescription(); @Override String getSource(); }### Answer:
@Test public void parseFacetField() { String a = "created,modified"; String b = "cm:created,modified"; String c = "modified"; String d = "{crazy}created,modified,updated"; String e = "{bob:\"fred\"}created,modified,updated"; String f = "{perc=\"3,4,5\"}created,modified"; String g = "{perc='3,4,5'}created,modified"; assertEquals(2, RewriteFacetParametersComponent.parseFacetField(a).length); assertEquals(2, RewriteFacetParametersComponent.parseFacetField(b).length); assertEquals(1, RewriteFacetParametersComponent.parseFacetField(c).length); assertEquals(3, RewriteFacetParametersComponent.parseFacetField(d).length); assertEquals(3, RewriteFacetParametersComponent.parseFacetField(e).length); assertEquals(2, RewriteFacetParametersComponent.parseFacetField(f).length); assertEquals(2, RewriteFacetParametersComponent.parseFacetField(g).length); }
@Test(expected=RuntimeException.class) public void parseEmpty() { RewriteFacetParametersComponent.parseFacetField(""); }
@Test(expected=RuntimeException.class) public void parseNull() { RewriteFacetParametersComponent.parseFacetField(null); }
|
### Question:
TempFileWarningLogger { protected String getGlob() { return glob; } TempFileWarningLogger(Logger log, String prefix, String[] extensions, Path dir); @SuppressWarnings("RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE") boolean checkFiles(); @SuppressWarnings("RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE") void removeFiles(); }### Answer:
@Test public void checkGlobBuiltCorrectly() { TempFileWarningLogger warner = new TempFileWarningLogger( log, "MyPrefix*", new String[] { "temp", "remove-me", "~notrequired" }, path); assertEquals("MyPrefix*.{temp,remove-me,~notrequired}", warner.getGlob()); }
|
### Question:
TempFileWarningLogger { @SuppressWarnings("RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE") public boolean checkFiles() { if (log.isDebugEnabled()) { log.debug("Looking for temp files matching " + glob + " in directory " + dir); } try(DirectoryStream<Path> stream = Files.newDirectoryStream(dir, glob)) { for (Path file : stream) { if (log.isDebugEnabled()) { log.debug("Solr suggester temp file found matching file pattern: " + glob + ", path: " + file); log.debug("Removing suggester temp files."); } return true; } return false; } catch (IOException e) { throw new RuntimeException("Unable to create directory stream", e); } } TempFileWarningLogger(Logger log, String prefix, String[] extensions, Path dir); @SuppressWarnings("RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE") boolean checkFiles(); @SuppressWarnings("RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE") void removeFiles(); }### Answer:
@Test public void checkFindFiles() throws IOException { File f = File.createTempFile("MyPrefix", ".remove-me", path.toFile()); f.deleteOnExit(); try { TempFileWarningLogger warner = new TempFileWarningLogger( log, "MyPrefix*", new String[] { "temp", "remove-me", "~notrequired" }, path); boolean found = warner.checkFiles(); assertTrue("Should have found matching files", found); verify(log, never()).warn(anyString()); } finally { f.delete(); } }
@Test public void checkWhenNoFilesToFind() throws IOException { File f = new File(path.toFile(), "TestFile.random"); assertFalse("Unable to perform test as file exists: " + f, f.exists()); TempFileWarningLogger warner = new TempFileWarningLogger( log, "TestFile", new String[] { "random" }, path); boolean found = warner.checkFiles(); assertFalse("Should NOT have found matching file", found); verify(log, never()).warn(anyString()); }
|
### Question:
ConfigUtil { public static String locateProperty(String propertyName, String defaultValue) { String propertyValue = null; String propertyKey = propertyName; String jndiKey = convertPropertyNameToJNDIPath(propertyKey); String envVar = convertPropertyNameToEnvironmentParam(propertyKey); try { Context c = new InitialContext(); propertyValue = (String) c.lookup(jndiKey); log.debug("Using JNDI key: "+jndiKey+": "+propertyValue ); return propertyValue; } catch (NoInitialContextException e) { log.debug("JNDI not configured (NoInitialContextEx)"); } catch (NamingException e) { log.debug("No "+jndiKey+" in JNDI"); } catch( RuntimeException ex ) { log.warn("Odd RuntimeException while testing for JNDI: " + ex.getMessage()); } propertyValue = System.getProperty(propertyKey); if( propertyValue != null ) { log.debug("Using system property "+propertyKey+": " + propertyValue ); return propertyValue; } propertyValue = System.getProperty("solr."+propertyKey); if( propertyValue != null ) { log.debug("Using system property "+"solr."+propertyKey+": " + propertyValue ); return propertyValue; } propertyValue = System.getenv(envVar); if( propertyValue != null ) { log.debug("Using environment variable "+envVar+": " + propertyValue ); return propertyValue; } log.debug("Using default value for variable "+propertyName+": " + defaultValue ); return defaultValue; } static String locateProperty(String propertyName, String defaultValue); }### Answer:
@Test public void locateProperty() throws Exception { assertEquals("king", ConfigUtil.locateProperty("find.me", "king")); System.setProperty("solr.find.me", "iamfound"); assertEquals("iamfound", ConfigUtil.locateProperty("find.me", "king")); System.clearProperty("solr.find.me"); assertEquals("king", ConfigUtil.locateProperty("find.me", "king")); System.setProperty("find.me", "iamfoundagain"); assertEquals("iamfoundagain", ConfigUtil.locateProperty("find.me", "king")); System.clearProperty("find.me"); }
|
### Question:
ConfigUtil { protected static String convertPropertyNameToJNDIPath(String propertyName) { if (propertyName == null) propertyName = ""; return JNDI_PREFIX+propertyName.replace('.','/'); } static String locateProperty(String propertyName, String defaultValue); }### Answer:
@Test public void convertPropertyNameToJNDIPath() throws Exception { assertEquals("java:comp/env/gethin",ConfigUtil.convertPropertyNameToJNDIPath("gethin")); assertEquals("java:comp/env/solr/content/dir",ConfigUtil.convertPropertyNameToJNDIPath("solr.content.dir")); assertEquals("java:comp/env/solr/model/dir",ConfigUtil.convertPropertyNameToJNDIPath("solr.model.dir")); assertEquals("java:comp/env/",ConfigUtil.convertPropertyNameToJNDIPath("")); assertEquals("java:comp/env/",ConfigUtil.convertPropertyNameToJNDIPath(null)); }
|
### Question:
ConfigUtil { protected static String convertPropertyNameToEnvironmentParam(String propertyName) { if (propertyName == null) propertyName = ""; return ENV_PREFIX+propertyName.replace('.','_').toUpperCase(); } static String locateProperty(String propertyName, String defaultValue); }### Answer:
@Test public void convertPropertyNameToEnvironmentParam() throws Exception { assertEquals("SOLR_GETHIN",ConfigUtil.convertPropertyNameToEnvironmentParam("gethin")); assertEquals("SOLR_SOLR_CONTENT_DIR",ConfigUtil.convertPropertyNameToEnvironmentParam("solr.content.dir")); assertEquals("SOLR_SOLR_MODEL_DIR",ConfigUtil.convertPropertyNameToEnvironmentParam("solr.model.dir")); assertEquals("SOLR_CREATE_ALFRESCO_DEFAULTS",ConfigUtil.convertPropertyNameToEnvironmentParam(AlfrescoCoreAdminHandler.ALFRESCO_DEFAULTS)); assertEquals("SOLR_SOLR_HOST",ConfigUtil.convertPropertyNameToEnvironmentParam(SolrInformationServer.SOLR_HOST)); assertEquals("SOLR_SOLR_PORT",ConfigUtil.convertPropertyNameToEnvironmentParam(SolrInformationServer.SOLR_PORT)); assertEquals("SOLR_SOLR_BASEURL",ConfigUtil.convertPropertyNameToEnvironmentParam(SolrInformationServer.SOLR_BASEURL)); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.