@aj-shadow/actorjs-documentation-text 0.0.0-aj-beta.221

package/Documentation/abstractions/actor/Document-global-actor-proxy.txt

@@ -0,0 +1,119 @@
+# **Actor Proxy**
+
+## **Description**
+The [[REF=, ABS_Actor_Proxy]] does have client and server capabilities. It means that it can use both [[REF=, ABS_Stack_Client_Connection]]s and [[REF=, ABS_Stack_Server_Connection]]s which can can setup connections and communicate with servers and listen for connections and communicate with clients. The [[REF=, ABS_Actor_Proxy]] can be used in all [[REF=, ABS_Test_Case_Phases]].
+
+## **States**
+The [[REF=, ABS_Actor_Proxy]] supports the following [[REF=, ABS_Actor_State_Execution]]:
+* ***data**
+* ***initServer**
+* ***initClient**
+* ***run**
+* ***exit**
+
+```state
+Title: ActorProxy
+Config(width: 400, height: 200, widthBias: 25, heightBias: 25)
+
+States[data, initServer, initClient, run]
+States[, done, exit]
+
+data -> initServer[success]: success
+data -> done[failure]: error, failure, interrupt
+initServer -> initClient[success]: success
+initServer -> done[failure]: error, failure, interrupt
+initClient -> run[success]: success
+initClient -> done[failure]: error, failure, interrupt
+run -> exit[normal]: always
+exit -> done[normal]: always
+```
+
+## **Example 1 - Actor Proxy Wizard**
+Here is the code produced by the [[REF=, ABS_Actor_Proxy]] Wizard.
+```javascript
+
+const ActorApi = require('actor-api');
+
+
+class NotImplementedProxy extends ActorApi.ActorProxy {
+  constructor() {
+    super();
+    this.clientConnection = this.create();
+    this.serverConnection = this.create();
+  }
+  
+  *data() {
+  }
+  
+  *initServer() {
+    this.createServer('[stack]', this.serverConnection);
+  }
+  
+  *initClient() {
+    this.createConnection('[stack]', this.clientConnection);
+  }
+  
+  *run() {
+    this.serverConnection.accept();
+  }
+  
+  *exit() {
+    this.closeConnection(this.serverConnection);
+    this.closeConnection(this.clientConnection);
+  }
+}
+
+module.exports = NotImplementedProxy;
+
+```
+
+## **Example 2 - static http**
+This is a very simple example where the [[REF=, ABS_Actor]] listens for incoming connections and connects to a web server. When it gets an HTTP GET it proxies it to the outgoing connection. When it get an response it proxies it to the incoming connection.
+
+```javascript
+
+const ActorApi = require('actor-api');
+const HttpApi = require('http-stack-api');
+
+
+class StaticHttpActorProxy extends ActorApi.ActorProxy {
+  constructor() {
+    super();
+    this.clientConnection = this.create();
+    this.serverConnection = this.create();
+  }
+  
+  *data() {
+    this.requistUri = this.getTestDataString('Request-URI', '/demo');
+  }
+
+  *initServer() {
+    this.createServer('http', this.serverConnection);
+  }
+
+  *initClient() {
+    this.createConnection('http', this.clientConnection);
+  }
+  
+  *run() {
+    this.serverConnection .accept();
+    
+    const request = this.serverConnection .receive();
+    this.clientConnection.send(request );
+    
+    const response = this.clientConnection.receive();
+    VERIFY_VALUE(HttpApi.StatusCode.OK, response.statusCode, ' HTTP response line status code:');
+    VERIFY_CONTENT_OPTIONAL('content-name', response.getHeaderNumber(HttpApi.Header.CONTENT_LENGTH), response.getBody());
+
+    this.serverConnection.send(response ));
+  }
+  
+  *exit() {
+    this.closeConnection(this.serverConnection);
+    this.closeConnection(this.clientConnection);
+  }
+}
+
+module.exports = StaticHttpActorProxy;
+
+```

package/Documentation/abstractions/actor/Document-global-actor-terminating.txt

@@ -0,0 +1,101 @@
+# **Actor Terminating**
+
+## **Description**
+The [[REF=, ABS_Actor_Terminating]] does have server capabilities. It means that it can use [[REF=, ABS_Stack_Server_Connection]]s which can listen for connections and communicate with clients. The [[REF=, ABS_Actor_Terminating]] can be used in all [[REF=, ABS_Test_Case_Phases]].
+
+## **States**
+The [[REF=, ABS_Actor_Terminating]] supports the following [[REF=, ABS_Actor_State_Execution]]:
+* ***data**
+* ***initServer**
+* ***run**
+* ***exit**
+
+```state
+Title: ActorTerminating
+Config(width: 400, height: 200, widthBias: 25, heightBias: 25)
+
+States[data, initServer, run]
+States[, done, exit]
+
+data -> initServer[success]: success
+data -> done[failure]: error, failure, interrupt
+initServer -> run[success]: success
+initServer -> done[failure]: error, failure, interrupt
+run -> exit[normal]: always
+exit -> done[normal]: always
+```
+
+## **Example 1 - Actor Terminating Wizard**
+Here is the code produced by the [[REF=, ABS_Actor_Terminating]] Wizard.
+
+```javascript
+
+const ActorApi = require('actor-api');
+
+
+class NotImplementedTerm extends ActorApi.ActorTerminating {
+  constructor() {
+    super();
+    this.connection = this.create();
+  }
+  
+  *data() {
+  }
+    
+  *initServer() {
+    this.createServer('[stack]', this.connection);
+  }
+  
+  *run() {
+    this.connection.accept();
+  }
+  
+  *exit() {
+    this.closeConnection(this.connection);
+  }
+}
+
+module.exports = NotImplementedTerm;
+
+```
+
+## **Example 2 - static http**
+This is a very simple example where the [[REF=, ABS_Actor]] listens for incoming connections. It then receives an HTTP GET and sends a response with the status code 200.
+
+```javascript
+
+const ActorApi = require('actor-api');
+const HttpApi = require('http-stack-api');
+const HttpGet200OkResponse = require('./msg/HttpGet200OkResponse');
+
+
+class StaticHttpActorTerm extends ActorApi.ActorTerminating {
+  constructor() {
+    super();
+    this.httpConnection = this.create();
+    this.content = null;
+  }
+  
+  *data() {
+    this.content = this.getContent('content-name');
+  }
+  
+  *initServer() {
+    this.createServer('http', this.httpConnection);
+  }
+  
+  *run() {
+    this.httpConnection.accept();
+    
+    const request = this.httpConnection.receive();
+    this.httpConnection.send(new HttpGet200OkResponse(this.content));
+  }
+  
+  *exit() {
+    this.closeConnection(this.httpConnection);
+  }
+}
+
+module.exports = StaticHttpActorTerm;
+
+```

package/Documentation/abstractions/actor/Document-global-actor.txt

@@ -0,0 +1,90 @@
+# **Actor Abstraction**
+
+## **Description**  
+An [[REF=, ABS_Actor]] is the fundamental building block of ActorJs. [[REF=, ABS_Actor]]s are a small pieces of code that are executed in parallel or serial with other [[REF=, ABS_Actor]]s in a [[REF=, ABS_Test_Case]]. They acts instead of simulators, mocked up processes or real systems. The Actors will be reused in a lot of Test Cases. ActorJs starts, stops and interrupts [[REF=, ABS_Actor]]s depending on the data and the outcome of the [[REF=, ABS_Test_Case]].
+
+The [[REF=, ABS_Actor]] is 100% code, which gives the test developer full control. For maximal reuse and optimal maintenance, the [[REF=, ABS_Actor]]s has its own:
+* Logic
+* Flow
+
+ActorJs will provide the [[REF=, ABS_Actor]] with:
+* [[REF=Addresses, ABS_Addressing]]
+* [[REF=, ABS_Test_Data]]
+* [[REF=, ABS_Verification_Data]]
+
+A [[REF=, ABS_Test_Case]] contains [[REF=, ABS_Actor]]s to isolate the [[REF=, ABS_System_Under_Test]]. An [[REF=, ABS_Actor]] can be reused over and over again in different [[REF=, ABS_Test_Case]]s. It can change its behavior depending on [[REF=, ABS_Test_Data]].
+
+## **Actor Types**
+Thera are five different types of [[REF=, ABS_Actor]]s  with different characteristics.
+* [[REF=, ABS_Actor_Originating]]: which has client capabilities.
+* [[REF=, ABS_Actor_Terminating]]: which has server capabilities.
+* [[REF=, ABS_Actor_Proxy]]: which has client and server capabilities.
+* [[REF=, ABS_Actor_Local]]: which has not either client or server capabilities.
+* [[REF=, ABS_Actor_Condition]]: which has client capabilities. But it is executed in both the [[REF=, ABS_Test_Case_Phase_Precondition]] and the [[REF=, ABS_Test_Case_Phase_Postcondition]].
+
+[[EMBED=abstractions/actor/execution-states]]
+
+## **Example**
+We have a [[REF=, ABS_System_To_Test]]. It contains a Browser, a Proxy and a web-server.
+```node
+Config(nodeWidth: 70, nodeHeight: 70, nodeWidthBetween: 25, nodeHeightBetween: 50, widthBias: 30, heightBias: 30, border: true, backgroundColor: default)
+
+Nodes[Browser, , Proxy, , web-server]
+
+Groups[STT(0; 5; 0; 1)]
+
+Browser => Proxy[http]: http
+Proxy => web-server[http]: http
+```
+If we want to test the Proxy we'll define it as the [[REF=, ABS_System_Under_Test]]. Then we have to simulate the Browser and the web server with [[REF=, ABS_Actor]]s.
+```node
+Config(nodeWidth: 70, nodeHeight: 70, nodeWidthBetween: 25, nodeHeightBetween: 50, widthBias: 30, heightBias: 30, border: true, backgroundColor: default)
+
+Nodes[Browser, , Proxy, , web-server]
+
+Groups[Actor Orig(0; 1; 0; 1), SUT(2; 3; 0; 1), Actor Term(4; 5; 0; 1)]
+
+Browser => Proxy[http]: http
+Proxy => web-server[http]: http
+```
+We want to test when the Browser gets an image from the web-server via the Proxy. The Use Case looks like this:
+```seq
+Config(nodeWidth: 150, nodeMessageHeight: 17, nodeEventHeight: 10, nodeCommentHeight: 26, widthBias: 30, heightBias: 30, lineNumbers: false, border: true, backgroundColor: default)
+
+Nodes[Browser, Proxy, web-server]
+Browser => Proxy[http]: Get /image.png
+Proxy => web-server[http]: Get /image.png
+web-server => Proxy[http]: 200 OK
+Proxy => Browser[http]: 200 OK
+```
+To implement this Use Case we need:
+* a HTTP Stack
+* a HTTP get image request message
+* a HTTP get image response message
+
+When having them in place it is just to implement the [[REF=, ABS_Actor]]s.
+1) The Browser [[REF=, ABS_Actor]] sends a request and receives a response.
+2) The web-server [[REF=, ABS_Actor]] receives a request and sends a response.
+
+## **Implementation**
+Minimal code is needed to implement simple [[REF=, ABS_Actor]]s. We recommend that [[REF=, ABS_Actor]]s are kept simple and just implements the part of the flow in the Use Case. But of course an [[REF=, ABS_Actor]] can implement a whole simulator but then nothing is won compared to use of simulators.
+#### **Browser**
+```javascript
+
+*run() {
+  this.httpConnection.send(new HttpMsgGetRequest(this.requistUri));
+  const response = this.httpConnection.receive();
+}
+
+```
+#### **web-server**
+```javascript
+
+*run() {
+  this.httpConnection.accept();
+  const request = this.httpConnection.receive();
+  this.httpConnection.send(new HttpGet200OkResponse(this.content));
+}
+
+```
+

package/Documentation/abstractions/actor/Document-global-execution-states.txt

@@ -0,0 +1,21 @@
+## **Execution States**
+The methods to override when implementing an [[REF=, ABS_Actor]] are called execution states. It is because an [[REF=, ABS_Actor]] is a small state-machine and a method with the name of the new state, execution state, will be called when the [[REF=, ABS_Actor]] state changes:
+
+### **The execution states**
+* ***data**: in this state all [[REF=, ABS_Test_Data]] must be read. This state will be executed first for all [[REF=, ABS_Actor]]s independent of the execution parameter in the Actor table.
+* ***initServer**: in this state the [[REF=, ABS_Actor]]s with server capabilities can listen on incoming connections from clients. If it is done here ActorJs makes sure that the [[REF=, ABS_Actor]]s with client capabilities which is started at the same time will be called after the servers have started.
+* ***initClient**: in this state the [[REF=, ABS_Actor]]s with client capabilities can connect to servers. If it is done here ActorJs makes sure that the [[REF=, ABS_Actor]]s with server capabilities which is started at the same time will be called before.
+* ***run**: this state is the state where the actual test is suppost to be performed.
+* ***exit**: in this state the client and servers that are not already closed must be closed.
+
+### **Actor Condition execution states**
+The [[REF=, ABS_Actor_Condition]] is are a little bit special though it is executed in both the [[REF=, ABS_Test_Case_Phase_Precondition]] and in the [[REF=, ABS_Test_Case_Phase_Postcondition]]. There task is change the configuration of the [[REF=, ABS_System_Under_Test]] and restore the configuration afterwards.
+
+Another special case is that if an [[REF=, ABS_Actor_Condition]] have succeeded in the [[REF=, ABS_Test_Case_Phase_Precondition]] the [[REF=, ABS_Test_Case_Phase_Postcondition]] will always be executed even when we have a failure and other [[REF=, ABS_Actor]]s are interrupted. This is because we still have to restore the [[REF=, ABS_System_Under_Test]].
+* ***initClientPre**: same as initClient but it will always be executed in the [[REF=, ABS_Test_Case_Phase_Precondition]].
+* ***runPre**: same as run but it will always be executed in the [[REF=, ABS_Test_Case_Phase_Precondition]].
+* ***exitPre**: same as exit but it will always be executed in the [[REF=, ABS_Test_Case_Phase_Postcondition]].
+* ***initClientPost**: same as initClient but it will always be executed in the [[REF=, ABS_Test_Case_Phase_Precondition]].
+* ***runPost**: same as run but it will always be executed in the [[REF=, ABS_Test_Case_Phase_Postcondition]].
+* ***exitPost**: same as exit but it will always be executed in the [[REF=, ABS_Test_Case_Phase_Postcondition]].
+

package/Documentation/abstractions/actorpart/Document-global-actorpart.txt

@@ -0,0 +1,2 @@
+# **Actor Part Abstraction**
+## **Description**  

package/Documentation/abstractions/stack/Document-global-client-connection.txt

@@ -0,0 +1,3 @@
+# **Stack Client Connection** `TODO`
+
+## **Description**

package/Documentation/abstractions/stack/Document-global-connection.txt

@@ -0,0 +1,3 @@
+# **Stack Connection** `TODO`
+
+## **Description**

package/Documentation/abstractions/stack/Document-global-decoder.txt

@@ -0,0 +1,3 @@
+# **Stack Decoder**
+
+## **Description**

package/Documentation/abstractions/stack/Document-global-encoder.txt

@@ -0,0 +1,3 @@
+# **Stack Encoder** `TODO`
+
+## **Description**

package/Documentation/abstractions/stack/Document-global-message.txt

@@ -0,0 +1,4 @@
+# **Stack Message**
+
+## **Description**
+The [[REF=, ABS_Stack_Message]] object contains all data sent or received with Stack. It is just a [[REF=, MDN_object]] decided by the Stack owner. The [[REF=, ABS_Stack_Encoder]] and the [[REF=, ABS_Stack_Decoder]] are depending on the format of the [[REF=, ABS_Stack_Message]].

package/Documentation/abstractions/stack/Document-global-server-connection.txt

@@ -0,0 +1,3 @@
+# **Stack Server Connection** `TODO`
+
+## **Description**

package/Documentation/abstractions/stack/Document-global-stack.txt

@@ -0,0 +1,12 @@
+# **Stack Abstraction**
+## **Description**
+An implementation of a protocol is called a [[REF=, ABS_Stack]]. A [[REF=, ABS_Stack]] contains an [[REF=, ABS_Stack_Encoder]] and a [[REF=, ABS_Stack_Decoder]]. When testing we do not want the [[REF=, ABS_Stack]]s to timeout so no timers are implemented in the [[REF=, ABS_Stack]]s. When testing timeouts the implementation will be done in an [Actor](actors) to be able to test all scenarios without having to update a [[REF=, ABS_Stack]].
+
+## **Objects**
+There are six objects needed in most of the stacks to be able to implement them.
+* [ConnectionClient](client-connection)
+* [ConnectionServer](server-connection)
+* [Encoder](encoder)
+* [Decoder](decoder)
+* [Message](message)
+* [Worker](worker)

package/Documentation/abstractions/stack/Document-global-worker.txt

@@ -0,0 +1,3 @@
+# **Stack Worker** `TODO`
+
+## **Description**

package/Documentation/abstractions/test-case/Document-global-phases.txt

@@ -0,0 +1,30 @@
+## **Test Case Phases**
+A [[REF=, ABS_Test_Case]] is divided to three phases.
+
+* **precondition**: this phase is used to prepare the [[REF=, ABS_System_Under_Test]], if it is needed for the [[REF=, ABS_Test_Case]]. There can be a lot of things that it might to do before running the actual test:
+  * Change configuration on the [System Under Test](system-under-tests)
+  * Add, remove or change files on the [System Under Test](system-under-tests)
+  * Change data in the Database of the [System Under Test](system-under-tests)
+* **execution**: in this phase the actual test of the [[REF=, ABS_System_Under_Test]] is performed.
+* **postcondition**: this phase is used to restore the configuration of the [[REF=, ABS_System_Under_Test]] to the [[REF=, ABS_System_Configuration_Floor]], if it is changed in the precondition phase. Thas means that it must always be possible to run what ever [[REF=, ABS_Test_Case]] independent of which [[REF=, ABS_Test_Case]]s have been running before it.
+
+```seq
+Nodes[pre, post, orig, SUT, term]
+pre => SUT[unknown]: config
+orig => SUT[http]: Get /image
+SUT => term[http]: Get /image
+term => SUT[http]: 200 Ok
+SUT => orig[http]: 200 Ok
+post => SUT[unknown]: restore config
+```
+
+[[ANCHOR={"id":"execution-phase-postcondition","visible":true}]]
+### **Precondition Phase**
+
+
+[[ANCHOR={"id":"execution-phase-execution","visible":true}]]
+### **Execution Phase**
+
+
+[[ANCHOR={"id":"execution-phase-precondition","visible":true}]]
+### **Postcondition Phase**

package/Documentation/abstractions/test-case/Document-global-test-case-result.txt

@@ -0,0 +1,23 @@
+These are the possible execution results from an [[REF=, ABS_Actor_State]]:
+
+***Not Executed Result***
+* [[RESULT=none]] **none** value: **0**: Not executed so there are no result.
+
+***Success Results***
+* [[RESULT=n/a]] **n/a** value: **1**: Not Applicable, this [[REF=, ABS_Actor_State]] is not supported by this type of [[REF=, ABS_Actor]].
+* [[RESULT=n_impl]] **n_impl** value: **2**: Not Implemented, the [[REF=, ABS_Actor]] has not implemented this [[REF=, ABS_Actor_State]].
+* [[RESULT=success]] **success** value: **3**: Success, the result of the [[REF=, ABS_Actor_State]] is Success.
+
+***Failure Results***
+* [[RESULT=n_exec]] **n_exec** value: **4**: Not Executed, the [[REF=, ABS_Actor_State]] is not executed because some other [[REF=, ABS_Actor_State]] has returned a **Failure Result**.
+* [[RESULT=interrupt]] **interrupt** value: **5**: Interrupted, the [[REF=, ABS_Actor_State]] has been interrupted because some other [[REF=, ABS_Actor_State]] has returned a **Failure Result**.
+* [[RESULT=error]] **error** value: **6**: Error, ActorJs has catched an exception in the [[REF=, ABS_Actor_State]].
+* [[RESULT=failure]] **failure** value: **7**: Failure, A verification have failed in the [[REF=, ABS_Actor_State]].
+* [[RESULT=timeout]] **timeout** value: **8**: Timeout, the [[REF=, ABS_Actor_State]] has not completed its task in time.
+
+***Reflection Results***
+* ([[RESULT=reflection]] **reflection** value: **9**): If the [[REF=, ABS_Actor]] can not be created there will be no [[REF=, ABS_Actor_State]] result. Then the [[REF=, ABS_Actor]] will return **reflection** as its result.
+
+An [[REF=, ABS_Actor]] will get the result with the highest value returned from an one of its [[REF=, ABS_Actor_State]]s.
+A [[REF=, ABS_Test_Case]] will get the result with the highest value returned from one of its [[REF=, ABS_Actor]]s.
+A [[REF=, ABS_Test_Suite]] will get the result with the highest value returned from one of its [[REF=, ABS_Test_Case]]s.

package/Documentation/abstractions/test-case/Document-global-test-case.txt

@@ -0,0 +1,199 @@
+# **Test Case Abstraction**
+
+[[ANCHOR={"id":"6cf956b9-7c22-4271-bbc3-f47f7ddcc1d5","visible":true}]]
+[[NOTE={"guid":"dad57cec-1318-4676-8955-75d1b1d4926a"}]]
+## **Description**
+The general definition of what a Test Case is can be found at [[REF=, WIKI_Test_Case]].
+
+An ActorJs [[REF=, ABS_Test_Case]] is 100% data driven. The data to provide is:
+* [[REF=, ABS_Actor]]s
+* [[REF=, ABS_Test_Data]]
+* [[REF=, ABS_Verification_Data]]
+
+Even though a [[REF=, ABS_Test_Case]] is 100% data driven you still have 100% control of the code. The code is written as [[REF=, ABS_Actor]]s. It is the [[REF=, ABS_Actor]]s who decides what [[REF=, ABS_Test_Data]] and [[REF=, ABS_Verification_Data]] they need.
+
+[[EMBED=abstractions/test-case/phases]]
+
+[[ANCHOR={"id":"bfee328d-0855-4cfd-b13c-d785185f858b","visible":true}]]
+[[NOTE={"guid":"b70b4de2-daf0-4407-8321-aba957cbb98e"}]]
+## **Example**
+A [[REF=, ABS_System_Under_Test]], **Image Service**, delivers images to clients and converts the format of the images if needed.
+
+```node
+Config(nodeWidth: 90, nodeHeight: 35, nodeWidthBetween: 65, nodeHeightBetween: 25, widthBias: 30, heightBias: 30, border: true, backgroundColor: default)
+
+Nodes[, , Image Store]
+Nodes[Client, Image Service]
+Nodes[, , Image Converter]
+
+
+Client => Image Service[http]: http
+Image Service => Image Store[http]: http
+Image Service => Image Converter[icap]: icap
+```
+We can make a sequence diagram with the different parts of the example.
+```seq
+Title:      Getting and converting an image
+Config(nodeWidth: 150, nodeMessageHeight: 17, nodeEventHeight: 10, nodeCommentHeight: 26, widthBias: 30, heightBias: 30, lineNumbers: false, border: true, backgroundColor: default)
+
+Nodes[ClientOrig, SUT, ImageConverterTerm, ImageStoreTerm]
+ClientOrig => SUT[http]: GET /i.jpg
+SUT => ImageStoreTerm[http]: Get /i.jpg
+ImageStoreTerm => SUT[http]: 200 OK (gif)
+SUT => ImageConverterTerm[icap]: respmod(gif)
+ImageConverterTerm => SUT[icap]: 200 OK (jpg)
+SUT => ClientOrig[http]: 200 OK
+```
+___
+[[ANCHOR={"id":"118c6304-7a0d-43c8-af26-f05133156a1a","visible":true}]]
+[[NOTE={"guid":"cdebf447-4c25-4840-b02a-b3045ddd89c1"}]]
+### **Breaking Down**
+* The Image Service is the SUT that we will Test.
+* We know have to simulate the Client, the Image Store and the Image Converter.
+
+Without ActorJS this is `a very complex task`. We need three simulators or a combination of simulators and real systems. But with `real systems negative testing and other scenarios are almost impossible to perform`.
+
+[[IE=With ActorJs this is very simple]].
+
+___
+[[ANCHOR={"id":"df5cafb7-c0b6-49d7-aa68-fd235b33db6d","visible":true}]]
+[[NOTE={"guid":"cb5be92c-c873-4e93-94b3-9159b3e7bd55"}]]
+### **Creating the Actors**
+We will create three [[REF=, ABS_Actor]]s:
+* ***ClientOrig***: sends an http request and receive an http response.
+* ***ImageStoreTerm***: receives an http request and sends http response.
+* ***ImageConverterTerm***: receives an icap request and sends icap response.
+
+Usually the [[REF=, ABS_Actor]]s below contains little bit more code. To make them reusable and maintainable [[REF=, ABS_Test_Data]] and [[REF=, ABS_Verification_Data]] is used. We just wants to [[IE=explain how extremely simple]] it is to get the message flow to work. The [[REF=, ABS_Actor]]s are created in the [[REF=, TOOL_Actor_Editor]].
+[[ANCHOR={"id":"ace1dcf8-03cd-4757-b56e-b02363d6fccf","visible":true}]]
+[[NOTE={"guid":"c314cb2f-ff28-406b-ab19-1d5a2af85d8f"}]]
+### **ClientOrig**
+```javascript
+
+const ActorApi = require('actor-api');
+const HttpMsgGetImage= require('./msg/HttpMsgGetImage');
+
+
+class ClientOrig extends ActorApi.ActorOriginating {
+  constructor() {
+    super();
+    this.httpConnection = this.create();
+  }
+  
+  *initClient() {
+    this.createConnection('http', this.httpConnection);
+  }
+  
+  *run() {
+    this.httpConnection.send(new HttpMsgGetImage());
+    const response = this.httpConnection.receive();
+  }
+  
+  *exit() {
+    this.closeConnection(this.httpConnection);
+  }
+}
+```
+[[ANCHOR={"id":"3d257f98-db9e-4ee6-9876-f639d82878a5","visible":true}]]
+[[NOTE={"guid":"9107d3ba-ce82-448e-b34d-95453d389d41"}]]
+### **ImageStoreTerm**
+```javascript
+
+const ActorApi = require('actor-api');
+const HttpGet200OkResponse = require('./msg/HttpGet200OkResponse');
+
+
+class ImageStoreTerm extends ActorApi.ActorTerminating {
+  constructor() {
+    super();
+    this.httpConnection = this.create();
+  }
+  
+  *initServer() {
+    this.createServer('http', this.httpConnection);
+  }
+  
+  *run() {
+    this.httpConnection.accept();
+    const request = this.httpConnection.receive();
+    this.httpConnection.send(new HttpGet200OkResponse());
+  }
+  
+  *exit() {
+    this.closeConnection(this.httpConnection);
+  }
+}
+```
+[[ANCHOR={"id":"1c9df4ae-c852-4239-b780-259d804fb519","visible":true}]]
+[[NOTE={"guid":"b7190304-6c33-4884-8652-ba6a25f2cb93"}]]
+### **ImageConverterTerm**
+```javascript
+
+const ActorApi = require('actor-api');
+const IcapGet200OkResponse= require('./msg/IcapGet200OkResponse');
+
+
+class ImageConverterTerm extends ActorApi.ActorTerminating {
+  constructor() {
+    super();
+    this.icapConnection = this.create();
+  }
+  
+  *initServer() {
+    this.createServer('icap', this.icapConnection);
+  }
+  
+  *run() {
+    this.icapConnection.accept();
+    const request = this.icapConnection.receive();
+    this.icapConnection.send(new IcapGet200OkResponse());
+  }
+  
+  *exit() {
+    this.closeConnection(this.icapConnection);
+  }
+}
+```
+___
+[[ANCHOR={"id":"2efacc83-2b86-4b7a-b501-3393838d60aa","visible":true}]]
+[[NOTE={"guid":"cf7ddd87-6f6c-4554-9360-237d22e50072"}]]
+### **Creating a Test Case**
+[[ANCHOR={"id":"033dfe0d-d81e-41a6-922a-5ab5c7a44600","visible":true}]]
+[[NOTE={"guid":"9179d915-0cd1-4ee6-b7a4-e6e8dbe8db68"}]]
+#### **Table**
+To Create a [[REF=, ABS_Test_Case]] it is just to create a table with the [[REF=, ABS_Actor]]s and their addresses. In most real [[REF=, ABS_Test_Case]]s there will also be tables for [[REF=, ABS_Test_Data]] and [[REF=, ABS_Verification_Data]].
+```tc
+|Actor                                                                                                          |
+|name                                 |node|type|phase|execution|src      |dst        |srv|testData|verification|
+|Actors-global.demo.ClientOrig        |orig|exec|     |         |i_service|           |   |        |            |
+|Actors-global.demo.ImageStoreTerm    |term|exec|     |         |         |i_store    |   |        |            |
+|Actors-global.demo.ImageConverterTerm|term|exec|     |         |         |i_converter|   |        |            |
+|                                     |    |    |     |         |         |           |   |        |            |
+```
+[[ANCHOR={"id":"61705a37-25a2-4aab-83a5-3892ea2c11cd","visible":true}]]
+[[NOTE={"guid":"359224a6-3d7b-4825-9e3d-b2bcdcc44091"}]]
+#### **Markup**
+Editing the tables will be done in a markup text format. This means that they will be easy to store in a repo and it will be easy to merge them.
+```escape
+
+
+
+|Actor                                                                                                  |
+|name                                 |type|phase|execution|src|dst      |srv     |testData|verification|
+|Actors-global.demo.ClientOrig        |orig|exec |         |   |i_service|        |        |            |
+|Actors-global.demo.ImageStoreTerm    |term|exec |         |   |         |i_store |        |            |
+|Actors-global.demo.ImageConverterTerm|term|exec |         |   |         |i_store |        |            |
+```
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>

package/Documentation/actor-api/Document-global-actor-part.txt

@@ -0,0 +1,7 @@
+# **ActorPart API**
+[[API-STATUS=STABLE, ]]
+[[DOC-STATUS=NOT-YET, ]]
+
+[[NOTE={"guid":"07d866ab-5ca0-4839-b84f-d462aaf57e6b"}]]
+[[ANCHOR={"id":"cb3ec7cd-9356-4cf9-a86f-f2f29f59231a","visible":true}]]
+## **Description**