TestCodec_Multiport.ttcn 14.5 KB
Newer Older
module TestCodec_Multiport {
    
  // LibCommon
  import from LibCommon_BasicTypesAndValues all;
  import from LibCommon_DataStrings all;
  import from LibCommon_Time all;
  import from LibCommon_VerdictControl all;
  import from LibCommon_Sync all;
  
  // LibIts
  //    import from ITS_Container language "ASN.1:1997" all;
  //    import from CAM_PDU_Descriptions language "ASN.1:1997"all;
  //    import from DENM_PDU_Descriptions language "ASN.1:1997" all;
    
  // LibItsCommon
  //    import from LibItsCommon_TypesAndValues all;
  //    import from LibItsCommon_Functions all;
    
  // LibItsExternal
  import from LibItsExternal_TypesAndValues all;
    
  // LibItsCam
  //    import from LibItsCam_TypesAndValues all;
  import from LibItsCam_TestSystem all;
  //    import from LibItsCam_Templates {
  //    template m_camReq;
  //    group camTemplateFunctions
  //    };
  //    
  // LibItsDenm
  //    import from LibItsDenm_Templates all;
  import from LibItsDenm_TestSystem all;
  //    
  //    // LibItsSecurity
  //    import from LibItsSecurity_TypesAndValues all;
  //    import from LibItsSecurity_Templates all;
  //    import from LibItsSecurity_Functions all;
  //    import from LibItsSecurity_Pixits all;
  //    
  // LibItsGeoNetworking
  import from LibItsGeoNetworking_TypesAndValues all;
  import from LibItsGeoNetworking_Templates all;
  import from LibItsGeoNetworking_Functions all;
  import from LibItsGeoNetworking_TestSystem all;
  import from LibItsGeoNetworking_Pixits all;
  import from LibItsGeoNetworking_Pics all;
  import from LibItsGeoNetworking_EncdecDeclarations all;
    
  // TestCodec
  import from TestCodec_TestAndSystem all;

  /*type component MultiplePorts extends ItsBaseComponent {
    port GeoNetworkingPort;
    port CamPort;
    port DenmPort;
    //component variables
    var CamInd vc_camMsg;
    var DenmInd vc_camMsg;
    var GeoNetworkingInd vc_camMsg;
    
    //default
    var default vc_default := null;
    
    //global variables
    var boolean vc_camReceived := false;
    
    var UtCamEventIndList vc_utEvents := {};
    
    var boolean vc_utDefaultActive := true;
    var boolean vc_camDefaultActive := true;
    var boolean vc_denmDefaultActive := true;
    var boolean vc_geoNetworkingDefaultActive := true;
    
    } // End of component ItsCam
  */



  
  group LibItsGeoNetworking_testCases {
        
    group LibItsGeoNetworking_DummyTemplates {
            
      /**
       * @desc    Dummy template for GN_Address 
       */
      template (value) GN_Address m_dummyGnAddrIut := {
      typeOfAddress := e_manual,
      stationType := e_roadSideUnit,
      stationCountryCode := 33,
      mid := 'a4fedecabeef'O
      }
        
      /**
       * @desc    Dummy template for long position vector
       */
      template (value) LongPosVector m_dummyLongPosVectorIut := {
      gnAddr := m_dummyGnAddrIut,
      timestamp_ := 123456,
      latitude := 4856,
      longitude := 675,
      pai := '1'B,
      speed := 55,
      heading := 9876
      }
            
      template (value) GN_Address m_dummyGnAddrNodeA := {
      typeOfAddress := e_manual,
      stationType := e_pedestrian,
      stationCountryCode := 49,
      mid := 'a4fdea5ea5ed'O
      }
            
      template (value) GN_Address m_dummyGnAddrNodeB := {
      typeOfAddress := e_manual,
      stationType := e_specialVehicle,
      stationCountryCode := 50,
      mid := 'a40102030405'O
      }
        
      template (value) GN_Address m_dummyGnAddrNodeC := {
      typeOfAddress := e_manual,
      stationType := e_moped,
      stationCountryCode := 42,
      mid := 'deadbabebeef'O
      }
        
      template (value) LongPosVector m_dummyLongPosVectorNodeA := {
      gnAddr := m_dummyGnAddrNodeA,
      timestamp_ := 875,
      latitude := 265,
      longitude := 789,
      pai := '0'B,
      speed := 80,
      heading := 548
      }
        
      template (value) LongPosVector m_dummyLongPosVectorNodeB := {
      gnAddr := m_dummyGnAddrNodeB,
      timestamp_ := 4585,
      latitude := 126,
      longitude := 123,
      pai := '0'B,
      speed := 45,
      heading := 125
      }
            
      template (value) LongPosVector m_dummyLongPosVectorNodeC := {
      gnAddr := m_dummyGnAddrNodeC,
      timestamp_ := 23644,
      latitude := 23754,
      longitude := 49645,
      pai := '0'B,
      speed := 110,
      heading := 23
      }
            
      template (value) ShortPosVector m_dummyShortPosVectorNodeC := {
      gnAddr := m_dummyGnAddrNodeC,
      timestamp_ := 23644,
      latitude := 23754,
      longitude := 49645
      }
            
      template (value) Area m_dummyArea1 := {
      geoAreaPosLatitude := 298376,
      geoAreaPosLongitude := 32745,
      distanceA := 1234,
      distanceB := 5678,
      angle := 9123
      }
        
      template (value) Area m_dummyArea2 := {
      geoAreaPosLatitude := 873548,
      geoAreaPosLongitude := 2837,
      distanceA := 8765,
      distanceB := 4321,
      angle := 4567
      }
        
      template (value) GeoBroadcastArea m_dummyGeoBroadcastArea1 := {
      geoBroadcastSubType := e_geoBroadcastRect,
      geoBroadcastArea := m_dummyArea1
      }
        
      template (value) GeoBroadcastArea m_dummyGeoBroadcastArea2 := {
      geoBroadcastSubType := e_geoBroadcastElip,
      geoBroadcastArea := m_dummyArea2
      }
        
      template (value) GeoAnycastArea m_dummyGeoAnycastArea1 := {
      geoAnycastSubType := e_geoAnycastCircle,
      geoAnycastArea := m_dummyArea1
      }
        
      template (value) GeoAnycastArea m_dummyGeoAnycastArea2 := {
      geoAnycastSubType := e_geoAnycastRect,
      geoAnycastArea := m_dummyArea2
      }

      template (value) GnNonSecuredPacket m_geoNwBeaconPacket_payload(
								      in template (value) LongPosVector p_sourceLongPosVec,
								      in template (value) GnRawPayload p_payload
								      ) modifies m_geoNwBeaconPacket := {
      payload := p_payload
      }
	    
      /**
       * @desc    Send template for GeoUnicast header
       * @param   p_sourceLongPosVec      Long position vector of source 
       * @param   p_destinationLongPosVec Long position vector of destination 
       * @param   p_senderLongPosVec      Long position vector of sender
       * @param   p_seqNumber         Sequence number of GeoUnicast packet
       */
      template (value) ExtendedHeader m_geoUnicastHeaderGeoNetworking(
								      in template (value) LongPosVector p_sourceLongPosVec,
								      in template (value) ShortPosVector p_dstPosVector,
								      in template (value) UInt16 p_seqNumber
								      ) := {
      geoUnicastHeader := {
	seqNumber := p_seqNumber,
	reserved := c_uInt8Zero,
	srcPosVector := p_sourceLongPosVec,
	dstPosVector := p_dstPosVector
      }
      }

      template (value) GeoNetworkingInd m_geoNwInd_withLinkLayerDestination(
									    in template (value) GeoNetworkingPdu p_geoNwMsg,
									    in template (value) MacAddress p_llDestinationAdress := 'FFFFFFFFFFFF'O,
									    in template (value) Bit256 p_ssp := int2bit(0, 256),
									    in template (value) UInt32 p_its_aid := 0
									    ) := {
      msgIn := p_geoNwMsg,
      macDestinationAddress := p_llDestinationAdress,
      ssp := p_ssp,
      its_aid := p_its_aid
      }

      /**
       * @desc    Receive template for GeoNetworking DENM Packet
       * @param   p_destinationShortPosVec    Short position vector of destination
       * @param   p_seqNumber                 Sequence number of GeoUnicast packet
       * @param   p_nextHeader                Id of next header
       */
      template (present) GnNonSecuredPacket mw_geoNwTsbPacketWithNextHeader_cam(
                                                                                in template (present) LongPosVector p_sourceLongPosVec := ?,
                                                                                in template (present) UInt8 p_hopLimit := ?,
                                                                                in template (value) NextHeader p_nextHeader
                                                                                ) modifies mw_geoNwShbPacket := {
      commonHeader := mw_commonHeaderWithHopLimit(
                                                  p_nextHeader,
                                                  m_shbHeaderType,
                                                  p_hopLimit
                                                  ),
      payload := ?
      } // End of template mw_geoNwTsbPacketWithNextHeader_cam
      
    } // End of group LibItsGeoNetworking_DummyTemplates
        
    group testMultiPort {
            
      /**
       * @desc validate GeoNetworkingReq/Broadcast
       * @verdict Pass on success, Fail otherwise
       */
      testcase tc_GeoNet_MultiPort() runs on ItsMtc system ItsGeoNetworkingSystem { // TODO To be moved into TestCodec_Multiport
        var ItsGeoNetworking v_comp1;
        var ItsGeoNetworking v_comp2;

      v_comp1 := ItsGeoNetworking.create("Comp1") alive;
      v_comp2 := ItsGeoNetworking.create("Comp2") alive;
	
        connect(self:syncPort, mtc:syncPort);
        connect(v_comp1:syncPort, self:syncPort);
        connect(v_comp2:syncPort, self:syncPort);
        map(v_comp1:geoNetworkingPort, system:geoNetworkingPort);
        map(v_comp2:geoNetworkingPort, system:geoNetworkingPort);
	
        v_comp1.start(f_tc_GeoNet_MultiPort());
        v_comp2.start(f_tc_GeoNet_MultiPort());
        // Synchronization
        f_serverSync2ClientsAndStop({c_prDone, c_tbDone});
	

        disconnect(self:syncPort, mtc:syncPort);
        disconnect(v_comp1:syncPort, self:syncPort);
        disconnect(v_comp2:syncPort, self:syncPort);
        unmap(v_comp1:geoNetworkingPort, system:geoNetworkingPort);
        unmap(v_comp2:geoNetworkingPort, system:geoNetworkingPort);
      }

      function f_tc_GeoNet_MultiPort() runs on ItsGeoNetworking {
        var GeoNetworkingReq v_gnReq;
        var ExtendedHeader v_header;
        var boolean v_got_it := false;
        var GeoNetworkingInd v_msg;
        if (PX_GN_UPPER_LAYER != e_any) {
          log("PX_GN_UPPER_LAYER shall be set to e_any");
          stop;
        }
        f_selfOrClientSyncAndVerdict(c_prDone, e_success);                
      v_gnReq := valueof(m_geoNwReq_linkLayerBroadcast(
                                                       m_geoNwPdu(
                                                                  m_geoNwBroadcastPacket(
                                                                                         m_dummyLongPosVectorNodeB, 
                                                                                         3456, 
                                                                                         m_dummyGeoBroadcastArea1
                                                                                         ))));
        geoNetworkingPort.send(v_gnReq);
        tc_ac.start;
        alt {
          [] geoNetworkingPort.receive(
                                       mw_geoNwInd(
                                                   mw_geoNwPdu(
                                                               mw_geoNwTsbPacketWithNextHeader_cam(
                                                                                                   -,
                                                                                                   -,
                                                                                                   e_btpB
                                                                                                   )))) {
            if (v_got_it == false) {
            v_got_it := true;
              setverdict(pass);
            }
            repeat;
          }
          [] geoNetworkingPort.receive(
                                       mw_geoNwInd(
                                                   mw_geoNwPdu(
                                                               mw_geoNwLsRequestPacket(
                                                                                       ?,
                                                                                       ?
                                                                                       )))) -> value v_msg {
            log("Receive LsRequest: ", v_msg.msgIn);
            // Send LsReply
            f_sendGeoNetMessage(
                                valueof(m_geoNwReq_linkLayerBroadcast(
                                                                      m_geoNwPdu(
                                                                                 m_geoNwLsReplyPacket(
                                                                                                      m_dummyLongPosVectorNodeA,
                                                                                                      f_longPosVector2ShortPosVector(
                                                                                                                                     valueof(v_msg.msgIn.gnPacket.packet.extendedHeader.lsRequestHeader.srcPosVector)
                                                                                                                                     ),
                                                                                                      vc_localSeqNumber
                                                                                                      )))));
            repeat;
          }
          [] geoNetworkingPort.receive(
                                       mw_geoNwInd(
                                                   mw_geoNwPdu(
                                                               mw_geoNwBeaconPacket(?)
                                                               )
                                                   )) -> value v_msg {
            log("Receive beacon: ", v_msg.msgIn);
            repeat;
          }
          [] geoNetworkingPort.receive(
                                       mw_geoNwInd(
                                                   ?
                                                   )) -> value v_msg {
            setverdict(fail);
          }
          [] tc_ac.timeout {
            if (v_got_it == false) {
              setverdict(inconc, "Expected message not received");
            }
          }
        }
        f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
	
      } // End of function f_tc_GeoNet_MultiPort
        
    } // End of group testMultiPort 
        
  } // End of group LibItsGeoNetworking_testCases
    
} // End of module TestCodec_Multiport