[jboss-svn-commits] JBL Code SVN: r17019 - in labs/jbossrules/branches/temporal_rete/drools-compiler/src/test: java/org/drools/integrationtests/eventgenerator and 2 other directories.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Tue Dec 4 11:29:14 EST 2007
Author: mgroch
Date: 2007-12-04 11:29:14 -0500 (Tue, 04 Dec 2007)
New Revision: 17019
Added:
labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/
labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/AbstractEventListener.java
labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/Event.java
labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/PseudoSessionClock.java
labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/SimpleEventGenerator.java
labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/SimpleEventGeneratorTest.java
labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/SimpleEventListener.java
labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/resources/org/drools/integrationtests/eventgenerator/
labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/resources/org/drools/integrationtests/eventgenerator/test_eventGenerator.drl
Log:
initial import event generator + test case
Added: labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/AbstractEventListener.java
===================================================================
--- labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/AbstractEventListener.java (rev 0)
+++ labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/AbstractEventListener.java 2007-12-04 16:29:14 UTC (rev 17019)
@@ -0,0 +1,32 @@
+/**
+ *
+ */
+package org.drools.integrationtests.eventgenerator;
+
+import org.drools.WorkingMemory;
+
+
+/**
+ * @author Matthias Groch
+ *
+ */
+public abstract class AbstractEventListener {
+
+ WorkingMemory wm;
+
+ /**
+ * @param wm
+ */
+ public AbstractEventListener(WorkingMemory wm) {
+ this.wm = wm;
+ }
+
+ public void addEventToWM (Event ev){
+ wm.insert(ev);
+ wm.fireAllRules();
+ }
+
+ // send generated event and execute corresponding actions
+ public abstract void generatedEventSent(Event e);
+
+}
Added: labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/Event.java
===================================================================
--- labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/Event.java (rev 0)
+++ labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/Event.java 2007-12-04 16:29:14 UTC (rev 17019)
@@ -0,0 +1,163 @@
+/**
+ *
+ */
+package org.drools.integrationtests.eventgenerator;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author Matthias Groch
+ *
+ */
+public class Event implements Cloneable{
+
+ public enum EventType {CUSTOM, PRODUCTION, STATUSCHANGED, HEARTBEAT, FAILURE};
+
+ private EventType eventId;
+ private String parentId;
+ private Map<String,String> parameters;
+ private long startTime, endTime;
+
+ public Event() {
+ this.parameters = new HashMap <String, String>();
+ }
+
+ /**
+ * @param eventId The name of the event.
+ * @param parentId The id of the corresponding site, resource, ...
+ */
+ public Event(EventType eventId, String parentId) {
+ this();
+ this.eventId = eventId;
+ this.parentId = parentId;
+ }
+
+ /**
+ * @param eventId The name of the event.
+ * @param parentId The id of the corresponding site, resource, ...
+ * @param start The start instance of the event.
+ * @param end The end instance of the event.
+ */
+ public Event(EventType eventId, String parentId, long start, long end) {
+ this(eventId, parentId);
+ this.startTime = start;
+ this.endTime = end;
+ }
+
+ /**
+ * @return the event id
+ */
+ public EventType getEventId() {
+ return this.eventId;
+ }
+
+ /**
+ * @param eventId the event name to set
+ */
+ public void setEventType(EventType eventId) {
+ this.eventId = eventId;
+ }
+
+ /**
+ * @return the endTime
+ */
+ public long getEndTime() {
+ return endTime;
+ }
+
+ /**
+ * @param endTime the endTime to set
+ *//*
+ public void setEndTime(Calendar endTime) {
+ this.endTime = (Calendar)endTime.clone();
+ }*/
+
+ /**
+ * @return the startTime
+ */
+ public long getStartTime() {
+ return startTime;
+ }
+
+ /**
+ * @param startTime the startTime to set
+ *//*
+ public void setStartTime(Calendar startTime) {
+ this.startTime = (Calendar)startTime.clone();
+ }*/
+
+ /**
+ * @param startTime the startTime to set
+ * @param endTime the endTime to set
+ */
+ public void setTimes(long startTime, long endTime) {
+ this.startTime = startTime;
+ this.endTime = endTime;
+ }
+
+ /**
+ * @param startTime the startTime to set
+ * @param endTime the endTime to set
+ */
+ // used for primitive events where start end end time are equal
+ public void setTimes(long startAndEndTime) {
+ this.startTime = startAndEndTime;
+ this.endTime = startAndEndTime;
+ }
+
+ /**
+ * @return the parentId
+ */
+ public String getParentId() {
+ return parentId;
+ }
+
+ /**
+ * @param ressourceId the ressourceId to set
+ */
+ public void setParentId(String parentId) {
+ this.parentId = parentId;
+ }
+
+ /**
+ * @return the parameters
+ */
+ public Map<String, String> getParameters() {
+ return parameters;
+ }
+
+ /**
+ * @param parameter name of the parameter
+ * @return value of the specified parameter
+ */
+ public String getParamValue(String parameter) {
+ return parameters.get(parameter);
+ }
+
+ /**
+ * @param parameters the parameters to set
+ */
+ public void addParameters(Map<String, String> parameters) {
+ this.parameters.putAll(parameters);
+ }
+
+ /**
+ * @param paramName the name of the added parameter to set
+ * @param paramValue the value of the added parameter to set
+ */
+ public void addParameter(String paramName, String paramValue) {
+ this.parameters.put(paramName, paramValue);
+ }
+
+ public Object clone(){
+ try
+ {
+ return super.clone();
+ }
+ catch ( CloneNotSupportedException e ) {
+ // this shouldn’t happen, since we are Cloneable
+ throw new InternalError();
+ }
+ }
+}
Added: labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/PseudoSessionClock.java
===================================================================
--- labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/PseudoSessionClock.java (rev 0)
+++ labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/PseudoSessionClock.java 2007-12-04 16:29:14 UTC (rev 17019)
@@ -0,0 +1,65 @@
+/**
+ *
+ */
+package org.drools.integrationtests.eventgenerator;
+
+
+public class PseudoSessionClock
+ {
+
+ private long timer;
+
+ public PseudoSessionClock() {
+ this.timer = 0;
+ }
+
+ /* (non-Javadoc)
+ * @see org.drools.temporal.SessionClock#getCurrentTime()
+ */
+ public long getCurrentTime() {
+ return this.timer;
+ }
+
+ public long advanceTime( long millisecs ) {
+ this.timer += millisecs;
+ return this.timer;
+ }
+
+ public long setTime( long timer ) {
+ this.timer = timer;
+ return this.timer;
+ }
+
+ // using current system time as reference
+ public long calcFuturePointInTime (long timeToAdd){
+ return this.timer+timeToAdd;
+ }
+
+ // ------------------------------------------------------------------------------------
+ // static convenience methods
+
+ // using an arbitrary starting point as reference
+ public static long calcFuturePointInTime (long currentTime, long timeToAdd){
+ return currentTime+timeToAdd;
+ }
+
+ // convert seconds to milliseconds
+ public static long timeInSeconds (long timeInSecs){
+ return timeInSecs*1000;
+ }
+
+ // convert seconds to milliseconds
+ public static long timeInMinutes (long timeInMins){
+ return timeInSeconds(timeInMins)*60;
+ }
+
+ // convert seconds to milliseconds
+ public static long timeInHours (long timeInHrs){
+ return timeInMinutes(timeInHrs)*60;
+ }
+
+ // convert time given as hours, minutes, seconds, milliseconds to milliseconds
+ public static long timeinHMSM (long hours, long mins, long secs, long msecs){
+ return timeInHours(hours) + timeInMinutes(mins) + timeInSeconds(secs) + msecs;
+ }
+ }
Added: labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/SimpleEventGenerator.java
===================================================================
--- labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/SimpleEventGenerator.java (rev 0)
+++ labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/SimpleEventGenerator.java 2007-12-04 16:29:14 UTC (rev 17019)
@@ -0,0 +1,239 @@
+/**
+ *
+ */
+package org.drools.integrationtests.eventgenerator;
+
+/**
+ * @author Matthias Groch
+ *
+ */
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Random;
+
+import org.drools.FactHandle;
+import org.drools.WorkingMemory;
+
+
+
+public class SimpleEventGenerator {
+
+ private WorkingMemory wm;
+ private long generationEndTime;
+ private static AbstractEventListener sendListener;
+ private boolean endInfinite;
+ private int eventSourceIdCounter;
+ private Map<String, Integer> eventSourceIds;
+ private LinkedList<EventOccurrence> nextEventSource;
+ private PseudoSessionClock myClock;
+ FactHandle clockHandle;
+
+ /**
+ * @param wm
+ */
+ public SimpleEventGenerator(WorkingMemory wm, AbstractEventListener l) {
+ this (wm, l, 0);
+ }
+
+ /**
+ * @param wm
+ * @param generationDuration
+ *
+ */
+ public SimpleEventGenerator(WorkingMemory wm, AbstractEventListener l, long generationDuration) {
+ this.wm = wm;
+ this.sendListener = l;
+ // add session clock to working memory
+ this.myClock = new PseudoSessionClock();
+ this.clockHandle = wm.insert(myClock);
+
+ this.generationEndTime = this.myClock.calcFuturePointInTime(generationDuration);
+ this.endInfinite = (generationDuration == 0);
+ this.eventSourceIdCounter = 0;
+ this.eventSourceIds = new HashMap<String, Integer>();
+ this.nextEventSource = new LinkedList<EventOccurrence>();
+ }
+
+ /**
+ * @return the endInfinite
+ */
+ public boolean isEndInfinite() {
+ return endInfinite;
+ }
+
+ // add source which will generate events from current clock time on, possibly forever (i.e. no boundaries)
+ public EventOccurrence addEventSource(String id, Event ev, long minOccur, long avgOccur){
+ return addEventSource (id, ev, minOccur, avgOccur, 0, 0);
+ }
+
+ // add source which will generate events from current clock time on, but only maxItems instances at the most AND not exceeding the time specified by maxDuration
+ public EventOccurrence addEventSource(String id, Event ev, long minOccur, long avgOccur, long maxDuration, int maxItems){
+ if (!eventSourceIds.containsKey(id)){
+ this.eventSourceIds.put(id, new Integer(eventSourceIdCounter++));
+ EventOccurrence evOcc = new EventOccurrence(id, ev, minOccur, avgOccur, this.myClock.getCurrentTime(), maxDuration, maxItems);
+ this.nextEventSource.add (evOcc);
+ return evOcc;
+ }
+ return null;
+ }
+
+ // add source which will generate events from the given start time on, possibly forever (i.e. no boundaries)
+ public EventOccurrence addDelayedEventSource(String id, Event ev, long minOccur, long avgOccur, long startTime){
+ return addDelayedEventSource (id, ev, minOccur, avgOccur, startTime, 0, 0);
+ }
+
+ // add source which will generate events from the given start time on, but only maxItems instances at the most AND not exceeding the time specified by maxDuration
+ public EventOccurrence addDelayedEventSource(String id, Event ev, long minOccur, long avgOccur, long startTime, long maxDuration, int maxItems){
+ if (!eventSourceIds.containsKey(id)){
+ this.eventSourceIds.put(id, new Integer(eventSourceIdCounter++));
+ EventOccurrence evOcc = new EventOccurrence(id, ev, minOccur, avgOccur, startTime, maxDuration, maxItems);
+ this.nextEventSource.add (evOcc);
+ return evOcc;
+ }
+ return null;
+ }
+
+ public void removeEventSource(String id){
+ Integer hashValue = eventSourceIds.get(id);
+ if (hashValue != null){
+ this.nextEventSource.remove(hashValue.intValue());
+ this.eventSourceIds.remove(id);
+ this.eventSourceIdCounter--;
+ }
+ }
+
+ public static void sendGeneratedEvent(Event ev){
+ sendListener.generatedEventSent(ev);
+ }
+
+
+ public void generate() {
+ EventOccurrence currentEGT;
+ Event currentEvent;
+
+ //sort all events according to their first occurrence
+ Collections.sort(nextEventSource, new EventGenerationTimeComparator());
+
+ // simulate ongoing simulation time and upcoming events
+ while (!nextEventSource.isEmpty()) {
+
+ // get next event generation time from queue
+ currentEGT = nextEventSource.removeFirst();
+ currentEvent = (Event)currentEGT.getEvent().clone();
+
+ // advance clock to time of currentEGT
+ myClock.setTime(currentEGT.getNextOccurrenceTime());
+
+ // send event corresponding to currentEGT
+ sendGeneratedEvent(currentEvent);
+ //System.out.println ("Sender "+currentEGT.getEventSenderId() + ": Sent "+currentEvent.getEventId()+" event for parent id " + currentEvent.getParentId() + " at " + Tools.formattedDate(currentEGT.getNextOccurrenceTime()));
+
+ //update clock in working memory in order being able to process time sensitive rules
+ wm.update(clockHandle, myClock);
+
+ // determine new event generation time for this event type
+ boolean occIsValid = currentEGT.calculateNextEventOccurrence();
+ // add the new generation time to the right position in the queue,
+ // but only if the generated event met its local restrictions plus
+ // it is going to occur within the global time boundaries (or there are no such boundaries, respectively)
+ if (occIsValid && (isEndInfinite() || currentEGT.getNextOccurrenceTime() < this.generationEndTime)) {
+ int index = Collections.binarySearch(nextEventSource, currentEGT, new EventGenerationTimeComparator());
+ if (index < 0)
+ nextEventSource.add(-index-1, currentEGT);
+ }
+ //session.out.print ("\nQueue nach Bearbeitung: ");
+ //for (int i = 0; i < nextEventSource.size(); i++)
+ // session.out.print (Tools.formattedDate(nextEventSource.get(i).getGenerationTime())+"\""+nextEventSource.get(i).getEventSenderId()+"; ");
+
+ };
+
+ //System.out.println ("\nSending of messages finished");
+ }
+
+}
+
+class EventOccurrence{
+
+ private static Random myRandom = new Random();;
+
+ private String eventSenderId;
+ private Event event;
+ private long evDeviation, evMinDur;
+ private int itemCounter, maxItems;
+ private long latestEnd;
+ private boolean infinite;
+
+ public EventOccurrence(String eventSenderId, Event ev, long evMinDur, long avgOccur, long earliestStart, long maxDuration, int maxItems) {
+ this.eventSenderId = eventSenderId;
+ this.evMinDur = evMinDur;
+ this.evDeviation = 2*(avgOccur-evMinDur);
+
+ this.event = ev;
+ this.event.setTimes(earliestStart);
+ this.latestEnd = earliestStart+maxDuration;
+ this.maxItems = maxItems;
+ this.itemCounter = 0;
+ this.infinite = maxDuration<=0;
+ calculateNextEventOccurrence();
+ }
+
+ // returns true if event source has no boundaries or all restrictions (i.e. a generation duration or max. number of event instances) are met, false otherwise
+ public boolean calculateNextEventOccurrence (){
+ this.event.setTimes(this.event.getEndTime()+myRandom.nextInt((int)this.evDeviation)+this.evMinDur);
+ if (maxItems <=0){
+ if (isInfinite())
+ return true;
+ else return event.getEndTime()<this.latestEnd;
+ }
+ else {
+ this.itemCounter++;
+ if (this.itemCounter>this.maxItems)
+ return false;
+ if (isInfinite())
+ return true;
+ else return (event.getEndTime()<this.latestEnd);
+ }
+ }
+
+ /**
+ * @return the infinite
+ */
+ private boolean isInfinite() {
+ return infinite;
+ }
+
+ /**
+ * @return the eventSenderId
+ */
+ public String getEventSenderId() {
+ return eventSenderId;
+ }
+
+ /**
+ * @return the time
+ */
+ public long getNextOccurrenceTime() {
+ return this.event.getEndTime();
+ }
+
+ /**
+ * @return the event
+ */
+ public Event getEvent() {
+ return event;
+ }
+
+}
+
+class EventGenerationTimeComparator implements Comparator<EventOccurrence>{
+
+ @Override
+ public int compare(EventOccurrence o1, EventOccurrence o2) {
+ return (int)(o1.getNextOccurrenceTime()-o2.getNextOccurrenceTime());
+ }
+
+}
Added: labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/SimpleEventGeneratorTest.java
===================================================================
--- labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/SimpleEventGeneratorTest.java (rev 0)
+++ labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/SimpleEventGeneratorTest.java 2007-12-04 16:29:14 UTC (rev 17019)
@@ -0,0 +1,168 @@
+package org.drools.integrationtests.eventgenerator;
+
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+import org.drools.RuleBase;
+import org.drools.RuleBaseFactory;
+import org.drools.WorkingMemory;
+import org.drools.compiler.DrlParser;
+import org.drools.compiler.DroolsParserException;
+import org.drools.compiler.PackageBuilder;
+import org.drools.integrationtests.eventgenerator.Event.EventType;
+import org.drools.lang.descr.PackageDescr;
+import org.drools.rule.Package;
+
+
+public class SimpleEventGeneratorTest extends TestCase {
+
+ private final static String TEST_RULE_FILE = "test_eventGenerator.drl";
+
+ protected RuleBase getRuleBase() throws Exception {
+
+ return RuleBaseFactory.newRuleBase( RuleBase.RETEOO,
+ null );
+ }
+
+ private RuleBase loadRuleBase(final Reader reader) throws IOException,
+ DroolsParserException,
+ Exception {
+ final DrlParser parser = new DrlParser();
+ final PackageDescr packageDescr = parser.parse( reader );
+ if ( parser.hasErrors() ) {
+ System.out.println( parser.getErrors() );
+ Assert.fail( "Error messages in parser, need to sort this our (or else collect error messages)" );
+ }
+ // pre build the package
+ final PackageBuilder builder = new PackageBuilder();
+ builder.addPackage( packageDescr );
+ final Package pkg = builder.getPackage();
+
+ // add the package to a rulebase
+ final RuleBase ruleBase = getRuleBase();
+ ruleBase.addPackage( pkg );
+ // load up the rulebase
+ return ruleBase;
+ }
+
+ public void testEventGenerationMaxItems() throws DroolsParserException, IOException, Exception{
+ final Reader reader = new InputStreamReader( getClass().getResourceAsStream( TEST_RULE_FILE ) );
+ final RuleBase ruleBase = loadRuleBase( reader );
+ final WorkingMemory wm = ruleBase.newStatefulSession();
+ final SimpleEventGenerator myGenerator;
+
+ // create unrestricted event generator
+ myGenerator = new SimpleEventGenerator(wm , new SimpleEventListener(wm));
+ // generate 10 events, starting from the session clock
+ myGenerator.addEventSource("Conveyor1", new Event(EventType.CUSTOM, null), PseudoSessionClock.timeInSeconds(4), PseudoSessionClock.timeInSeconds(6), 0, 10);
+ myGenerator.generate();
+ assertEquals(wm.getQueryResults("all inserted events").size(), 10);
+ }
+
+ public void testEventGenerationMaxTime() throws DroolsParserException, IOException, Exception{
+ final Reader reader = new InputStreamReader( getClass().getResourceAsStream( TEST_RULE_FILE ) );
+ final RuleBase ruleBase = loadRuleBase( reader );
+ final WorkingMemory wm = ruleBase.newStatefulSession();
+ final SimpleEventGenerator myGenerator;
+
+ // create unrestricted event generator
+ myGenerator = new SimpleEventGenerator(wm , new SimpleEventListener(wm));
+ // generate events for 1 min, starting from the session clock
+ myGenerator.addEventSource("Conveyor1", new Event(EventType.CUSTOM, null), PseudoSessionClock.timeInSeconds(4), PseudoSessionClock.timeInSeconds(6), PseudoSessionClock.timeInMinutes(1), 0);
+ myGenerator.generate();
+ assertEquals(wm.getQueryResults("all inserted events").size(), wm.getQueryResults("all inserted events with generation time < 1 min").size());
+ }
+
+ public void testEventGenerationMaxTimeAndMaxItems() throws DroolsParserException, IOException, Exception{
+ final Reader reader = new InputStreamReader( getClass().getResourceAsStream( TEST_RULE_FILE ) );
+ final RuleBase ruleBase = loadRuleBase( reader );
+ final WorkingMemory wm = ruleBase.newStatefulSession();
+ final SimpleEventGenerator myGenerator;
+
+ // create unrestricted event generator
+ myGenerator = new SimpleEventGenerator(wm , new SimpleEventListener(wm));
+ // generate at most 10 events not exceeding 1 min, starting from the session clock
+ myGenerator.addEventSource("Conveyor1", new Event(EventType.CUSTOM, null), PseudoSessionClock.timeInSeconds(4), PseudoSessionClock.timeInSeconds(6), PseudoSessionClock.timeInMinutes(1), 10);
+ myGenerator.generate();
+ assertEquals(wm.getQueryResults("all inserted events").size(), wm.getQueryResults("all inserted events with generation time < 1 min").size());
+ assertTrue(wm.getQueryResults("all inserted events with generation time < 1 min").size()<=10);
+ }
+
+ public void testEventGenerationDelayedMaxItems() throws DroolsParserException, IOException, Exception{
+ final Reader reader = new InputStreamReader( getClass().getResourceAsStream( TEST_RULE_FILE ) );
+ final RuleBase ruleBase = loadRuleBase( reader );
+ final WorkingMemory wm = ruleBase.newStatefulSession();
+ final SimpleEventGenerator myGenerator;
+
+ // create unrestricted event generator
+ myGenerator = new SimpleEventGenerator(wm , new SimpleEventListener(wm));
+ // generate 10 events, delayed by 2 minutes from start session clock
+ myGenerator.addDelayedEventSource("Conveyor1", new Event(EventType.CUSTOM, null), PseudoSessionClock.timeInSeconds(4), PseudoSessionClock.timeInSeconds(6), PseudoSessionClock.timeInMinutes(2), 0, 10);
+ myGenerator.generate();
+ assertEquals(wm.getQueryResults("all inserted events").size(), 10);
+ }
+
+ public void testEventGenerationDelayedMaxTime() throws DroolsParserException, IOException, Exception{
+ final Reader reader = new InputStreamReader( getClass().getResourceAsStream( TEST_RULE_FILE ) );
+ final RuleBase ruleBase = loadRuleBase( reader );
+ final WorkingMemory wm = ruleBase.newStatefulSession();
+ final SimpleEventGenerator myGenerator;
+
+ // create unrestricted event generator
+ myGenerator = new SimpleEventGenerator(wm , new SimpleEventListener(wm));
+ // generate events for 1 min, delayed by 2 minutes from start session clock
+ myGenerator.addDelayedEventSource("Conveyor1", new Event(EventType.CUSTOM, null), PseudoSessionClock.timeInSeconds(4), PseudoSessionClock.timeInSeconds(6), PseudoSessionClock.timeInMinutes(2), PseudoSessionClock.timeInMinutes(1), 0);
+ myGenerator.generate();
+ assertEquals(wm.getQueryResults("all inserted events").size(), wm.getQueryResults("all inserted events with 2 min < generation time < 3 min").size());
+ }
+
+ public void testEventGenerationDelayedMaxTimeAndMaxItems() throws DroolsParserException, IOException, Exception{
+ final Reader reader = new InputStreamReader( getClass().getResourceAsStream( TEST_RULE_FILE ) );
+ final RuleBase ruleBase = loadRuleBase( reader );
+ final WorkingMemory wm = ruleBase.newStatefulSession();
+ final SimpleEventGenerator myGenerator;
+
+ // create unrestricted event generator
+ myGenerator = new SimpleEventGenerator(wm , new SimpleEventListener(wm));
+ // generate at most 10 events not exceeding 1 min, delayed by 2 minutes from start session clock
+ myGenerator.addDelayedEventSource("Conveyor1", new Event(EventType.CUSTOM, null), PseudoSessionClock.timeInSeconds(4), PseudoSessionClock.timeInSeconds(6), PseudoSessionClock.timeInMinutes(2), PseudoSessionClock.timeInMinutes(1), 10);
+ myGenerator.generate();
+ assertEquals(wm.getQueryResults("all inserted events").size(), wm.getQueryResults("all inserted events with 2 min < generation time < 3 min").size());
+ assertTrue(wm.getQueryResults("all inserted events with 2 min < generation time < 3 min").size()<=10);
+ }
+
+ public void testEventGenerationGlobalMaxTime() throws DroolsParserException, IOException, Exception{
+ final Reader reader = new InputStreamReader( getClass().getResourceAsStream( TEST_RULE_FILE ) );
+ final RuleBase ruleBase = loadRuleBase( reader );
+ final WorkingMemory wm = ruleBase.newStatefulSession();
+ final SimpleEventGenerator myGenerator;
+
+ // create unrestricted event generator
+ myGenerator = new SimpleEventGenerator(wm , new SimpleEventListener(wm), PseudoSessionClock.timeInMinutes(1));
+ // generate events for 1 min, starting from the session clock
+ myGenerator.addEventSource("Conveyor1", new Event(EventType.CUSTOM, null), PseudoSessionClock.timeInSeconds(4), PseudoSessionClock.timeInSeconds(6), PseudoSessionClock.timeInMinutes(3), 0);
+ myGenerator.generate();
+ assertEquals(wm.getQueryResults("all inserted events").size(), wm.getQueryResults("all inserted events with generation time < 1 min").size());
+ }
+
+ public void testEventGenerationMultipleSources() throws DroolsParserException, IOException, Exception{
+ final Reader reader = new InputStreamReader( getClass().getResourceAsStream( TEST_RULE_FILE ) );
+ final RuleBase ruleBase = loadRuleBase( reader );
+ final WorkingMemory wm = ruleBase.newStatefulSession();
+ final SimpleEventGenerator myGenerator;
+
+ // create unrestricted event generator
+ myGenerator = new SimpleEventGenerator(wm , new SimpleEventListener(wm));
+ // generate 15 events with parent resource A and 20 events with parent resource B
+ myGenerator.addEventSource("Conveyor1", new Event(EventType.CUSTOM, "resA"), PseudoSessionClock.timeInSeconds(4), PseudoSessionClock.timeInSeconds(6), 0, 15);
+ myGenerator.addEventSource("Conveyor2", new Event(EventType.CUSTOM, "resB"), PseudoSessionClock.timeInSeconds(3), PseudoSessionClock.timeInSeconds(5), 0, 20);
+ myGenerator.generate();
+ assertEquals(wm.getQueryResults("all inserted events with parent resource A").size(), 15);
+ assertEquals(wm.getQueryResults("all inserted events with parent resource B").size(), 20);
+ }
+
+}
Added: labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/SimpleEventListener.java
===================================================================
--- labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/SimpleEventListener.java (rev 0)
+++ labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/java/org/drools/integrationtests/eventgenerator/SimpleEventListener.java 2007-12-04 16:29:14 UTC (rev 17019)
@@ -0,0 +1,28 @@
+/**
+ *
+ */
+package org.drools.integrationtests.eventgenerator;
+
+import org.drools.WorkingMemory;
+
+
+/**
+ * @author Matthias Groch
+ *
+ */
+public class SimpleEventListener extends AbstractEventListener {
+
+ public SimpleEventListener(WorkingMemory wm) {
+ super(wm);
+ // TODO Auto-generated constructor stub
+ }
+
+ /* (non-Javadoc)
+ * @see com.event.AbstractEventListener#generatedEventSent(com.event.Event)
+ */
+ @Override
+ public void generatedEventSent(Event e) {
+ addEventToWM(e);
+ }
+
+}
Added: labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/resources/org/drools/integrationtests/eventgenerator/test_eventGenerator.drl
===================================================================
--- labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/resources/org/drools/integrationtests/eventgenerator/test_eventGenerator.drl (rev 0)
+++ labs/jbossrules/branches/temporal_rete/drools-compiler/src/test/resources/org/drools/integrationtests/eventgenerator/test_eventGenerator.drl 2007-12-04 16:29:14 UTC (rev 17019)
@@ -0,0 +1,23 @@
+package com.test;
+
+import org.drools.integrationtests.eventgenerator.*;
+
+query "all inserted events"
+ Event()
+end
+
+query "all inserted events with generation time < 1 min"
+ Event(eval(endTime<PseudoSessionClock.timeInMinutes(1)))
+end
+
+query "all inserted events with 2 min < generation time < 3 min"
+ Event(eval (endTime>PseudoSessionClock.timeInMinutes(2)), eval(endTime<PseudoSessionClock.timeInMinutes(3)))
+end
+
+query "all inserted events with parent resource A"
+ Event(parentId=="resA")
+end
+
+query "all inserted events with parent resource B"
+ Event(parentId=="resB")
+end
\ No newline at end of file
More information about the jboss-svn-commits
mailing list