/* Copyright (c) 2010, 2016  Ericsson AB
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Michael Josenhans
******************************************************************************/
//
//  File:               SocketCANtest.ttcn
//  Description:        SocketCAN port type test
//


module SocketCANtest {

import from SocketCAN_Types all;
import from SocketCAN_PortType all;
import from Bcm all
import from Can all

const float c_guard := 10.0

type enumerated SocketCAN_open_socket_type
{ 
  OPEN_CAN_RAW,
  OPEN_CAN_BCM
  //OPEN_CAN_ISOTP
}

type enumerated e_Phase {
  e_open_socket, 
  e_testbody1, 
  e_testbody2,
  e_testbody3,
  e_testbody4,
  e_testbody5,
  e_testbody6,
  e_testbody7,
  e_testbodyEnd,
  e_close_socket,
  e_testcase_complete
}

type record SocketCAN_open_raw_result{
  SocketCAN_ifr                    ifr,
  SocketCAN_socketid               socket_id} 

type record BCM_cmd  {
  e_Phase phase,
  SocketCAN_bcm_frame bcm_frame
}

type record length (0 .. CAN_FRAME_MAX_NUMBER) of BCM_cmd BCM_cmds

type record length (0 .. CAN_FRAME_MAX_NUMBER) of SocketCAN_CAN_or_CAN_FD_frame SocketCAN_CAN_or_CAN_FD_frames

// workarounds as (x .. enum2int(e_testcase_complete)) fails but:
// workarounds as (x .. enum2int(c_testcase_complete)) works
const e_Phase c_firstPhase        := e_open_socket
const e_Phase c_testcase_complete := e_testcase_complete


template SocketCAN_Result a_result(in SocketCAN_Result_code v_result_code) := {          
  result_code   := v_result_code,
  err           := *,
  err_text      := *
}

template SocketCAN_socket_result 
a_SocketCAN_socket_result(template SocketCAN_Result p_result) := {
  id := ?, 
  result := p_result
}

template SocketCAN_ioctl_result 
a_SocketCAN_ioctl_result(template SocketCAN_Result p_result) := {
  ifr := ?,
  result := p_result
}

template SocketCAN_connect_result
a_SocketCAN_connect_result(template SocketCAN_Result p_result) := {
  result := p_result
}

template SocketCAN_bind_result
a_SocketCAN_bind_result(template SocketCAN_Result p_result) := {
  result := p_result
}

template SocketCAN_send_data_result
a_SocketCAN_send_data_result(template SocketCAN_Result p_result) := {
  result := p_result
}

template SocketCAN_write_data_result
a_SocketCAN_write_data_result(template SocketCAN_Result p_result) := {
  result := p_result
}

template SocketCAN_receive_CAN_or_CAN_FD_frame a_SocketCAN_receive_CAN_or_CAN_FD_frame(
  template SocketCAN_socketid p_id, 
  template SocketCAN_CAN_or_CAN_FD_frame p_frame) := { 
  // recieved CAN or CAN FD frame
  id        := p_id,
  ifr       := ?,
  frame     := p_frame, 
  timestamp := ?
}

template SocketCAN_receive_BCM_message a_SocketCAN_receive_BCM_message(
  template SocketCAN_socketid p_id, 
  template SocketCAN_bcm_frame p_frame) := { 
  // recieved CAN or CAN FD frame
  id        := p_id,
  ifr       := ?,
  frame     := p_frame
}

template SocketCAN_setsockopt_result
a_SocketCAN_setsockopt_result(template SocketCAN_Result p_result) := {
  result := p_result
}

type record PhaseStartReq {
  e_Phase phase,
  integer phase_int
}
type record PhaseEndInd   {
  e_Phase phase, 
  integer phase_int
}

type port SyncMasterPort message {
  out PhaseStartReq
  in  PhaseEndInd
} with { extension "internal" }

type port SyncSlavePort message {
  in   PhaseStartReq
  out  PhaseEndInd
} with { extension "internal" }

type record of PTC PTCSet 


type component PTC {
  port SyncSlavePort                  pt_sync
  port SocketCAN_PT                   pt_socketCAN
  var  e_Phase                        v_phase := c_firstPhase
}

//component declarations
type component MTC{ 
  timer t_guard
  port  SyncMasterPort pt_sync
  var PTCSet         v_PTCSet := {}
}

altstep alt_awaitPhaseStartReq(in e_Phase p_phase) runs on PTC {
  var PhaseStartReq v_PhaseStartReq;
  [] pt_sync.receive (PhaseStartReq: {phase := p_phase, phase_int := ?}){
    log("PTC name: ", self)
    log("Waits for start of phase: ", p_phase)
  }
  // between v_phase and p_phase
  [] pt_sync.receive (PhaseStartReq: {phase := ?, phase_int := (enum2int(c_firstPhase) .. enum2int(v_phase))}) -> value v_PhaseStartReq 
  { 
    //v_phase := f_incPhase(v_phase)
    log("PTC name: ", self)
    log("Waits for start of phase: ", p_phase)
    log("Received completion of phase: ", p_phase)
    f_sendPhaseEndInd()
    repeat
  }
  [] pt_sync.receive (PhaseStartReq: {phase := ?, phase_int :=?}) -> value v_PhaseStartReq
  {log("Received unexpected message:", v_PhaseStartReq);setverdict(inconc)}
}

function f_startPhase (in e_Phase p_phase) runs on MTC {
  var integer v_i
  var integer v_amount := sizeof(v_PTCSet)
  var PhaseStartReq v_phaseStartReq := { phase := p_phase, phase_int := enum2int(p_phase)}

  for (v_i := 0; v_i < v_amount; v_i := v_i +1){
    log("MTC instance: ", self)
    pt_sync.send(v_phaseStartReq) to v_PTCSet[v_i]
  }
}

function f_incPTCPhase(in e_Phase p_currentPhase) runs on PTC return e_Phase {
  var e_Phase v_nextPhase
  log("PTC: ", self)
  log("PTC instance: ", self)
  log("Current PTC phase: ", p_currentPhase)
  int2enum( enum2int(p_currentPhase)+1, v_nextPhase)
  log("Next PTC phase:", v_nextPhase)
  return v_nextPhase
}

function f_sendPhaseEndInd() runs on PTC{
  // just to allow matching with integer ranges on the reception side, as it is not poosible to do so with enums
  var PhaseEndInd v_PhaseEndInd := {phase := v_phase, phase_int := enum2int(v_phase)}
  pt_sync.send(v_PhaseEndInd)
  log("PTC: PhaseEndInd to MTC with content: ", v_PhaseEndInd, self)
  v_phase := f_incPTCPhase(v_phase)
}

function f_addSyncSlaveSet (in PTC p_slave,
  inout PTCSet p_set) {
  p_set[sizeof(p_set)] := p_slave
  return
}

function f_incMTCPhase(in e_Phase p_currentPhase) runs on MTC return e_Phase {
  var e_Phase v_nextPhase
  log("MTC: ", self)
  log("Current phase: ", p_currentPhase)
  int2enum( enum2int(p_currentPhase)+1, v_nextPhase)
  log("Next phase:", v_nextPhase)
  return v_nextPhase
}

function f_awaitEndPhase(in e_Phase p_phase) runs on MTC {
  var integer v_amount:= sizeof(v_PTCSet);
  var integer v_i
  t_guard.start(c_guard)
  var PhaseEndInd v_PhaseEndInd

  for(v_i := 0; v_i < v_amount; v_i := v_i +1) {
    alt {
      [] pt_sync.receive (PhaseEndInd: {phase :=p_phase, phase_int := ?}){}
      // value between p_phase +1  and e_testcase_complete:
      [] pt_sync.receive (PhaseEndInd: {phase :=?, phase_int :=  (enum2int(p_phase) .. (enum2int(c_testcase_complete)))}){}
      [] t_guard.timeout {
        log("Timeout in MTC phase:", p_phase)
        setverdict(inconc)
      }
      [] pt_sync.receive (?)  -> value v_PhaseEndInd {
        log("Unexpected phase recieved: ", v_PhaseEndInd)
        log("Expected phase range: ", p_phase)
        log(" to ", c_testcase_complete)
        setverdict(inconc)        
      }
      [] any port.receive{
        log("Expected phase:", p_phase)
        setverdict(inconc)
      }
    } 
  }
  t_guard.stop
}

function f_open_socket(in SocketCAN_open_socket_type v_socket_type) 
runs on PTC 
return SocketCAN_socket_result {

  var SocketCAN_socket_result v_result  
  timer t_guard
  t_guard.start(c_guard)

  var SocketCAN_socket socket

  if(v_socket_type==OPEN_CAN_RAW) {
    socket := {domain:=PF_CAN, ptype := SOCK_RAW, protocol:= CAN_RAW};
  } else if (v_socket_type == OPEN_CAN_BCM) {
    socket := {domain:=PF_CAN, ptype := SOCK_DGRAM, protocol:= CAN_BCM};  
  }
  pt_socketCAN.send(socket)  

  // receive response
  alt {
    [] pt_socketCAN.receive(
      a_SocketCAN_socket_result(a_result(SocketCAN_SUCCESS))) -> value v_result
    {log("SocketCan:Socket opened: ", v_result.id)}
    [] pt_socketCAN.receive(a_SocketCAN_socket_result(a_result(SocketCAN_ERROR)))
    {log("Received Opening Socket failed"); setverdict(fail)}
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)}
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)}
  }
  t_guard.stop
  return v_result
}

function f_ioctl_get_if_index(in SocketCAN_socketid p_socket_id) 
runs on PTC 
return SocketCAN_ioctl_result {
  var SocketCAN_ioctl_result v_result   
  timer t_guard
  t_guard.start(c_guard)

  pt_socketCAN.send(SocketCAN_ioctl:{id:= p_socket_id, ifu := omit});
  // receive response
  alt {
    [] pt_socketCAN.receive(a_SocketCAN_ioctl_result(a_result(SocketCAN_SUCCESS))) -> value v_result
    {log("Retrieved interface index", v_result.ifr.if_index)}
    [] pt_socketCAN.receive(a_SocketCAN_ioctl_result(a_result(SocketCAN_ERROR)))
    {log("Retrieving interface index failed", p_socket_id); setverdict(fail)}       
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)
    }
  } 
  return v_result
}

function f_connect(in SocketCAN_socketid p_socket_id,
  in SocketCAN_if_index p_if_index) 
runs on PTC 
return SocketCAN_connect_result {  
  var SocketCAN_connect_result v_result                   
  timer t_guard
  t_guard.start(c_guard)

  pt_socketCAN.send(SocketCAN_connect:{id:= p_socket_id, if_index:= p_if_index});
  // SocketCAN_connect receive response
  alt {
    [] pt_socketCAN.receive(a_SocketCAN_connect_result(a_result(SocketCAN_SUCCESS))) -> value v_result
    {log("Connecting socket", p_socket_id)}
    [] pt_socketCAN.receive(a_SocketCAN_connect_result(a_result(SocketCAN_ERROR))) 
    {log("Connecting socket failed.", p_socket_id); setverdict(fail)}       
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)}
  } 
  return v_result
}

function f_bind(in SocketCAN_socketid p_socket_id,
  in SocketCAN_if_index p_if_index) 
runs on PTC 
return SocketCAN_bind_result {
  var SocketCAN_bind_result v_result
  timer t_guard
  t_guard.start(c_guard)

  pt_socketCAN.send(SocketCAN_bind:{id:= p_socket_id, if_index:= p_if_index});
  alt {
    [] pt_socketCAN.receive(a_SocketCAN_bind_result(a_result(SocketCAN_SUCCESS))) -> value v_result
    {log("Binding socket", p_socket_id)}
    [] pt_socketCAN.receive(a_SocketCAN_bind_result(a_result(SocketCAN_ERROR))) {}
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)
    }
  }  
  return v_result
}

function f_send_data(in SocketCAN_socketid p_socket_id, 
  SocketCAN_send_data_ifu p_ifu,
  in SocketCAN_CAN_or_CAN_FD_frame p_CAN_or_CAN_FD_frame)
runs on PTC
return SocketCAN_send_data_result { 
  var SocketCAN_send_data_result v_result

  timer t_guard
  t_guard.start(c_guard)

  // note: the optional parameter ifu has been left out.
  pt_socketCAN.send(SocketCAN_send_data:{id:= p_socket_id, ifu := p_ifu, frame := p_CAN_or_CAN_FD_frame});

  alt {
    [] pt_socketCAN.receive(a_SocketCAN_send_data_result(a_result(SocketCAN_SUCCESS))) -> value v_result
    {log("Sending data", p_socket_id)}
    [] pt_socketCAN.receive(a_SocketCAN_send_data_result(a_result(SocketCAN_ERROR))) 
    {log("Sending data failed", p_socket_id); setverdict(fail)}       
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)
    }
  }
  return v_result
}

function f_receive_data(in SocketCAN_socketid p_socket_id, template SocketCAN_CAN_or_CAN_FD_frame p_frame_expected)
runs on PTC { 
  var SocketCAN_receive_CAN_or_CAN_FD_frame v_result

  timer t_guard
  t_guard.start(c_guard)

  // receive frame or timeout
  alt {

    [] pt_socketCAN.receive(a_SocketCAN_receive_CAN_or_CAN_FD_frame(p_socket_id, p_frame_expected)) -> value v_result
    {log("SocketCan:Expected frame received", v_result)}
    [] pt_socketCAN.receive(?) -> value v_result
    {log("SocketCan:Unexpected frame received!", v_result)
      setverdict(fail)}
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)}
  }
}

function f_receive_no_data_but_timeout(in SocketCAN_socketid p_socket_id, in float p_timeout_period)
runs on PTC { 
  var SocketCAN_receive_CAN_or_CAN_FD_frame v_result

  timer t_guard
  t_guard.start(p_timeout_period)

  // receive frame or timeout
  alt {
    [] pt_socketCAN.receive(a_SocketCAN_receive_CAN_or_CAN_FD_frame(p_socket_id, ?)) -> value v_result {
      log("SocketCan:Unexpected frame received!", v_result)
      setverdict(fail)
    }
    [] t_guard.timeout {
      log("Expected timeout!")}
  }
}

function f_write_data(in SocketCAN_socketid p_socket_id, 
  in SocketCAN_bcm_frame p_bcm_frame) 
runs on PTC { 

  var SocketCAN_write_data_result v_result

  timer t_guard
  t_guard.start(c_guard)
  log("BCM frame: SocketCAN_write_data:{id}:", p_socket_id)
  log("BCM frame: SocketCAN_write_data:{bcm_tx_msg}:", p_bcm_frame)

  pt_socketCAN.send(SocketCAN_write_data:{id:= p_socket_id, bcm_tx_msg := p_bcm_frame});
  alt {
    [] pt_socketCAN.receive(a_SocketCAN_write_data_result(a_result(SocketCAN_SUCCESS))) -> value v_result
    {log("Writing data on BCM socket: ", p_socket_id)}
    [] pt_socketCAN.receive(a_SocketCAN_write_data_result(a_result(SocketCAN_ERROR))) 
    {log("Writing data on BCM socket failed", p_socket_id); 
      setverdict(fail)}       
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)}
  }
}

function f_receive_BCM_message(template SocketCAN_socketid p_socket_id, template SocketCAN_bcm_frame p_BCM_message_expected)
runs on PTC { 
  var SocketCAN_receive_BCM_message v_result

  timer t_guard
  t_guard.start(c_guard)

  // receive frame or timeout
  alt {
    [] pt_socketCAN.receive(a_SocketCAN_receive_BCM_message(p_socket_id, p_BCM_message_expected)) -> value v_result
    {log("SocketCan:Expected frame received", v_result)}
    [] pt_socketCAN.receive(?) -> value v_result
    {log("SocketCan:Unexpected frame received!", v_result)
      setverdict(fail)}
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)}
  }
}

function f_setsockopt(in SocketCAN_socketid p_socket_id,
  in SocketCAN_setsockopt_commandu p_command)
runs on PTC 
return SocketCAN_setsockopt_result{
  var SocketCAN_setsockopt_result v_result

  timer t_guard
  t_guard.start(c_guard)

  pt_socketCAN.send(SocketCAN_setsockopt:{id:= p_socket_id, command := p_command});
  alt {
    [] pt_socketCAN.receive(a_SocketCAN_setsockopt_result(a_result(SocketCAN_SUCCESS))) -> value v_result
    {log("Writing data", p_socket_id)}
    [] pt_socketCAN.receive(a_SocketCAN_setsockopt_result(a_result(SocketCAN_ERROR))) 
    {log("Writing data failed", p_socket_id); setverdict(fail)}       
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)
    }
  }
  return v_result
}

function f_close_socket (in SocketCAN_socketid p_socket_id) 
runs on PTC {
  pt_socketCAN.send(SocketCAN_close:{id:= p_socket_id});
}

function f_open_raw()
runs on PTC 
return SocketCAN_open_raw_result {
  var SocketCAN_socketid v_socket_id
  v_socket_id := f_open_socket(OPEN_CAN_RAW).id
  var SocketCAN_ifr v_ifr
  v_ifr := f_ioctl_get_if_index(v_socket_id).ifr
  var SocketCAN_bind_result v_bind_result
  v_bind_result := f_bind(v_socket_id, v_ifr.if_index)

  var SocketCAN_open_raw_result v_result
  v_result := {ifr := v_ifr, socket_id := v_socket_id}

  return v_result
}

function f_open_bcm()
runs on PTC 
return SocketCAN_socketid {
  var SocketCAN_socketid v_socket_id
  v_socket_id := f_open_socket(OPEN_CAN_BCM).id
  log("Opening BCM socket_id", v_socket_id)
  var SocketCAN_ifr v_ifr
  v_ifr := f_ioctl_get_if_index(v_socket_id).ifr
  var SocketCAN_connect_result v_connect_result
  v_connect_result := f_connect(v_socket_id, v_ifr.if_index)

  return v_socket_id
}

function f_ptc_RawSendInitiator(in e_Phase p_phase,
  in SocketCAN_CAN_or_CAN_FD_frame v_frame_send) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_id
  var SocketCAN_ifr v_ifr
  var SocketCAN_send_data_ifu v_ifu

  alt_awaitPhaseStartReq(e_open_socket)
  var SocketCAN_open_raw_result res
  res := f_open_raw();
  v_socket_id := res.socket_id
  v_ifr := res.ifr
  v_ifu.if_name :=  v_ifr.if_name 
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(p_phase)
  var SocketCAN_send_data_result send_data_result
  send_data_result := f_send_data(v_socket_id,
    v_ifu,
    v_frame_send)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)
  setverdict(pass)
  f_sendPhaseEndInd()
}

function f_ptc_RawFrameReceiver(in e_Phase p_phase,
  template SocketCAN_CAN_or_CAN_FD_frame p_frame_expected) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_raw_id
  var SocketCAN_ifr v_ifr
  var SocketCAN_send_data_ifu v_ifu

  alt_awaitPhaseStartReq(e_open_socket)
  var SocketCAN_open_raw_result res
  res := f_open_raw();
  v_socket_raw_id := res.socket_id
  v_ifr := res.ifr
  v_ifu.if_name :=  v_ifr.if_name 
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(p_phase)
  f_receive_data(v_socket_raw_id, p_frame_expected)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_raw_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)  
  setverdict(pass)
  f_sendPhaseEndInd()
}

function f_ptc_RawFrameSequenceReceiver(
  in e_Phase p_sequence_expected_phase,
  template SocketCAN_CAN_or_CAN_FD_frames p_frame_sequence_expected, 
  in e_Phase p_no_further_frames_expected_phase, 
  in float p_timeout_period) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_raw_id
  var SocketCAN_ifr v_ifr
  var SocketCAN_send_data_ifu v_ifu

  alt_awaitPhaseStartReq(e_open_socket)
  var SocketCAN_open_raw_result res
  res := f_open_raw();
  v_socket_raw_id := res.socket_id
  v_ifr := res.ifr
  v_ifu.if_name :=  v_ifr.if_name 
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(p_sequence_expected_phase)
  var integer v_i
  for( v_i := 0; v_i < lengthof(p_frame_sequence_expected); v_i := v_i +1) { 
    f_receive_data(v_socket_raw_id, p_frame_sequence_expected[v_i])
  }
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(p_no_further_frames_expected_phase)
  f_receive_no_data_but_timeout(v_socket_raw_id, p_timeout_period)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_raw_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)  
  setverdict(pass)
  f_sendPhaseEndInd()
}

function f_ptc_bcmComandSendInitiator(in BCM_cmds p_cmd_list) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_bcm_id

  alt_awaitPhaseStartReq(e_open_socket)
  v_socket_bcm_id := f_open_bcm()
  f_sendPhaseEndInd()
  var integer v_i
  for( v_i := 0; v_i < lengthof(p_cmd_list); v_i := v_i +1) { 
    alt_awaitPhaseStartReq(p_cmd_list[v_i].phase)
    // write mesage to BCM using v_socket_bcm_id
    f_write_data(v_socket_bcm_id, p_cmd_list[v_i].bcm_frame)
    f_sendPhaseEndInd()
  }

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_bcm_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)
  setverdict(pass)
  f_sendPhaseEndInd()
}

// the following function is work in progress to receive messages from BCM
function f_ptc_bcmComandSendReceiveInitiator(in BCM_cmds p_cmd_list) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_bcm_id

  alt_awaitPhaseStartReq(e_open_socket)
  v_socket_bcm_id := f_open_bcm()
  f_sendPhaseEndInd()
  var integer v_i
  for( v_i := 0; v_i < lengthof(p_cmd_list); v_i := v_i +1) { 
    alt_awaitPhaseStartReq(p_cmd_list[v_i].phase)
    // write mesage to BCM using v_socket_bcm_id
    f_write_data(v_socket_bcm_id, p_cmd_list[v_i].bcm_frame)
    f_receive_BCM_message(v_socket_bcm_id, ?)
    f_sendPhaseEndInd()
  }

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_bcm_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)
  setverdict(pass)
  f_sendPhaseEndInd()
}

function f_ptc_bcmSendInitiator(in e_Phase p_phase, 
  in SocketCAN_bcm_frame p_bcm_frame) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_bcm_id

  alt_awaitPhaseStartReq(e_open_socket)
  v_socket_bcm_id := f_open_bcm()
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(p_phase)
  // write mesage to BCM using v_socket_bcm_id
  f_write_data(v_socket_bcm_id, p_bcm_frame)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_bcm_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)
  setverdict(pass)
  f_sendPhaseEndInd()
}

function f_raw_setsockopt(in e_Phase p_phase, 
  in  SocketCAN_setsockopt_commandu p_setsockopt_command) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_id
  var SocketCAN_ifr v_ifr
  var SocketCAN_send_data_ifu v_ifu

  alt_awaitPhaseStartReq(e_open_socket)
  var SocketCAN_open_raw_result res
  res := f_open_raw();
  v_socket_id := res.socket_id
  v_ifr := res.ifr
  v_ifu.if_name :=  v_ifr.if_name 
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(p_phase)
  // send command to setsockopt
  var SocketCAN_setsockopt_result            v_setsockopt_result

  // configure filters:
  v_setsockopt_result := f_setsockopt(v_socket_id, p_setsockopt_command)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)
  setverdict(pass)
  f_sendPhaseEndInd()
}

// control
// {
//    execute(tc_can_raw0())
// }
}