Added basic graph functionality as a first step towards simplifying the container...

[utils] / system / general / src / test / java / org / wamblee / system / core / Application.java

diff --git a/system/general/src/test/java/org/wamblee/system/core/Application.java b/system/general/src/test/java/org/wamblee/system/core/Application.java
index 938f2bd1d50e7e969d46e71d97b778f81a3573ee..5e771b326464676d3729ffed4d2be370ea21f6f2 100644 (file)
--- a/system/general/src/test/java/org/wamblee/system/core/Application.java
+++ b/system/general/src/test/java/org/wamblee/system/core/Application.java
@@ -24,18 +24,39 @@ import org.wamblee.system.core.RequiredInterface;
 import org.wamblee.test.EventTracker;
 
 public class Application extends AbstractComponent {
-       private static RequiredInterface[] required() {
+       public static RequiredInterface[] required(boolean aOptional, String aPrefix) {
                return
                new RequiredInterface[] { 
-                       new DefaultRequiredInterface("datasource", DataSource.class), 
-                       new DefaultRequiredInterface("integer", Integer.class)
+                       new DefaultRequiredInterface(aPrefix + "string", String.class, aOptional), 
+                       new DefaultRequiredInterface(aPrefix + "integer", Integer.class, aOptional)
        };
        }
+       
+       public static RequiredInterface[] required(boolean aOptional) {
+        return required(aOptional, "");
+    }
+    
 
        private EventTracker<String> _tracker;
+       private String _string; 
+       private Integer _integer;
+       private double _random; 
        
        public Application() {
-               super("application", new ProvidedInterface[0], required()); 
+           this("application");
+       }
+       
+       public Application(String aName) {
+           this(aName, "");
+    }
+       
+       public Application(String aName, String aPrefix) {
+        super(aName, new ProvidedInterface[0], required(false, aPrefix));
+        _random = Math.random();
+    }
+       
+       public Application(boolean aIsOptinal) { 
+               super("application", new ProvidedInterface[0], required(true, "")); 
        }
        
        public Application(EventTracker<String> aTracker) { 
@@ -44,13 +65,28 @@ public class Application extends AbstractComponent {
        }
 
        @Override
-       protected void doStart() {
-               track("start." + getName()); 
+       protected Object doStart(Scope aScope) {
+               track("start." + getName());
+               _string = aScope.getInterfaceImplementation(getRequiredInterfaces()[0].getProvider(), String.class);
+           _integer = aScope.getInterfaceImplementation(getRequiredInterfaces()[1].getProvider(), Integer.class);
+           return _random; 
+       }
+       
+       public String getString() {
+               return _string;
+       }
+       
+       public Integer getInteger() {
+               return _integer;
        }
        
        @Override
-       protected void doStop() {
-               track("stop." + getName());     
+       protected void doStop(Object aRuntime) {
+               track("stop." + getName());
+               if ( _random != (Double)aRuntime) { 
+                       throw new IllegalArgumentException("Wrong runtime: expected " + _random + " but got " +
+                                       aRuntime);
+               }
        }
        
        private void track(String aString) {