Home
   News
   About the project
   Language
   Compiler download
   Test suite
   Blog on the programming model
   Zonnon @ OCP Forum
   Collection of examples

TEST: 092-T22-T

category

status

Compilation and execution results for Windows (first) and Mono (second)
PASSED Compiler: 1.2.8.0
Date, time: 2010.08.06, 18:06
Compilation: SUCCESS
Execution: SUCCESS
PASSED Compiler: 1.2.8.0
Date, time: 2010.08.06, 22:22
Compilation: SUCCESS
Execution: SUCCESS
(0, 0) Assembly reference not resolved: System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a.

code

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
88  
89  
90  
91  
92  
93  
94  
95  
96  
97  
98  
99  
100  
101  
102  
103  
104  
105  
106  
107  
108  
109  
110  
111  
112  
113  
114  
115  
116  
117  
118  
119  
120  
121  
122  
123  
124  
125  
126  
127  
128  
129  
130  
131  
132  
133  
134  
135  
136  
137  
138  
139  
140  
141  
142  
143  
144  
145  
146  
147  
148  
149  
150  
151  
152  
153  
 (**   
  * 9. Concurrency-Activities-Protocols  
  * 9.2. Protocol-Controlled-and-Activities  
  *     Positive test: Complex example  
  *)  
 module {protected} Main;  
   
 protocol {public} SMTP = (  
      SMTP_SERVER_READY,           SERVICE_NOT_AVAILABLE,           HELO,   
      OK,                     MAIL_FROM,                RCPT_TO,   
      RCPT_REJECTED,               DATA,                     START_MAIL_INPUT,   
      END,                    QUIT,                     BYE,  LINE,  
      mail_from = MAIL_FROM string ?OK,  
      rcpt_to = RCPT_TO string ( ?OK | ?RCPT_REJECTED ),  
      msg_body = DATA ?START_MAIL_INPUT { LINE string ?OK } END ?OK,  
      session = HELO string ?OK  {mail_from rcpt_to {rcpt_to} msg_body},  
      se_end = QUIT ?BYE,  
      dialog = ?SMTP_SERVER_READY [session] se_end | ?SERVICE_NOT_AVAILABLE  
 );  
   
 type {publicrefprotected} MailServer = object  
   
 (* == SMTP Activity - session to client ============== *)  
  activity SendMail implements SMTP;  
  var request : SMTP; any_request : object;  
       mto, mtextline : string;  
  begin  
     writeln("server is activated");  
      return SMTP.SMTP_SERVER_READY;  
      writeln("server said HELO and waiting for request");  
      accept request;   
      if request = SMTP.HELO then (* If not HELO then request is QUIT *)  
           accept unused;   
           return SMTP.OK; (* Confirm that client is accepted *)  
           (* Sending a message *)  
           loop  
                accept request;  
                if request = SMTP.QUIT then exit end;  
                (* Protocol guarantees that request = SMTP.MAIL_FROM *)  
                accept unused; (* Sender e-mail *)  
                return SMTP.OK; (* Confirm that sender is accepted *)  
   
                (*** New mail - clearing recipients list ***)  
                accept request;  
                while request = SMTP.RCPT_TO do  
                     accept mto; (* One more recipient *)  
                     (* if  checking the recipient is  true then *)  
                     return SMTP.OK; (* Recipient accepted *)  
                          (* Adding mto to the rcpt list *)  
                     (*else  
                          return SMTP.RCPT_REJECTED (* Recipient rejected *)  
                     end; *)  
                     writeln("server approved ", mto);  
                     accept request  
                end; (* Request can be SMTP.DATA or SMTP.QUIT *)  
                  
                if request = SMTP.QUIT then exit end;  
                (* Protocol guarantees that request = SMTP.DATA *)  
                return SMTP.START_MAIL_INPUT;   
                accept request;  
                while request = SMTP.LINE do  
                          accept mtextline; (* One more text line  *)  
                          return SMTP.OK; writeln("server accepted ", mtextline);  
                          accept request;                           
                end; (* while *) (* any_request is SMTP.END *)  
                writeln("END was accepted. Reply with OK ");  
                (* Accept the message to delivery *)  
                return SMTP.OK  
                (* Putting the message to the queue *)  
           end (* loop *)  
      end;  
      return SMTP.BYE  
  end SendMail;  
   
 end MailServer;  
   
 type {publicref} MailClient = object  
 var {public}  
      server: MailServer;  
   
 procedure {public} Configure(server: MailServer);  
 begin  
      self.server := server;  
 end Configure;  
   
 procedure {public} SendMail;  
 var smtp: activity { SMTP };   
      answer: SMTP;   
      i: integer;  
 begin  
     writeln("client requests server");  
      smtp := new server.SendMail; (* new dialog with the server *)  
      writeln("client is waiting for greeting");  
      answer := smtp();   
      writeln("client received greeting");  
      if  answer = SMTP.SMTP_SERVER_READY  then  
           answer := smtp( SMTP.HELO, "www.roman.nnov.ru" );  
           if answer = SMTP.OK then  
                for (* each mail in outbox *) i := 1 to 1 do  
                     answer := smtp( SMTP.MAIL_FROM, "roman.mitin@inf.ethz.ch" );  
                     if answer = SMTP.OK then  
                          answer := smtp( SMTP.RCPT_TO, "zueff@inf.ethz.ch" );  
                          writeln("client recieved confiramtion of email");  
                          if answer = SMTP.OK then  
                               writeln("client sending data");  
                               answer := smtp( SMTP.DATA );  
                               writeln("client transfers text");  
                               if answer = SMTP.START_MAIL_INPUT then  
                                    answer := smtp( SMTP.LINE, "Hi!" );  
                                    answer := smtp( SMTP.LINE, "It works!" );  
                                    writeln("client is sending END");  
                                    answer := smtp( SMTP.END );  
                                    if answer = SMTP.OK then  
                                         writeln("client is sending QUIT");  
                                         answer := smtp( SMTP.QUIT );  
                                         if answer = SMTP.BYE then  
                                              (* Session closed *)  
                                         end  
                                    else (* Smth. has happened *)  
                                    end            
                               else (* No invitaion to input data *)  
                               end  
                          else (* Recipient has been rejected *)  
                          end  
                     else (* Sender has been rejected *)  
                     end  
                end (* for *)  
           else (* Host has been rejected *)  
           end  
      else (* Cant connect case *)  
      end  
 end SendMail;  
   
 procedure {public} Synchronize;  
 begin  
      SendMail;   
      (* Other syncronisation tasks such as GetMail *)  
 end Synchronize;  
   
 begin (* object MailClient *)  
        
 end MailClient;  
   
 var   
      server: MailServer;  
      client: MailClient;  
 begin  
      server := new MailServer;  
      client := new MailClient;  
      client.Configure( server );  
      client.Synchronize();  
      halt(1);  
 end Main.  

information

  • PASSED - overall positive decision about the test
  • NOT PASSED - overall negative decision about the test
  • SUCCESS - compilation / execution successful
  • ERROR - compilation failed with normal syntax or semantic error
  • ABORT - compilation failed because of an internal compiler error
  • NOT RUN - the test was not / not supposed to be executed
  • FAIL - execution failed
Copyright © 2010 ETH Zurich, Switzerland