Changeset 96 for java/main/src/test


Ignore:
Timestamp:
07/04/13 20:29:50 (11 years ago)
Author:
psniegowski
Message:

HIGHLIGHTS:

  • cleanup Instance management
    • extract Instance interface
    • extract Instance common algorithms to InstanceUtils?
  • fix closing issues: Ctrl+C or window close button

properly shutdown whole program

by Java Framsticks framework

  • fix parsing and printing of all request types
  • hide exception passing in special handle method of closures
    • substantially improve readability of closures
    • basically enable use of exception in asynchronous closures

(thrown exception is transported back to the caller)

  • implement call request on both sides

CHANGELOG:
Further improve calling.

Improve instance calling.

Calling is working on both sides.

Improve exception handling in testing.

Waiters do not supercede other apllication exception being thrown.

Finished parsing and printing of all request types (with tests).

Move implementation and tests of request parsing to Request.

Add tests for Requests.

Improve waits in asynchronours tests.

Extract more algorithms to InstanceUtils?.

Extract Instance.resolve to InstanceUtils?.

Improve naming.

Improve passing exception in InstanceClient?.

Hide calling of passed functor in StateCallback?.

Hide Exception passing in asynchronous closures.

Hide exception passing in Future.

Make ResponseCallback? an abstract class.

Make Future an abstract class.

Minor change.

Move getPath to Path.to()

Move bindAccess to InstanceUtils?.

Extract common things to InstanceUtils?.

Fix synchronization bug in Connection.

Move resolve to InstanceUtils?.

Allow names of Joinable to be dynamic.

Add support for set request server side.

More fixes in communication.

Fix issues with parsing in connection.

Cut new line characters when reading.

More improvements.

Migrate closures to FramsticksException?.

Several changes.

Extract resolveAndFetch to InstanceUtils? algorithms.

Test resolving and fetching.

More fixes with function signature deduction.

Do not print default values in SimpleAbstractAccess?.

Add test of FramsClass? printing.

Improve FramsticksException? messages.

Add explicit dispatcher synchronization feature.

Rework assertions in tests.

Previous solution was not generic enough.

Allow addition of joinables to collection after start.

Extract SimulatorInstance? from RemoteInstance?.

Remove PrivateJoinableCollection?.

Improve connections.

Move shutdown hook to inside the Monitor.

It should work in TestNG tests, but it seems that
hooks are not called.

In ServerTest? client connects to testing server.

Move socket initialization to receiver thread.

Add proper closing on Ctrl+C (don't use signals).

Fix bugs with server accepting connections.

Merge Entity into Joinable.

Reworking ServerInstance?.

Extract more algorithm to InstanceUtils?.

Extract some common functionality from AbstractInstance?.

Functions were placed in InstanceUtils?.

Hide registry of Instance.

Use ValueParam? in Instance interface.

Minor change.

Extract Instance interface.

Old Instance is now AbstractInstance?.

Location:
java/main/src/test
Files:
11 added
1 deleted
12 edited

Legend:

Unmodified
Added
Removed

  • java/main/src/test/java/com/framsticks/core/FramsticksTest.java

    r88 r96  
    2020                Framsticks framsticks = Framsticks.loadConfiguration(stream);
    2121                assertThat(framsticks).isNotNull();
    22                 assertThat(framsticks.getObservables().size()).isEqualTo(1);
    23                 assertThat(framsticks.getObservables().get("browser")).isInstanceOf(Browser.class);
     22                assertThat(framsticks.size()).isEqualTo(1);
     23                assertThat(framsticks.get("browser")).isInstanceOf(Browser.class);
    2424        }
    2525

  • java/main/src/test/java/com/framsticks/core/ObjectInstanceTest.java

    r90 r96  
    1919import com.framsticks.params.ReflectionAccess;
    2020import com.framsticks.params.types.FloatParam;
     21
     22import static com.framsticks.core.InstanceUtils.*;
     23
    2124
    2225import static org.fest.assertions.Assertions.*;
    … …  
    4851        public void startInstance() {
    4952                instance = new ObjectInstance();
    50                 instance.getRegistry().takeAllFrom(schema.getRegistry());
     53                instance.takeAllFrom(schema.getRegistry());
    5154
    5255                instance.setRootObject(model);
    … …  
    6265                        })).isEqualTo("bla");
    6366
    64                 assertDispatch(instance, new RunAt<Instance>() {
     67                instance.dispatch(new RunAt<Instance>() {
    6568                        @Override
    6669                        public void run() {
    6770                                assertThat(instance.getRootObject(Model.class).getNeuroDefinitions().get(2).details).isEqualTo("G");
    6871
    69                                 Path path = instance.getPath("/");
     72                                Path path = Path.to(instance, "/");
    7073                                assertThat(path.isResolved());
    71                                 AccessInterface access = instance.bindAccess(path);
     74                                AccessInterface access = InstanceUtils.bindAccess(path);
    7275                                assertThat(access.get("se", Double.class)).isEqualTo(1.0);
    7376
    74                                 assertThat(instance.bindAccess("/parts/2").getFramsClass().getParamEntry("m", FloatParam.class).getDef(Double.class)).isEqualTo(1.0);
    75                                 assertThat(instance.bindAccess("/parts/2").getFramsClass().getParamEntry("m", FloatParam.class).getMax(Double.class)).isEqualTo(999.0);
    76                                 assertThat(instance.bindAccess("/parts/2")).isInstanceOf(ReflectionAccess.class);
    77                                 assertThat(instance.getPath("/neurodefs").getTopObject()).isInstanceOf(ArrayList.class);
    78                                 assertThat(instance.getPath("/joints/1").getTopObject()).isInstanceOf(Joint.class);
    79                                 assertThat(instance.bindAccess("/parts/2").get("i", String.class)).isEqualTo("bla");
     77                                assertThat(bindAccess(instance, "/parts/2").getFramsClass().getParamEntry("m", FloatParam.class).getDef(Double.class)).isEqualTo(1.0);
     78                                assertThat(bindAccess(instance, "/parts/2").getFramsClass().getParamEntry("m", FloatParam.class).getMax(Double.class)).isEqualTo(999.0);
     79                                assertThat(bindAccess(instance, "/parts/2")).isInstanceOf(ReflectionAccess.class);
     80                                assertThat(Path.to(instance, "/neurodefs").getTopObject()).isInstanceOf(ArrayList.class);
     81                                assertThat(Path.to(instance, "/joints/1").getTopObject()).isInstanceOf(Joint.class);
     82                                assertThat(bindAccess(instance, "/parts/2").get("i", String.class)).isEqualTo("bla");
    8083                        }
    8184                });

  • java/main/src/test/java/com/framsticks/gui/BrowserBaseTest.java

    r90 r96  
    99import org.fest.swing.fixture.FrameFixture;
    1010import org.fest.swing.fixture.JTreeFixture;
    11 import org.testng.annotations.AfterClass;
    12 import org.testng.annotations.BeforeClass;
    1311import org.testng.annotations.Test;
    1412
    15 import com.framsticks.test.TestConfiguration;
    16 import com.framsticks.util.dispatching.Monitor;
     13import com.framsticks.test.MonitorBasedTest;
     14import com.framsticks.util.dispatching.Joinable;
    1715
    1816import static org.fest.assertions.Assertions.assertThat;
    … …  
    2220
    2321@Test
    24 public abstract class BrowserBaseTest extends TestConfiguration {
     22public abstract class BrowserBaseTest extends MonitorBasedTest {
    2523
    2624        private static final Logger log = Logger.getLogger(BrowserTest.class);
    2725
    28         protected Monitor monitor;
    2926        protected Browser browser;
    3027        protected static Robot robot;
    … …  
    3936        }
    4037
    41         @BeforeClass(timeOut = 5000)
    42         public void setUp() {
     38        @Override
     39        protected Joinable createSubject() {
     40                configureBrowser();
     41                return browser;
     42        }
    4343
    44                 configureBrowser();
    45 
    46                 monitor = new Monitor(browser);
    47 
    48                 monitor.use();
    49 
     44        protected void setUpAfterUse() {
    5045                frame = new FrameFixture(robot,
    5146                                GuiActionRunner.execute(new GuiQuery<JFrame>() {
    … …  
    5752
    5853                tree = frame.tree("tree");
     54
    5955                log.debug("frame fixture done");
    6056        }
     57
    6158
    6259        protected abstract void configureBrowser();
    … …  
    7168        }
    7269
    73         @AfterClass(timeOut = 5000)
    74         public void tearDown() {
    75                 monitor.drop().join();
    76         }
    77 
    7870}

  • java/main/src/test/java/com/framsticks/gui/BrowserTest.java

    r90 r96  
    1010
    1111import com.framsticks.model.ModelPackage;
    12 import com.framsticks.remote.RemoteInstance;
     12import com.framsticks.remote.SimulatorInstance;
    1313
    1414public class BrowserTest extends BrowserBaseTest {
    … …  
    1616        private static final Logger log = Logger.getLogger(BrowserTest.class);
    1717
    18         RemoteInstance localhost;
     18        SimulatorInstance localhost;
    1919
    2020        @Override
    … …  
    2222                browser = new Browser();
    2323
    24                 localhost = new RemoteInstance();
     24                localhost = new SimulatorInstance();
    2525                localhost.setName("localhost");
    2626                localhost.setAddress("localhost:9009");

  • java/main/src/test/java/com/framsticks/gui/ObjectInstanceBrowserTest.java

    r90 r96  
    1111import com.framsticks.parsers.XmlLoader;
    1212import com.framsticks.util.dispatching.RunAt;
     13
     14import static com.framsticks.core.InstanceUtils.*;
    1315
    1416@Test
    … …  
    2931        @Test(timeOut = 10000)
    3032        public void testShow() {
    31                 assertDispatch(instance, new RunAt<Instance>() {
     33                instance.dispatch(new RunAt<Instance>() {
    3234                        @Override
    3335                        public void run() {
    … …  
    4042                clickAndExpandPath("model/parts/2");
    4143
    42                 assertDispatch(instance, new RunAt<Instance>() {
     44                instance.dispatch(new RunAt<Instance>() {
    4345                        @Override
    4446                        public void run() {
    45                                 assertThat(instance.bindAccess("/parts/2").getFramsClass().getParamEntry("m", FloatParam.class).getMax(Double.class)).isEqualTo(999.0);
     47                                assertThat(bindAccess(instance, "/parts/2").getFramsClass().getParamEntry("m", FloatParam.class).getMax(Double.class)).isEqualTo(999.0);
    4648                        }
    4749                });

  • java/main/src/test/java/com/framsticks/gui/ProcedureBrowserTest.java

    r90 r96  
    1616import com.framsticks.test.TestClass;
    1717import com.framsticks.util.dispatching.RunAt;
     18import static com.framsticks.core.InstanceUtils.*;
    1819
    1920@Test
    … …  
    3435        @Test(timeOut = 10000)
    3536        public void testShow() {
    36                 assertDispatch(instance, new RunAt<Instance>() {
     37                instance.dispatch(new RunAt<Instance>() {
    3738                        @Override
    3839                        public void run() {
    … …  
    4344                clickAndExpandPath("test");
    4445
    45                 assertDispatch(instance, new RunAt<Instance>() {
     46                instance.dispatch(new RunAt<Instance>() {
    4647                        @Override
    4748                        public void run() {
    48                                 assertThat(instance.bindAccess("/").getFramsClass().getParam("history")).isInstanceOf(StringParam.class);
     49                                assertThat(bindAccess(instance, "/").getFramsClass().getParam("history")).isInstanceOf(StringParam.class);
    4950                        }
    5051                });
    … …  
    5253                // monitor.useFor(4.0);
    5354
    54                 assertDispatch(instance, new RunAt<Instance>() {
     55                instance.dispatch(new RunAt<Instance>() {
    5556                        @Override
    5657                        public void run() {
    57                                 AccessInterface access = instance.bindAccess("/");
     58                                AccessInterface access = bindAccess(instance, "/");
    5859                                assertThat(access).isInstanceOf(ReflectionAccess.class);
    5960                                FramsClass framsClass = access.getFramsClass();
    … …  
    7475                waitForIdle();
    7576
    76                 assertDispatch(instance, new RunAt<Instance>() {
     77                instance.dispatch(new RunAt<Instance>() {
    7778                        @Override
    7879                        public void run() {
    79                                 assertThat(instance.bindAccess("/").get("history", String.class)).isEqualTo("argument|");
     80                                assertThat(bindAccess(instance, "/").get("history", String.class)).isEqualTo("argument|");
    8081                        }
    8182                });
    … …  
    8485                waitForIdle();
    8586
    86                 assertDispatch(instance, new RunAt<Instance>() {
     87                instance.dispatch(new RunAt<Instance>() {
    8788                        @Override
    8889                        public void run() {
    89                                 assertThat(instance.bindAccess("/").get("history", String.class)).isEqualTo("");
     90                                assertThat(bindAccess(instance, "/").get("history", String.class)).isEqualTo("");
    9091                        }
    9192                });

  • java/main/src/test/java/com/framsticks/params/FramsClassBuilderTest.java

    r90 r96  
    11package com.framsticks.params;
    22
     3import java.util.Arrays;
    34
    45import org.testng.annotations.BeforeClass;
    … …  
    78import com.framsticks.params.types.ProcedureParam;
    89import com.framsticks.params.types.StringParam;
     10import com.framsticks.parsers.Savers;
    911import com.framsticks.test.TestClass;
    1012import com.framsticks.test.TestConfiguration;
    … …  
    1719        ReflectionAccess access;
    1820        TestClass test;
    19 
    2021
    2122        @BeforeClass
    … …  
    3637                assertThat(framsClass.getParam("appendHistory")).isInstanceOf(ProcedureParam.class);
    3738                assertThat(framsClass.getParam("resetHistory")).isInstanceOf(ProcedureParam.class);
     39
    3840                ProcedureParam appendHistory = framsClass.getParamEntry("appendHistory", ProcedureParam.class);
    3941                assertThat(appendHistory.getArgumentsType().size()).isEqualTo(1);
    … …  
    4244
    4345        @Test(dependsOnMethods = "checkProcedureParams")
     46        public void print() {
     47                assertThat(Savers.saveFramsClass(new ListSink(), framsClass).getOut()).isEqualTo(
     48                                Arrays.asList(
     49                                        "class:",
     50                                        "name:TestClass",
     51                                        "id:TestClass",
     52                                        "",
     53                                        "prop:",
     54                                        "id:name",
     55                                        "name:Name",
     56                                        "type:s",
     57                                        "",
     58                                        "prop:",
     59                                        "id:history",
     60                                        "name:History",
     61                                        "type:s",
     62                                        "",
     63                                        "prop:",
     64                                        "id:appendHistory",
     65                                        "name:AppendHistory",
     66                                        "type:p d(s arg0)",
     67                                        "",
     68                                        "prop:",
     69                                        "id:resetHistory",
     70                                        "name:ResetHistory",
     71                                        "type:p()",
     72                                        ""
     73                                )
     74                        );
     75        }
     76
     77
     78        @Test(dependsOnMethods = "print")
    4479        public void callProcedures() {
    4580                access = new ReflectionAccess(TestClass.class, framsClass);

  • java/main/src/test/java/com/framsticks/params/ParamBuilderTest.java

    r88 r96  
    2323                assertThat(builderFramsClass.getName()).isEqualTo("prop");
    2424                assertThat(builderFramsClass.getId()).isEqualTo("prop");
     25                assertThat(builderFramsClass.getParamEntry("flags", ValueParam.class).getDef(Object.class)).isEqualTo(new Integer(0));
    2526                assertThat(builderFramsClass.getParamEntry("id", Param.class)).isInstanceOf(StringParam.class);
    2627        }

  • java/main/src/test/java/com/framsticks/running/FramsServerTest.java

    r90 r96  
    33import org.testng.annotations.Test;
    44
    5 import com.framsticks.core.Framsticks;
    6 import com.framsticks.test.TestConfiguration;
    7 import com.framsticks.util.dispatching.Monitor;
     5import com.framsticks.core.XmlBasedTest;
    86
    97import static org.fest.assertions.Assertions.*;
    108
    119@Test
    12 public class FramsServerTest extends TestConfiguration {
     10public class FramsServerTest extends XmlBasedTest {
     11
     12        @Override
     13        protected String getConfigurationName() {
     14                return "FramsServerTest.xml";
     15        }
    1316
    1417        @Test(timeOut = 3000)
    1518        public void runServer() {
    16                 Framsticks framsticks = Framsticks.loadConfiguration(FramsServerTest.class.getResourceAsStream("/configs/FramsServerTest.xml"));
     19                assertThat(framsticks.size()).isEqualTo(1);
     20                assertThat(framsticks.get("frams")).isInstanceOf(FramsServer.class);
    1721
    18                 assertThat(framsticks.getObservables().size()).isEqualTo(1);
    19                 assertThat(framsticks.getObservables().get("frams")).isInstanceOf(FramsServer.class);
    20                 // assertThat(framsticks.getObservables().get("remote")).isInstanceOf(RemoteInstance.class);
    21 
    22                 new Monitor(framsticks).use().useFor(1.0).drop().join();
    23 
    24                 // monitor.use();
    25 
    26                 // Dispatching.sleep(1000);
    27 
    28                 // // monitor.waitFor();
    29                 // monitor.drop();
    30                 // monitor.join();
    31 
    32                 // framsticks.start();
    33 
    34                 // framsticks.waitForObservables();
    35 
     22                monitor.useFor(1.0);
    3623        }
    3724
     25
    3826}

  • java/main/src/test/java/com/framsticks/test/TestConfiguration.java

    r90 r96  
    11package com.framsticks.test;
    22
     3import java.util.HashSet;
    34import java.util.LinkedList;
    45import java.util.List;
     6import java.util.Set;
    57
    68import org.apache.log4j.Logger;
    … …  
    810import org.testng.annotations.*;
    911
     12import com.framsticks.util.FramsticksException;
    1013import com.framsticks.util.dispatching.Dispatcher;
    11 import com.framsticks.util.dispatching.RunAt;
     14import com.framsticks.util.dispatching.Dispatching;
     15import com.framsticks.util.dispatching.Dispatching.Waiter;
     16import com.framsticks.util.dispatching.ExceptionHandler;
     17import com.framsticks.util.dispatching.ExceptionResultHandler;
     18
     19import static org.fest.assertions.Assertions.*;
    1220
    1321public class TestConfiguration {
    … …  
    2129        }
    2230
    23         private final List<AsyncAssert<?>> asyncAssertions = new LinkedList<AsyncAssert<?>>();
     31        private final List<AssertionError> asyncAssertions = new LinkedList<>();
    2432
    25         public class AsyncAssert<C> extends RunAt<C> {
    26                 final RunAt<? extends C> runnable;
    27                 boolean done = false;
    28                 AssertionError assertion;
     33        public ExceptionHandler createExceptionHandler() {
     34                return new ExceptionHandler() {
     35                        @Override
     36                        public boolean handle(Dispatcher<?> dispatcher, Throwable throwable) {
     37                                AssertionError ae;
     38                                if (AssertionError.class.isInstance(throwable)) {
     39                                        ae = AssertionError.class.cast(throwable);
     40                                } else {
     41                                        ae = new AssertionError();
     42                                        ae.initCause(throwable);
     43                                }
     44                                synchronized (asyncAssertions) {
     45                                        asyncAssertions.add(ae);
     46                                }
     47                                return true;
     48                        }
     49                };
     50        }
    2951
    30                 /**
    31                  * @param runnable
    32                  */
    33                 public AsyncAssert(RunAt<? extends C> runnable) {
    34                         this.runnable = runnable;
    35                 }
    36 
    37                 @Override
    38                 public void run() {
     52        @AfterMethod
     53        public void waitForWaiters() {
     54                for (Waiter w : waiters) {
    3955                        try {
    40                                 runnable.run();
    41                         } catch (AssertionError e) {
    42                                 assertion = e;
    43                         }
    44                         synchronized (this) {
    45                                 done = true;
    46                                 this.notifyAll();
     56                                w.waitFor();
     57                        } catch (FramsticksException e) {
     58                                AssertionError ae = new AssertionError();
     59                                ae.initCause(e);
     60                                asyncAssertions.add(ae);
    4761                        }
    4862                }
    4963        }
    5064
    51         public <C> void assertDispatch(Dispatcher<C> dispatcher, RunAt<? extends C> runnable) {
    52                 AsyncAssert<C> assertion = new AsyncAssert<C>(runnable);
     65        @AfterMethod(timeOut = 1000, dependsOnMethods = "waitForWaiters")
     66        public void processAsyncAssertions() {
    5367                synchronized (asyncAssertions) {
    54                         asyncAssertions.add(assertion);
    55                 }
    56                 dispatcher.dispatch(assertion);
    57         }
    58 
    59         @BeforeMethod
    60         public void clearAsyncAsserts() {
    61                 synchronized (asyncAssertions) {
    62                         asyncAssertions.clear();
     68                        if (asyncAssertions.isEmpty()) {
     69                                return;
     70                        }
     71                        AssertionError a = asyncAssertions.get(0);
     72                        asyncAssertions.remove(0);
     73                        throw a;
    6374                }
    6475        }
    6576
    66         @AfterMethod(timeOut = 5000)
    67         public void waitForAsyncAsserts() {
    68                 while (true) {
    69                         AsyncAssert<?> assertion;
    70                         synchronized (asyncAssertions) {
    71                                 if (asyncAssertions.isEmpty()) {
    72                                         return;
    73                                 }
    74                                 assertion = asyncAssertions.get(0);
    75                                 asyncAssertions.remove(0);
     77        final Set<Waiter> waiters = new HashSet<>();
     78
     79        @BeforeMethod
     80        public void clearWaiters() {
     81                waiters.clear();
     82        }
     83
     84        protected Dispatching.Waiter produceWaiter(double timeOut) {
     85                Waiter waiter = new Waiter(timeOut);
     86                waiters.add(waiter);
     87                return waiter;
     88        }
     89
     90        public static ExceptionResultHandler failOnException() {
     91                return new ExceptionResultHandler() {
     92                        @Override
     93                        public void handle(FramsticksException e) {
     94                                assertThat(e).isNull();
    7695                        }
    77                         synchronized (assertion) {
    78                                 while (!assertion.done) {
    79                                         try {
    80                                                 assertion.wait();
    81                                         } catch (InterruptedException ignored) {
    82                                         }
    83                                 }
    84                                 if (assertion.assertion != null) {
    85                                         throw assertion.assertion;
    86                                 }
    87                         }
    88                 }
     96                };
     97
    8998        }
    9099}

  • java/main/src/test/resources/configs/test.xml

    r88 r96  
    22<Framsticks>
    33        <import class="com.framsticks.gui.Browser" />
    4         <import class="com.framsticks.remote.RemoteInstance" />
     4        <import class="com.framsticks.remote.SimulatorInstance" />
    55        <Browser name="browser">
    6                 <RemoteInstance name="localhost:9009" address="localhost:9009" />
     6                <SimulatorInstance name="localhost:9009" address="localhost:9009" />
    77        </Browser>
    88</Framsticks>

  • java/main/src/test/resources/log4j.properties

    r90 r96  
    2727
    2828log4j.logger.com.framsticks=INFO
     29# log4j.logger.com.framsticks.hosting.Server=DEBUG
     30# log4j.logger.com.framsticks.communication.ServerConnection=TRACE
     31# log4j.logger.com.framsticks.util.dispatching.AbstractJoinable=DEBUG
    2932# log4j.logger.com.framsticks.parsers.F0Writer=TRACE
    3033# log4j.logger.com.framsticks.core.ObjectInstance=DEBUG
Note: See TracChangeset for help on using the changeset viewer.