@Test
public void mustBeAbleToRecover() throws Exception {
final ManualProbe<Integer> publisherProbe = TestPublisher.manualProbe(true, system);
final JavaTestKit probe = new JavaTestKit(system);
final Source<Integer, NotUsed> source =
Source.fromPublisher(publisherProbe)
.map(
elem -> {
if (elem == 1) throw new RuntimeException("ex");
else return elem;
})
.recover(new PFBuilder<Throwable, Integer>().matchAny(ex -> 0).build());
final CompletionStage<Done> future =
source.runWith(
Sink.foreach(elem -> probe.getRef().tell(elem, ActorRef.noSender())), materializer);
final PublisherProbeSubscription<Integer> s = publisherProbe.expectSubscription();
s.sendNext(0);
probe.expectMsgEquals(0);
s.sendNext(1);
probe.expectMsgEquals(0);
future.toCompletableFuture().get(200, TimeUnit.MILLISECONDS);
}
@Test
public void reusingComponents() throws Exception {
final Source<Integer, NotUsed> nestedSource =
Source.single(0) // An atomic source
.map(i -> i + 1) // an atomic processing stage
.named("nestedSource"); // wraps up the current Source and gives it a name
final Flow<Integer, Integer, NotUsed> nestedFlow =
Flow.of(Integer.class)
.filter(i -> i != 0) // an atomic processing stage
.map(i -> i - 2) // another atomic processing stage
.named("nestedFlow"); // wraps up the Flow, and gives it a name
final Sink<Integer, NotUsed> nestedSink =
nestedFlow
.to(Sink.fold(0, (acc, i) -> acc + i)) // wire an atomic sink to the nestedFlow
.named("nestedSink"); // wrap it up
// #reuse
// Create a RunnableGraph from our components
final RunnableGraph<NotUsed> runnableGraph = nestedSource.to(nestedSink);
// Usage is uniform, no matter if modules are composite or atomic
final RunnableGraph<NotUsed> runnableGraph2 =
Source.single(0).to(Sink.fold(0, (acc, i) -> acc + i));
// #reuse
}
/**
* Method removes a Spring bean definition from the XML application context file. Bean definition
* is identified by its id or bean name.
*
* @param project
* @param id
*/
public void removeBeanDefinition(File configFile, Project project, String id) {
Source xsltSource;
Source xmlSource;
try {
xsltSource =
new StreamSource(new ClassPathResource("transform/delete-bean.xsl").getInputStream());
xsltSource.setSystemId("delete-bean");
List<File> configFiles = new ArrayList<>();
configFiles.add(configFile);
configFiles.addAll(getConfigImports(configFile, project));
for (File file : configFiles) {
xmlSource = new StringSource(FileUtils.readToString(new FileInputStream(configFile)));
// create transformer
Transformer transformer = transformerFactory.newTransformer(xsltSource);
transformer.setParameter("bean_id", id);
// transform
StringResult result = new StringResult();
transformer.transform(xmlSource, result);
FileUtils.writeToFile(format(result.toString(), project.getSettings().getTabSize()), file);
return;
}
} catch (IOException e) {
throw new ApplicationRuntimeException(UNABLE_TO_READ_TRANSFORMATION_SOURCE, e);
} catch (TransformerException e) {
throw new ApplicationRuntimeException(FAILED_TO_UPDATE_BEAN_DEFINITION, e);
}
}
@Test
public void mustBeAbleToUseZipWith() throws Exception {
final JavaTestKit probe = new JavaTestKit(system);
final Iterable<String> input1 = Arrays.asList("A", "B", "C");
final Iterable<String> input2 = Arrays.asList("D", "E", "F");
Source.from(input1)
.zipWith(
Source.from(input2),
new Function2<String, String, String>() {
public String apply(String s1, String s2) {
return s1 + "-" + s2;
}
})
.runForeach(
new Procedure<String>() {
public void apply(String elem) {
probe.getRef().tell(elem, ActorRef.noSender());
}
},
materializer);
probe.expectMsgEquals("A-D");
probe.expectMsgEquals("B-E");
probe.expectMsgEquals("C-F");
}
/*
* We need a type which can be resolved 2 different ways:
*
* SourceChild == Source : mapping SourceChild == SourceChild : converter
*/
@Test
public void testResolveTypes2() {
MapperFacade mapper = new MyMapper();
Source src = new Source();
src.name = "source 1";
src.description = "source 1 description";
SourceChild srcChild = new SourceChild();
srcChild.name = "source 1";
srcChild.description = "source 1 description";
/*
* Mapping Source to Dest2 causes a mapping to be created
*/
Dest2 dest2 = mapper.map(src, Dest2.class);
/*
* SourceChild is able to use this mapping, so the resolved type in this
* case for SourceChild is 'Source', which gets cached in resolvedTypes
*/
Dest2 dest2B = mapper.map(srcChild, Dest2.class);
Assert.assertNotNull(dest2);
Assert.assertNotNull(dest2B);
/*
* But now, since the resolvedType for 'SourceChild' has been cached as
* 'Source', it cannot find the converter which has been specifically
* created for 'SourceChild'
*/
Dest1 dest1 = mapper.map(srcChild, Dest1.class);
Assert.assertNotNull(dest1);
}
private void completeEvidenceDocument() throws IOException {
String tempText =
"<table><tr><td class=\"subHeading\">Evidence:</td><td class=\"info\">"
+ this.theEvidence.getName()
+ "</td></tr>\n";
// add the type of evidence
tempText +=
"<tr><td class=\"subHeading\">Type:</td><td class=\"info\">"
+ this.theEvidence.getType()
+ "</td></tr>\n";
// add the evidence description
tempText +=
"<tr><td class=\"subHeading\">Description:</td><td class=\"info\">"
+ this.theEvidence.getDescription()
+ "</td></tr>\n";
// add the sources relating to the given piece of evidence
tempText += "<tr><td class=\"subHeading\">References:</td><td class=\"info\" colspan=\"3\">\n";
for (Source s : this.theEvidence.getSources(allTheSources)) {
tempText +=
"\t<li><a href=\"../source/" + s.getName() + ".html\">" + s.getName() + "</a></li>\n";
}
tempText += "</td></tr>\n";
// tempText +="</body></html>";
tempText +=
"</table></div>\n<div id=\"footer\">\n\t© "
+ getYear()
+ " <a href=\"http://www.eecs.qmul.ac.uk/research/view/risk-and-information-management\"> Risk and Information Management (RIM) Research Group, Queen Mary, University of London</a>\n</div>\n</body>\n</html>";
appendCurrentDocument(tempText, "evidence");
}
/**
* Method adds a new Spring bean definition to the XML application context file.
*
* @param project
* @param jaxbElement
*/
public void addBeanDefinition(File configFile, Project project, Object jaxbElement) {
Source xsltSource;
Source xmlSource;
try {
xsltSource =
new StreamSource(new ClassPathResource("transform/add-bean.xsl").getInputStream());
xsltSource.setSystemId("add-bean");
xmlSource = new StringSource(FileUtils.readToString(new FileInputStream(configFile)));
// create transformer
Transformer transformer = transformerFactory.newTransformer(xsltSource);
transformer.setParameter(
"bean_content",
getXmlContent(jaxbElement)
.replaceAll("(?m)^(.)", getTabs(1, project.getSettings().getTabSize()) + "$1"));
// transform
StringResult result = new StringResult();
transformer.transform(xmlSource, result);
FileUtils.writeToFile(
format(result.toString(), project.getSettings().getTabSize()), configFile);
return;
} catch (IOException e) {
throw new ApplicationRuntimeException(UNABLE_TO_READ_TRANSFORMATION_SOURCE, e);
} catch (TransformerException e) {
throw new ApplicationRuntimeException(FAILED_TO_UPDATE_BEAN_DEFINITION, e);
}
}
/**
* Return the Properties that enumerate the keys for this Source
*
* @param source the Source
* @return the relevant Properties
*/
protected static Properties getKeyProperties(Source source) {
Properties keys = null;
synchronized (sourceKeys) {
keys = sourceKeys.get(source);
if (keys == null) {
String sourceNameKeysFileName = source.getName() + "_keys.properties";
keys = PropertiesUtil.loadProperties(sourceNameKeysFileName);
String sourceTypeKeysFileName = source.getType() + "_keys.properties";
if (keys == null) {
keys = PropertiesUtil.loadProperties(sourceTypeKeysFileName);
}
if (keys == null) {
throw new RuntimeException(
"can't find keys for source: "
+ source
+ " after trying to find: "
+ sourceNameKeysFileName
+ " and: "
+ sourceTypeKeysFileName);
}
sourceKeys.put(source, keys);
}
}
return keys;
}
/**
* Adds a new streaming source to the list. If another source in the list is already playing on
* the same channel, it is stopped and removed from the list.
*
* @param source New source to stream.
*/
public void watch(Source source) {
// make sure the source exists:
if (source == null) return;
// make sure we aren't already watching this source:
if (streamingSources.contains(source)) return;
ListIterator<Source> iter;
Source src;
// Make sure noone else is accessing the list of sources:
synchronized (listLock) {
// Any currently watched source which is null or playing on the
// same channel as the new source should be stopped and removed
// from the list.
iter = streamingSources.listIterator();
while (iter.hasNext()) {
src = iter.next();
if (src == null) {
iter.remove();
} else if (source.channel == src.channel) {
src.stop();
iter.remove();
}
}
// Add the new source to the list:
streamingSources.add(source);
}
}
/**
* @param pcat
* @param array
* @param coordTab
* @param flagIgnore
*/
private static void fillXMatchArray(
Pcat pcat, double[][] array, int[] coordTab, boolean[] flagIgnore) {
Source o;
String content;
Iterator<Obj> it = pcat.iterator();
for (int i = 0; it.hasNext(); i++) {
o = (Source) it.next();
// not needed
// flagIgnore[i] = false;
try {
// ra
content = o.getValue(coordTab[0]);
if (isSexa(content)) content = sexa2Deg(content, true);
// array[i][0] = Double.parseDouble(content);
array[i][0] = Double.valueOf(content).doubleValue();
// dec
content = o.getValue(coordTab[1]);
if (isSexa(content)) content = sexa2Deg(content, false);
// array[i][1] = Double.parseDouble(content);
array[i][1] = Double.valueOf(content).doubleValue();
} catch (NumberFormatException e) {
e.printStackTrace();
// ignore this source
flagIgnore[i] = true;
// array[i][0] = array[i][1] = 0.0;
} catch (NullPointerException npe) {
npe.printStackTrace();
// ignore this source
flagIgnore[i] = true;
}
}
}
@Test
public void testAssociateFile() throws Exception {
sm.register(SOURCE, testFile);
String statistics = "statistics";
Source source = sm.getSource(SOURCE);
String rcStr = associateFile(source, statistics);
assertEquals(sm.getSource(SOURCE).getFilePropertyNames().length, 1);
sm.saveStatus();
sm.shutdown();
sm.init();
assertEquals(sm.getSource(SOURCE).getFilePropertyNames().length, 1);
String statsContent = source.getFilePropertyContentsAsString(statistics);
assertEquals(statsContent, rcStr);
File f = source.getFileProperty(statistics);
DataInputStream dis = new DataInputStream(new FileInputStream(f));
byte[] content = new byte[dis.available()];
dis.readFully(content);
assertEquals(new String(content), rcStr);
}
@Test
public void testReturnNullWhenNoProperty() throws Exception {
sm.register(SOURCE, testFile);
Source source = sm.getSource(SOURCE);
assertNull(source.getFileProperty("skjbnskb"));
assertNull(source.getProperty("skjbnskb"));
}
private void recoverSourceSequence(
Endpoint endpoint, Conduit conduit, Source s, SourceSequence ss) {
Collection<RMMessage> ms = store.getMessages(ss.getIdentifier(), true);
if (null == ms || 0 == ms.size()) {
store.removeSourceSequence(ss.getIdentifier());
return;
}
LOG.log(Level.FINE, "Number of messages in sequence: {0}", ms.size());
s.addSequence(ss, false);
// choosing an arbitrary valid source sequence as the current source sequence
if (s.getAssociatedSequence(null) == null && !ss.isExpired() && !ss.isLastMessage()) {
s.setCurrent(ss);
}
for (RMMessage m : ms) {
Message message = new MessageImpl();
Exchange exchange = new ExchangeImpl();
message.setExchange(exchange);
exchange.setOutMessage(message);
if (null != conduit) {
exchange.setConduit(conduit);
message.put(Message.REQUESTOR_ROLE, Boolean.TRUE);
}
exchange.put(Endpoint.class, endpoint);
exchange.put(Service.class, endpoint.getService());
exchange.put(Binding.class, endpoint.getBinding());
exchange.put(Bus.class, bus);
SequenceType st = new SequenceType();
st.setIdentifier(ss.getIdentifier());
st.setMessageNumber(m.getMessageNumber());
RMProperties rmps = new RMProperties();
rmps.setSequence(st);
rmps.exposeAs(ss.getProtocol().getWSRMNamespace());
if (ss.isLastMessage() && ss.getCurrentMessageNr() == m.getMessageNumber()) {
CloseSequenceType close = new CloseSequenceType();
close.setIdentifier(ss.getIdentifier());
rmps.setCloseSequence(close);
}
RMContextUtils.storeRMProperties(message, rmps, true);
if (null == conduit) {
String to = m.getTo();
AddressingProperties maps = new AddressingProperties();
maps.setTo(RMUtils.createReference(to));
RMContextUtils.storeMAPs(maps, message, true, false);
}
try {
// RMMessage is stored in a serialized way, therefore
// RMMessage content must be splitted into soap root message
// and attachments
PersistenceUtils.decodeRMContent(m, message);
RMContextUtils.setProtocolVariation(message, ss.getProtocol());
retransmissionQueue.addUnacknowledged(message);
} catch (IOException e) {
LOG.log(Level.SEVERE, "Error reading persisted message data", e);
}
}
}
@Test
public void testOverrideFileProperty() throws Exception {
sm.register(SOURCE, testFile);
Source source = sm.getSource(SOURCE);
String fileProp = "testFileProp";
associateFile(source, fileProp);
File file = source.createFileProperty(fileProp);
FileOutputStream fis = new FileOutputStream(file);
fis.write("newcontent".getBytes());
fis.close();
source.deleteProperty(fileProp);
File dir = sm.getSourceInfoDirectory();
File[] content =
dir.listFiles(
new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return !name.startsWith(".");
}
});
assertEquals(2, content.length);
String[] res = new String[] {content[0].getName(), content[1].getName()};
Arrays.sort(res);
String[] comp = new String[] {"directory.xml", "spatial_ref_sys_extended.gdms"};
assertArrayEquals(res, comp);
}
@Test
public void shouldMapWithCustomizedClassMapBuilder() {
// given
MapperFactory mapperFactory =
new DefaultMapperFactory.Builder()
.classMapBuilderFactory(new ScoringClassMapBuilder.Factory())
.build();
mapperFactory.classMap(Source.class, Destination.class).byDefault().register();
MapperFacade mapperFacade = mapperFactory.getMapperFacade();
Source src = new Source();
src.firstName = "Jan";
src.postalAddress = new PostalAddress();
src.postalAddress.country = new Country();
src.postalAddress.country.alphaCode = "PL";
// when
Destination result = mapperFacade.map(src, Destination.class);
// then
assertThat(result.name.first).isEqualTo("Jan");
assertThat(result.countryCode).isEqualTo("PL");
}
/**
* Returns a string representation of this object useful for debugging purposes.
*
* <p>The output includes details of all the {@link #getRegisteredOutputSegments() registered
* output segments}.
*
* @return a string representation of this object useful for debugging purposes.
*/
public String getDebugInfo() {
StringBuffer sb = new StringBuffer();
for (Iterator i = getRegisteredOutputSegments().iterator(); i.hasNext(); ) {
OutputSegment outputSegment = (OutputSegment) i.next();
if (outputSegment instanceof BlankOutputSegment) sb.append("Replace with Spaces: ");
else if (outputSegment instanceof RemoveOutputSegment) sb.append("Remove: ");
else sb.append("Replace: ");
if (sourceText instanceof Source) {
Source source = (Source) sourceText;
sb.append('(');
source.getRowColumnVector(outputSegment.getBegin()).appendTo(sb);
sb.append('-');
source.getRowColumnVector(outputSegment.getEnd()).appendTo(sb);
sb.append(')');
} else {
sb.append("(p")
.append(outputSegment.getBegin())
.append("-p")
.append(outputSegment.getEnd())
.append(')');
}
sb.append(' ');
String outputFromSegment = outputSegment.toString();
if (outputFromSegment.length() <= 20) {
sb.append(outputFromSegment);
} else {
sb.append(outputFromSegment.substring(0, 20)).append("...");
}
sb.append(Config.NewLine);
}
return sb.toString();
}
@Test
public void mustProduceTicks() throws Exception {
final JavaTestKit probe = new JavaTestKit(system);
Source<String, Cancellable> tickSource =
Source.tick(
FiniteDuration.create(1, TimeUnit.SECONDS),
FiniteDuration.create(500, TimeUnit.MILLISECONDS),
"tick");
@SuppressWarnings("unused")
Cancellable cancellable =
tickSource
.to(
Sink.foreach(
new Procedure<String>() {
public void apply(String elem) {
probe.getRef().tell(elem, ActorRef.noSender());
}
}))
.run(materializer);
probe.expectNoMsg(FiniteDuration.create(600, TimeUnit.MILLISECONDS));
probe.expectMsgEquals("tick");
probe.expectNoMsg(FiniteDuration.create(200, TimeUnit.MILLISECONDS));
probe.expectMsgEquals("tick");
probe.expectNoMsg(FiniteDuration.create(200, TimeUnit.MILLISECONDS));
}
/** Specify which classes are visible to the compiler through -classpath. */
public void setVisibleClasses(Map<String, Source> vs) {
visibleSrcs = new HashSet<>();
for (String s : vs.keySet()) {
Source src = vs.get(s);
visibleSrcs.add(src.file().toURI());
}
}
@Test
public void mustBeAbleToUseFlatMapMerge() throws Exception {
final JavaTestKit probe = new JavaTestKit(system);
final Iterable<Integer> input1 = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
final Iterable<Integer> input2 = Arrays.asList(10, 11, 12, 13, 14, 15, 16, 17, 18, 19);
final Iterable<Integer> input3 = Arrays.asList(20, 21, 22, 23, 24, 25, 26, 27, 28, 29);
final Iterable<Integer> input4 = Arrays.asList(30, 31, 32, 33, 34, 35, 36, 37, 38, 39);
final List<Source<Integer, NotUsed>> mainInputs = new ArrayList<Source<Integer, NotUsed>>();
mainInputs.add(Source.from(input1));
mainInputs.add(Source.from(input2));
mainInputs.add(Source.from(input3));
mainInputs.add(Source.from(input4));
CompletionStage<List<Integer>> future =
Source.from(mainInputs)
.flatMapMerge(3, ConstantFun.<Source<Integer, NotUsed>>javaIdentityFunction())
.grouped(60)
.runWith(Sink.<List<Integer>>head(), materializer);
List<Integer> result = future.toCompletableFuture().get(3, TimeUnit.SECONDS);
final Set<Integer> set = new HashSet<Integer>();
for (Integer i : result) {
set.add(i);
}
final Set<Integer> expected = new HashSet<Integer>();
for (int i = 0; i < 40; ++i) {
expected.add(i);
}
assertEquals(expected, set);
}
private void addDefaultProperties() {
for (Iterator it = m_sources.iterator(); it.hasNext(); ) {
Source source = (Source) it.next();
makePathLoadable(source.getPath());
addFetchedPaths(source.getPath(), source.getObjectType());
}
}
private void appendTraceHeader(
StringBuilder sb,
ExpressionEvaluationContext context,
ExpressionVariables processedVariables) {
sb.append("---[ EXPRESSION in ");
sb.append(context.getContextDescription());
sb.append("]---------------------------");
sb.append("\nSources:");
Collection<Source<?, ?>> sources = context.getSources();
if (sources == null) {
sb.append(" null");
} else {
for (Source<?, ?> source : sources) {
sb.append("\n");
sb.append(source.debugDump(1));
}
}
sb.append("\nVariables:");
if (processedVariables == null) {
sb.append(" null");
} else {
sb.append("\n");
sb.append(processedVariables.debugDump(1));
}
sb.append("\nOutput definition: ").append(MiscUtil.toString(outputDefinition));
sb.append("\nEvaluators: ");
sb.append(shortDebugDump());
}
/**
* Implements the progressive text handling. This method is used as a "web method" with
* progressiveText.jelly.
*/
public void doProgressText(StaplerRequest req, StaplerResponse rsp) throws IOException {
setContentType(rsp);
rsp.setStatus(HttpServletResponse.SC_OK);
if (!source.exists()) {
// file doesn't exist yet
rsp.addHeader("X-Text-Size", "0");
rsp.addHeader("X-More-Data", "true");
return;
}
long start = 0;
String s = req.getParameter("start");
if (s != null) start = Long.parseLong(s);
if (source.length() < start) start = 0; // text rolled over
CharSpool spool = new CharSpool();
long r = writeLogTo(start, spool);
rsp.addHeader("X-Text-Size", String.valueOf(r));
if (!completed) rsp.addHeader("X-More-Data", "true");
Writer w = createWriter(req, rsp, r - start);
spool.writeTo(new LineEndNormalizingWriter(w));
w.close();
}
private void fillXIDArray(Pcat pcat, String[] array, int index) {
Source o;
Iterator<Obj> it = pcat.iterator();
for (int i = 0; it.hasNext(); i++) {
o = (Source) it.next();
array[i] = o.getValue(index);
}
}
static Source createSource(
final String key, final SourceType type, final Map<String, String> fields) {
Source source = new Source();
source.key = key;
source.type = type;
source.fields = fields;
return source;
}
public void go() {
source.start();
source.waitFor();
if (sink != null) {
sink.close();
}
stats.print();
}
@Test
public void mustWorkFromFuture() throws Exception {
final Iterable<String> input = Arrays.asList("A", "B", "C");
CompletionStage<String> future1 = Source.from(input).runWith(Sink.<String>head(), materializer);
CompletionStage<String> future2 =
Source.fromCompletionStage(future1).runWith(Sink.<String>head(), materializer);
String result = future2.toCompletableFuture().get(3, TimeUnit.SECONDS);
assertEquals("A", result);
}
@TruffleBoundary
@Override
public boolean equals(Object obj) {
if (obj instanceof Source) {
Source other = (Source) obj;
return content().equals(other.content()) && equalAttributes(other);
}
return false;
}
@Test
public void sourceFromInputStreamBounds() throws Exception {
Source source = Okio.source(new ByteArrayInputStream(new byte[100]));
try {
source.read(new Buffer(), -1);
fail();
} catch (IllegalArgumentException expected) {
}
}
@Test
@WithClasses({Target.class, SourceTargetMapper.class})
public void shouldUseCustomMapperViaMapperConfigForFooToDto() {
Source source = SourceTargetMapper.INSTANCE.toSource(new Target(new FooEntity()));
assertThat(source.getFoo()).isNotNull();
assertThat(source.getFoo().getCreatedBy())
.isEqualTo(CustomMapperViaMapperConfig.class.getSimpleName());
}
protected void say(Source source, String str) {
Server server = source.getServer();
if (source.talkable()) {
source.messageReceived(server.getNick(), str);
server.say(source.getName(), str);
} else {
source.report(getText(IRCTextProvider.INTERPRETOR_NOT_ON_CHANNEL));
}
}