module InresExample1 ( ISDUType TestsuitePar ) {


  /* *** General Type Definitions *** */
  type integer ISDUType (-infinity .. infinity);
  type enumerated Sequencenumber { zero(1), one(2) };
  type enumerated IPDUType { CR(1), CC(2), DR(3), DT(4), AK(5) };


  /* *** Module Constants *** */
  const Sequencenumber TestSuiteConst := one;


  /* *** Configuration Definitions *** */
  group ConfigurationDefinitions {


    /* *** Port Type Definitions *** */
    type port PCO_Type1 message {
      in ICONconf, IDISind;	/* received from SUT */
      out ICONconf, IDATreq, IDISreq; /* send to SUT */
    } with { display "PCO Type, role := UT"; }

    type port PCO_Type2 message {
      in MDATind;		/* received from SUT */
      out MDATreq;		/* send to SUT */
    } with { display "PCO Type, role = LT"; }


    /* *** MTC Type Definition (is equal to Test System Interface) *** */
    type component MTCType {
      port PCO_Type1 ISAP1;
      port PCO_Type2 MSAP2;
    };

  } /* End ConfigurationDefinitions */


  /* *** ASP Type Definitions for Medium Interface */
  group MediumServiceASPTypes {

    type record MDATreq {
      IPDUType iPDUType1,
	Sequencenumber sequencenumber2,
	ISDUType iSDUType3
	};

    type record MDATind {
      IPDUType iPDUType1,
	Sequencenumber sequencenumber2,
	ISDUType iSDUType3
	};

  } with { display "ASP Type Definitions"; } /* End MediumServiceASPTypes */


  /* *** ASP Type Definitions for Inres Interface (Initiator side) *** */
  group InitiatorSideInresASPTypes {

    type record ICONreq {};
    type record IDATreq { ISDUType iSDUType1 };
    type record IDISreq {};
    type record ICONconf {};
    type record IDISind {};

  } with { display "ASP Type Definitions"; } /* End InitiatorSideInresASPTypes */


  /* *** Template Definitions *** */
  group TemplateDefinitions {

    template IDATreq DataRequest (ISDUType Par1) := { iSDUType1 := Par1 };

    template MDATreq Medium_Connection_Confirmation := {
      iPDUType1 := CC,
      sequencenumber2 := ?,
      iSDUType3 := ?
    };

    template MDATind Medium_Connection_Request := {
      iPDUType1 := CR,
      sequencenumber2 := ?,
      iSDUType3 := ?
    };

    template MDATind Medium_Data_Transfer := {
      iPDUType1 := DT,
      sequencenumber2 := TestSuiteConst,
      iSDUType3 := TestSuitePar
    };

    template MDATind Medium_Disconnection_Request := {
      iPDUType1 := DR,
      sequencenumber2 := ?,
      iSDUType3 := ?
    };

    template MDATreq cmi_synch1 := {
      iPDUType1 := AK,
      sequencenumber2 := one,
      iSDUType3 := 55
    };

  } /* End TemplateDefinitions */

  /* ** test step used as default for the following test cases *** */
  teststep OtherwiseFail() {
  []	ISAP1.receive {
    verdict.set(fail);
    stop;
  }
  []	MSAP2.receive {
    verdict.set(fail);
    stop;
  }
  } with { display "default"; }

  /* ** Test step **/

  teststep ReceiveIDISind (verdicttype result) { 
  []	ISAP1.receive( IDISind : { } ) {
    verdict.set(result);
  }
  } with { display "test step"; } /* End ReceiveIDISind */


  /* The following TTCN-3 test case is a one-to-one translation of the
     test case mi_synch1 in the example test suite, it is not the
     optimal way to 'program' TTCN-3, but shows at least how the
     result of a direct translation or TTCN-2 test cases into TTCN-3
     test cases may look. */

  group Transmission { 
    group MultileInstances { 
      group SystemLevelMSC {
	/* The nested grouping is only done to be 100% consistent with
           the original TTCN2 testsuite */

	testcase mi_synch1 () runs on MTCType {

	  var default def := activate(OtherwiseFail()); /* Default activation */
	  ISAP1.send( ICONreq:{} ); /* Inline template definition */
	  alt {
	  [] MSAP2.receive( Medium_Connection_Request() ) { /* use of a template */
	    
	    MSAP2.send( MDATreq:Medium_Connection_Confirmation() ); /*optional template type*/
	    alt {
	    [] ISAP1.receive ( ICONconf:{} ) {
	      ISAP1.send ( Data_Request(TestSuitePar) );
	      alt {
	      [] MSAP2.receive ( Medium_Data_Transfer() ) {
		MSAP2.send ( MDATreq:cmi_synch1() );
		ISAP1.send ( IDISreq:{} );
		alt {
		[] ISAP1.receive (IDISind:{} ) {
		  MSAP2.receive (Medium_Disconnection_Request() );
		  verdict.set(pass);
		  stop;
		}
		[] MSAP2.receive ( Medium_Disconnection_Request() ) {
		  ISAP1.receive( IDISind:{} );
		  verdict.set(pass);
		  stop;
		}
		[] MSAP2.receive ( Medium_Data_Transfer() ) {
		  verdict.set(inconclusive);
		  stop;
		}
		}
	      }
	      [] ISAP1.receive( IDISind:{} ) {
		verdict.set(inconclusive);
		stop;
	      }
	      }
	    }
	    [] MSAP2.receive( MDATind:Medium_Connection_Request()) {
	      verdict.set(inconclusive);
	      stop;
	    }
	    [] ISAP1.receive( IDISind:{} ) {
	      verdict.set(inconclusive);
	      stop;
	    }
	    }
	  }
	  [] ISAP1.receive( IDISind:{} ) {
	    verdict.set(inconclusive);
	    stop;
	  }
	  }
	} /* End testcase mi_synch1 */

      } 
    } 
  } /* End groups SystemLevelMSC, MultipleInstances and Transmission */

  /* Although this one-to-one translation looks a little bit clumsy,
     it is 'readable' which is a great advantage compared to the
     TTCN2/MP Form. */

  /* This is a slight transformation of the previous example. It makes
     use of the 'sequential' character of TTCN-3. The stop operation
     is not copied to all branches of the 'behaviour tree'. Instead it
     is only executed at the end of the test case. Furthermore, the
     verdict is initialized with the verdict pass. During the test
     execution it can be overwritten by inconclusive or, in the
     default, by fail. The places where a pass has been assigned
     before are indicated by comments. The result looks much more
     readable, maybe because lots of the curly parenthesis have been
     deleted. */

  testcase mi_synch2 () runs on MTCType {

    var default def := activate(OtherwiseFail()); /* Default activation */
    ISAP1.send( ICONreq:{} );
    verdict.set(pass);
    alt {
    [] MSAP2.receive( Medium_Connection_Request() ) {
      MSAP2.send ( MDATreq:Medium_Connection_Confirmation() );
      alt {
      [] ISAP1.receive ( ICONconf:{} ) {
	ISAP1.send ( Data_Request(TestSuitePar) );
	alt {
	[] MSAP2.receive ( Medium_Data_Transfer() ) {
	  MSAP2.send ( MDATreq:cmi_synch1() );
	  ISAP1.send ( IDISreq:{} );
	  alt {
	  [] ISAP1.receive (IDISind:{} ) { /* PASS */
	    MSAP2.receive ( Medium_Disconnection_Request() );	
	  }
	  [] MSAP2.receive ( Medium_Disconnection_Request() ) {
	    ISAP1.receive( IDISind:{} ); /* PASS */
	  }
	  [] MSAP2.receive ( Medium_Data_Transfer() ) {
	    verdict.set(inconclusive);
	  }
	  }
	}
	[] ISAP1.receive( IDISind:{} ) {
	  verdict.set(inconclusive);
	}
	}
      }
      [] MSAP2.receive( MDATind:Medium_Connection_Request()) {
	verdict.set(inconclusive);
      }
      [] ISAP1.receive( IDISind:{} ) {
	verdict.set(inconclusive);
      }
      }
    }
    [] ISAP1.receive( IDISind:{} ) {
      verdict.set(inconclusive);
    }
    }
    stop;
  } /* End testcase mi_synch2 */




  /* This is a slight transformation of the previous example. It shows
     the usage of test steps. A test step is a special
     function which allows to extend the alternative
     construct by adding new alternatives. It is comparable to the
     TTCN-2 feature of tree attachment in sets of alternatives. */

  testcase mi_synch3 () runs on MTCType {
    var default def := activate(OtherwiseFail()); /* Default activation */
    ISAP1.send( ICONreq:{} );
    verdict.set(pass);
    alt {
    [] MSAP2.receive( Medium_Connection_Request() ) {
      MSAP2.send ( MDATreq:Medium_Connection_Confirmation() );
      alt {
      [] ISAP1.receive ( ICONconf:{} ) {
	ISAP1.send ( Data_Request(TestSuitePar) );
	alt {
	[] MSAP2.receive ( Medium_Data_Transfer() ) {
	  MSAP2.send ( MDATreq:cmi_synch1() );
	  ISAP1.send ( IDISreq:{} );
	  alt {
	  [] ISAP1.receive (IDISind:{} ) { 		/* PASS */
	    MSAP2.receive ( Medium_Disconnection_Request() );
	  }
	  [] MSAP2.receive ( Medium_Disconnection_Request() ) {
	    ReceiveIDISind(pass); /* direct call of test step */
	  }
	  [] MSAP2.receive ( Medium_Data_Transfer() ) {
	    verdict.set(inconclusive);
	  }
	  }
	}
	[] ReceiveIDISind(inconclusive); /* use of test step */
	}
      }
      [] MSAP2.receive( MDATind:Medium_Connection_Request() ) {
	verdict.set(inconclusive);
      }
      [] ReceiveIDISind(inconclusive);
      }
    }
    [] ReceiveIDISind(inconclusive);
    }
    stop;
  } /* End testcase mi_synch3 */



  /* All previous examples kept the TTCN-2 tree structure. But, TTCN-3
     allows also a pure sequential style which is more in line with
     most programming languages. */


  testcase mi_synch4 () runs on MTCType {
    var default def := activate(OtherwiseFail()); /* Default activation */

    ISAP1.send( ICONreq:{} );	/* ONE */
    
    alt {
    [] MSAP2.receive( Medium_Connection_Request() ) {}; /* response to ONE */
    [] ISAP1.receive( IDISind:{} ) { /* not expected response */
      verdict.set(inconclusive);
      stop;
    }
    }

    MSAP2.send ( MDATreq:Medium_Connection_Confirmation() ); /* TWO */

    alt {			
    [] ISAP1.receive ( ICONconf:{} ) {};	/* response to TWO */
    [] MSAP2.receive( MDATind:Medium_Connection_Request()) { /* not expected response */
      verdict.set(inconclusive);
      stop;
    }
    [] ISAP1.receive( IDISind:{} ) { /* not expected response */
      verdict.set(inconclusive);
      stop;
    }
    }

    ISAP1.send ( Data_Request(TestSuitePar) ); /* THREE */

    alt {
    [] MSAP2.receive ( Medium_Data_Transfer() ) {}; /* response to THREE */
    [] ISAP1.receive ( IDISind:{} ) { /* not expected response */
      verdict.set(inconclusive);
      stop;
    }
    }

    MSAP2.send ( MDATreq:cmi_synch1() ); /* FOUR */
    ISAP1.send ( IDISreq:{} );	/* FIVE */

    alt {
    [] ISAP1.receive ( IDISind:{} ) { /* the two responses to FIVE */
      MSAP2.receive ( Medium_Disconnection_Request() );
    }

    [] MSAP2.receive ( Medium_Disconnection_Request() ) { /* other order of responses */
      ISAP1.receive ( IDISind:{} );
    }	
	
    [] MSAP2.receive ( Medium_Data_Transfer() ) {
      verdict.set(inconclusive);
      stop;
    }
    }
    
    verdict.set(pass);
    stop;
    
  } /* End testcase mi_synch4 */


  /* At the first glance this test case description looks very strange
     because we (at least me) are familiar with the TTCN-2 tree
     representation. However, after a second look, you will see some
     advantages. For example, the alternatives at each stage of test
     execution are very clear and you can read the test case from top
     to button. There is no need to compare different levels of
     indentation in order to examine the alternatives. Note, this is a
     toy example, developed from another toy example. Further comments
     (e.g., about reached system states), structuring in test steps or
     a different style of formatting may increase the readability
     considerably. */

  /* A further transformation of the previous example. For readability
     purposes we may decide to hide the inconclusive cases in the
     default behaviour. The new default description would then look
     like: */

  teststep DefaultWithInconclusives() {

    /* INCONCLUSIVE CASES */

  [] MSAP2.receive( MDATind:Medium_Connection_Request()) {
    verdict.set(inconclusive); stop;		/* two statements on the same line */
  }
  [] ISAP1.receive ( IDISind:{} ) {
    verdict.set(inconclusive); stop;
  }
  [] MSAP2.receive ( Medium_Data_Transfer() ) {
    verdict.set(inconclusive); stop;
  }

  /* FAIL CASES */
  [] ISAP1.receive {
    verdict.set(fail); stop;
  }
  [] MSAP2.receive {
    verdict.set(fail); stop;
  }
  } with { display "default"; }


  /* The test case using this default will look like: */
  
  
  testcase mi_synch5 () runs on MTCType {
    var default def := activate(DefaultWithInconclusives()); /* Default activation */

    ISAP1.send( ICONreq:{} );	/* ONE */

    MSAP2.receive( Medium_Connection_Request() ); /* response to ONE */

    MSAP2.send ( MDATreq:Medium_Connection_Confirmation() );	/* TWO */

    ISAP1.receive ( ICONconf:{} ); /* response to TWO */

    ISAP1.send ( Data_Request(TestSuitePar) ); /* THREE */
    
    MSAP2.receive ( Medium_Data_Transfer() ); /* response to THREE */

    MSAP2.send ( MDATreq:cmi_synch1() ); /* FOUR */
    ISAP1.send ( IDISreq:{} ); /* FIVE */

    interleave {					/* the two responses to FIVE can arrive in any order */
    [] ISAP1.receive (IDISind:{} ) {}; 		
    [] MSAP2.receive ( Medium_Disconnection_Request() ) {};
    }

    verdict.set(pass);
    stop;

  } /* End testcase mi_synch5 */



  /* The previous example with some more meaningful comments ... */
  
  testcase mi_synch6 () runs on MTCType {
    var default def := activate(DefaultWithInconclusives()); /* Default activation */

    /* ***** Inres Initiator state = DISCONNECTED ***** */

    /* Connection Set-Up */
    ISAP1.send( ICONreq:{} );	/* Connection Request from Initiator user */
    MSAP2.receive( Medium_Connection_Request() ); /* Connection Request on Responder side */

    MSAP2.send ( MDATreq:Medium_Connection_Confirmation() );
    /* Connection Confirmation from Responder side */
    ISAP1.receive ( ICONconf:{} );/* Connection Confirmation on Initiator user */

    /* ***** Inres Initiator state = CONNECTED ***** */

    /* Data transfer */
    ISAP1.send ( Data_Request(TestSuitePar) );/* Data transfer from Initiator user */

    MSAP2.receive ( Medium_Data_Transfer() ); /* Data reception on Responder side */

    MSAP2.send ( MDATreq:cmi_synch1() ); /* Acknowledgement for data reception by Responder */

    /* End Data transfer, ***** Inres Initiator state = CONNECTED ***** */


    /* Disconnection */
    ISAP1.send ( IDISreq:{} );	/* Disconnection Request from Initiator user */

    interleave {		/* Disconnection is indicated on both sides */
    [] ISAP1.receive ( IDISind:{} ) {};
    [] MSAP2.receive ( Medium_Disconnection_Request() ) {};
    }

    /* ***** Inres Initiator state = DISCONNECTED ***** */

    verdict.set(pass);
    stop;

  } /* End testcase mi_synch6 */



  testcase mi_synch7 () runs on MTCType {
    var default def := activate(DefaultWithInconclusives()); // Default activation

    // * Inres Initiator state = DISCONNECTED *

    // Connection Set-Up
    ISAP1.send( ICONreq:{} );	// Connection Request from Initiator user
    MSAP2.receive( MDATind:Medium_Connection_Request() );
    // Connection Request on Responder side

    MSAP2.send ( MDATreq:Medium_Connection_Confirmation() );
    // Connection Confirmation from Responder side
    ISAP1.receive ( ICONconf:{} );// Connection Confirmation on Initiator user

    // * Inres Initiator state = CONNECTED *
    
    // Data transfer
    ISAP1.send ( IDATreq:Data_Request(TestSuitePar) );
    // Data transfer from Initiator user
    
    MSAP2.receive ( MDATind:Medium_Data_Transfer() );
    // Data reception on Responder side
    
    MSAP2.send ( MDATreq:cmi_synch1() ); // Acknowledgement for data reception by Responder

    // End Data transfer, * Inres Initiator state = CONNECTED *


    // Disconnection
    ISAP1.send ( IDISreq:{} );	// Disconnection Request from Initiator user 

    interleave {		// Disconnection is indicated on both sides
    [] ISAP1.receive ( IDISind:{} ) {};
    [] MSAP2.receive ( MDATind:Medium_Disconnection_Request() ) {};
    }

    // End Disconnection, * Inres Initiator state = DISCONNECTED *

    verdict.set(pass);
    stop;

  } // End testcase mi_synch5

} /* end  module InresExample1 */