globalResolver );

    }

    public StatelessSessionResult executeWithResults(Object[] array) {

        for ( int i = 0, length = array.length; i < length; i++ ) {

        }

        GlobalResolver globalResolver = null;

        if ( this.globalExporter != null ) {

            globalResolver = this.globalExporter.export( wm );

        }

                                               globalResolver );

    }

    public StatelessSessionResult executeWithResults(Collection collection) {

        for ( Iterator it = collection.iterator(); it.hasNext(); ) {

        }

        GlobalResolver globalResolver = null;

        if ( this.globalExporter != null ) {

            globalResolver = this.globalExporter.export( wm );

        }

    public static void readFactHandles(MarshallerReaderContext context,

                                       org.drools.core.marshalling.impl.ProtobufMessages.EntryPoint _ep,

                                       ObjectStore objectStore) throws IOException,

                                                               ClassNotFoundException {

        SessionEntryPoint entryPoint = context.wm.getEntryPoints().get( _ep.getEntryPointId() );

        // load the handles

        for ( ProtobufMessages.FactHandle _handle : _ep.getHandleList() ) {

            InternalFactHandle handle = readFactHandle( context,

    public static void readFactHandles( MarshallerReaderContext context,

            ObjectStore objectStore ) throws IOException,

            ClassNotFoundException {

        ObjectInputStream stream = context.stream;

        int size = stream.readInt();

        // load the handles

        InternalFactHandle[] handles = new InternalFactHandle[size];

        for (int i = 0; i < size; i++) {

            InternalFactHandle handle = readFactHandle( context );

            context.handles.put( handle.getId(),

                                 handle );

            handles[i] = handle;

            if (handle.getObject() != null) {

                objectStore.addHandle( handle,

                                       handle.getObject() );

            }

            readRightTuples( handle,

                             context );

        }

        readLeftTuples( context ); // object store

        if (stream.readBoolean()) {

            readLeftTuples( context ); // activation fact handles

        }

        // add handles to object type nodes

        for (InternalFactHandle factHandle : handles) {

            Object object = factHandle.getObject();

            EntryPoint ep = ( (InternalWorkingMemoryEntryPoint) factHandle.getEntryPoint() ).getEntryPoint();

            ObjectTypeConf typeConf = ( (InternalWorkingMemoryEntryPoint) factHandle.getEntryPoint() ).getObjectTypeConfigurationRegistry().getObjectTypeConf( ep,

                                                                                                                                                               object );

            ObjectTypeNode[] cachedNodes = typeConf.getObjectTypeNodes();

            for (int i = 0, length = cachedNodes.length; i < length; i++) {

                set.add( factHandle,

                         false );

            }

        }

    }

    public static Activation readActivation( MarshallerReaderContext context ) throws IOException {

        ObjectInputStream stream = context.stream;

        InternalRuleBase ruleBase = context.ruleBase;

        long activationNumber = stream.readLong();

        int pos = stream.readInt();

        LeftTuple leftTuple = context.terminalTupleMap.get( pos );

        int salience = stream.readInt();

        String pkgName = stream.readUTF();

        String ruleName = stream.readUTF();

        Package pkg = ruleBase.getPackage( pkgName );

        Rule rule = pkg.getRule( ruleName );

        RuleTerminalNode ruleTerminalNode = (RuleTerminalNode) leftTuple.getLeftTupleSink();

        PropagationContext pc = context.propagationContexts.get( stream.readLong() );

        AgendaItem activation;

        boolean scheduled = false;

        if (rule.getTimer() != null) {

            activation = new ScheduledAgendaItem( activationNumber,

                                                  leftTuple,

                                                  pc,

                                                  ruleTerminalNode );

            scheduled = true;

        } else {

            activation = new AgendaItem( activationNumber,

                                         leftTuple,

                                         salience,

                                         pc,

                                         ruleTerminalNode );

        }

        leftTuple.setObject( activation );

        if (stream.readBoolean()) {

            String activationGroupName = stream.readUTF();

        }

        boolean activated = stream.readBoolean();

        activation.setActivated( activated );

        if (stream.readBoolean()) {

            InternalFactHandle handle = context.handles.get( stream.readInt() );

            activation.setFactHandle( handle );

            handle.setObject( activation );

        }

        InternalAgendaGroup agendaGroup;

        if (rule.getAgendaGroup() == null || rule.getAgendaGroup().equals( "" ) ||

            rule.getAgendaGroup().equals( AgendaGroup.MAIN )) {

            // Is the Rule AgendaGroup undefined? If it is use MAIN,

            // which is added to the Agenda by default

        } else {

            // AgendaGroup is defined, so try and get the AgendaGroup

            // from the Agenda

        }

        activation.setAgendaGroup( agendaGroup );

        if (!scheduled && activated) {

            if (rule.getRuleFlowGroup() == null) {

                agendaGroup.add( activation );

            } else {

                rfg.addActivation( activation );

            }

        }

        throw new UnsupportedOperationException(); // MDP need to update as we now have a TMS per EntryPoint

        ksession.insert( bob );

        ksession.insert( mic );

        ksession.insert( mark );

        final InternalAgenda agenda = (InternalAgenda) ((AgendaImpl)ksession.getAgenda()).getAgenda();

        final AgendaGroup group1 = agenda.getAgendaGroup( "group1" );

        if ( phreak == RuleEngineOption.RETEOO ) {

            agenda.setFocus( group1 );

        public Boolean call() throws Exception {

            EntryPoint ep = ksession.getEntryPoint("EP" + index);

            ObjectTypeNode otn = ((NamedEntryPoint)ep).getEntryPointNode().getObjectTypeNodes().values().iterator().next();

            AlphaNode alpha = (AlphaNode)otn.getSinkPropagator().getSinks()[0];

            BetaNode beta = (BetaNode)alpha.getSinkPropagator().getSinks()[0];

            memory.getSegmentMemory();

            for (int i = 0; i < 100; i++) {

                Thread.sleep(RANDOM.nextInt(100));

                if (fh == null) {

        private void initPathMemories() {

            pathMemories = new PathMemory[3];

            NamedEntryPoint ep = (NamedEntryPoint)epManipulators[8].getEntryPoiny();

            ObjectTypeNode otn = ((NamedEntryPoint)ep).getEntryPointNode().getObjectTypeNodes().values().iterator().next();

            AlphaNode alpha = (AlphaNode)otn.getSinkPropagator().getSinks()[0];

            ObjectSink[] sinks = alpha.getSinkPropagator().getSinks();

            for (int i = 0; i < sinks.length; i++) {

                BetaNode beta = (BetaNode)sinks[i];

                RuleTerminalNode rtn = (RuleTerminalNode)beta.getSinkPropagator().getSinks()[0];

            }

        }

        KieSessionConfiguration conf = KnowledgeBaseFactory.newKnowledgeSessionConfiguration();

        conf.setOption( ClockTypeOption.get( "pseudo" ) );

        StatefulKnowledgeSession session = createKnowledgeSession(kbase, conf);

        SessionPseudoClock clock = (SessionPseudoClock) session.<SessionClock>getSessionClock();

        final List results = new ArrayList();

        session.setGlobal( "results",

                           results );

        StockTickInterface tick1 = new StockTick( 1,

                                                  "DROO",

                                                  50,

                                                  10000 );

        StockTickInterface tick2 = new StockTick( 2,

                                                  "ACME",

                                                  10,

                                                  10010 );

        StockTickInterface tick3 = new StockTick( 3,

                                                  "ACME",

                                                  10,

                                                  10100 );

        StockTickInterface tick4 = new StockTick( 4,

                                                  "DROO",

                                                  50,

                                                  11000 );

        assertEquals( 0,

        InternalFactHandle handle1 = (InternalFactHandle) session.insert( tick1 );

        clock.advanceTime( 10,

                           TimeUnit.SECONDS );

        assertEquals( 10000,

        InternalFactHandle handle2 = (InternalFactHandle) session.insert( tick2 );

        assertEquals( 0,

        clock.advanceTime( 15,

                           TimeUnit.SECONDS );

        assertEquals( 15000,

        clock.advanceTime( 15,

                           TimeUnit.SECONDS );

        assertEquals( 30000,

        InternalFactHandle handle3 = (InternalFactHandle) session.insert( tick3 );

        assertEquals( 0,

        clock.advanceTime( 20,

                           TimeUnit.SECONDS );

        InternalFactHandle handle4 = (InternalFactHandle) session.insert( tick4 );

        clock.advanceTime( 10,

                           TimeUnit.SECONDS );

        assertNotNull( handle1 );

        assertNotNull( handle2 );

        assertNotNull( handle3 );

        assertNotNull( handle4 );

        assertTrue( handle1.isEvent() );

        assertTrue( handle2.isEvent() );

        assertTrue( handle3.isEvent() );

        assertTrue( handle4.isEvent() );

        assertEquals( 10000,

        session.fireAllRules();

        assertEquals( 0,

        assertEquals( 2,

                      ((List) session.getGlobal( "results" )).size() );

    }

            List results = new ArrayList();

            wm.setGlobal( "results",

                          results );

            // how to initialize the clock?

            // how to configure the clock?

            SessionPseudoClock clock = (SessionPseudoClock) wm.getSessionClock();

            clock.advanceTime( 5,

                               TimeUnit.SECONDS ); // 5 seconds

            // there is no next job, so returns -1

            assertEquals( -1,

            wm.insert( new OrderEvent( "1",

                                       "customer A",

                                       70 ) );

            assertEquals( 0,

            // now, there is a next job in 30 seconds: expire the event

            assertEquals( 30000,

            wm.fireAllRules();

            assertEquals( 1,

                          results.size() );

            assertEquals( 70,

                          ((Number) results.get( 0 )).intValue() );

            // advance clock and assert new data

            clock.advanceTime( 10,

                               TimeUnit.SECONDS ); // 10 seconds

            // next job is in 20 seconds: expire the event

            assertEquals( 20000,

            wm.insert( new OrderEvent( "2",

                                       "customer A",

                                       60 ) );

            wm.fireAllRules();

            assertEquals( 2,

                          results.size() );

            assertEquals( 65,

                          ((Number) results.get( 1 )).intValue() );

            // advance clock and assert new data

            clock.advanceTime( 10,

                               TimeUnit.SECONDS ); // 10 seconds

            // next job is in 10 seconds: expire the event

            assertEquals( 10000,

            wm.insert( new OrderEvent( "3",

                                       "customer A",

                                       50 ) );

            wm.fireAllRules();

            assertEquals( 3,

                          results.size() );

            assertEquals( 60,

                          ((Number) results.get( 2 )).intValue() );

            // advance clock and assert new data

            clock.advanceTime( 10,

                               TimeUnit.SECONDS ); // 10 seconds

            // advancing clock time will cause events to expire

            assertEquals( 0,

            // next job is in 10 seconds: expire another event

            //assertEquals( 10000, iwm.getTimeToNextJob());

            wm.insert( new OrderEvent( "4",

                                       "customer A",

                                       25 ) );

            wm.fireAllRules();

            // first event should have expired, making average under the rule threshold, so no additional rule fire

            assertEquals( 3,

                          results.size() );

            // advance clock and assert new data

            clock.advanceTime( 10,

                               TimeUnit.SECONDS ); // 10 seconds

            wm.insert( new OrderEvent( "5",

                                       "customer A",

                                       70 ) );

            assertEquals( 0,

            //        wm  = SerializationHelper.serializeObject(wm);

            wm.fireAllRules();

            // still under the threshold, so no fire