ItsGeoNetworking_TpFunctions.ttcn

                /**
                 * @desc    Behavior function for NodeD (TC_GEONW_PON_GBC_BV_02)
                 */
                function f_GEONW_PON_GBC_BV_02_nodeD() runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorIut := f_getPosition(c_compIut);
                    
                    // Preamble
                    f_prNeighbour();
                    f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                    
                    // Test Body
                    tc_noac.start;
                    alt {
                        [] a_receiveGeoBroadcastWithArea(
                                mw_longPosVectorPosition_withDelta(v_longPosVectorIut),
                                ?,
                                f_getGeoBroadcastArea(c_area2)) {
                            tc_noac.stop;
                            log("*** " & testcasename() & ": FAIL: received GBC message ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                        }
                        [] tc_noac.timeout {
                            log("*** " & testcasename() & ": PASS: GBC message not received ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                        }
                    }
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BV_02_nodeD
                
            } // end GEONW_PON_GBC_BV_02
            
            group GEONW_PON_GBC_BV_03 {
                
                /**
                 * @desc    TP Function for TC_GEONW_PON_GBC_BV_03
                 */
                function f_GEONW_PON_GBC_BV_03() runs on ItsMtc {
                    
                    // Local variables
                    var ItsGeoNetworking v_nodeB;
                    var ItsGeoNetworking v_nodeD;
                    
                    // Test control
                    if (not PICS_GN_GBC_SRC) {
                        log("*** " & testcasename() & ": PICS_GN_GBC_SRC required for executing the TC ***");
                        setverdict(inconc);
                        stop;
                    }
                    if ((f_getGeoBroadcastForwardingAlgorithm() != e_simple) and (f_getGeoBroadcastForwardingAlgorithm() != e_unspecified)) {
                        log("*** " & testcasename() & ": PICS_GN_GEOBROADCAST_FORWARDING_ALGORITHM == ( e_simple or e_unspecified ) required for executing the TC ***");
                        setverdict(inconc);
                        stop;
                    }
                    
                    // Test component configuration
                    f_cf02Up();
                    
                    // Preamble
                    
                    // Start components
                    v_nodeB := f_getComponent(c_compNodeB);
                    v_nodeD := f_getComponent(c_compNodeD);
                    v_nodeB.start(f_GEONW_PON_GBC_BV_03_nodeB());
                    v_nodeD.start(f_GEONW_PON_GBC_BV_03_nodeD());
                    
                    // Synchronization
                    f_serverSync2ClientsAndStop({c_prDone, c_tbDone});
                    
                    // Cleanup
                    f_cf02Down();
                    
                } // end f_GEONW_PON_GBC_BV_03
                
                /**
                 * @desc    Behavior function for NodeB (TC_GEONW_PON_GBC_BV_03)
                 */
                function f_GEONW_PON_GBC_BV_03_nodeB() runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB);
                    
                    // Preamble
                    f_prNeighbour();
                    f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                    
                    // Test Body
                    f_sendGeoNetMessage(
                        m_geoNwReq_linkLayerBroadcast(
                            m_geoNwPdu(
                                m_geoNwBroadcastPacket(
                                    v_longPosVectorNodeB,
                                    vc_localSeqNumber,
                                    f_getGeoBroadcastArea(c_area1)
                                )
                            )
                        )
                    );
                    
                    tc_ac.start;
                    alt {
                        [] a_receiveGeoBroadcastWithArea(
                                mw_longPosVectorPosition(v_longPosVectorNodeB),
                                ?,
                                f_getGeoBroadcastArea(c_area1)) {
                            tc_ac.stop;
                            log("*** " & testcasename() & ": PASS: GBC message received correctly ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                        }
                        [] tc_ac.timeout {
                            log("*** " & testcasename() & ": FAIL: GBC message not received ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                        }
                    }
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BV_03_nodeB
                
                /**
                 * @desc    Behavior function for NodeD (TC_GEONW_PON_GBC_BV_03)
                 */
                function f_GEONW_PON_GBC_BV_03_nodeD() runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB);
                    
                    // Preamble
                    f_prNeighbour();
                    f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                    
                    // Test Body
                    tc_ac.start;
                    alt {
                        [] a_receiveGeoBroadcastWithArea(
                                mw_longPosVectorPosition(v_longPosVectorNodeB),
                                ?,
                                f_getGeoBroadcastArea(c_area1)) {
                            tc_ac.stop;
                            log("*** " & testcasename() & ": PASS: GBC message received correctly ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                        }
                        [] tc_ac.timeout {
                            log("*** " & testcasename() & ": FAIL: GBC message not received ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                        }
                    }
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BV_03_nodeD
                
            } // end GEONW_PON_GBC_BV_03
            
            group GEONW_PON_GBC_BO_04 {
                
                /**
                 * @desc    TP Function for TC_GEONW_PON_GBC_BO_04
                 */
                function f_GEONW_PON_GBC_BO_04() runs on ItsMtc {
                    
                    // Local variables
                    var ItsGeoNetworking v_nodeB;
                    var ItsGeoNetworking v_nodeD;
                    
                    // Test control
                    if (not PICS_GN_GBC_FWD) {
                        log("*** " & testcasename() & ": PICS_GN_GBC_FWD required for executing the TC ***");
                        setverdict(inconc);
                        stop;
                    }
                    if ((f_getGeoBroadcastForwardingAlgorithm() != e_simple) and (f_getGeoBroadcastForwardingAlgorithm() != e_unspecified)) {
                        log("*** " & testcasename() & ": PICS_GN_GEOBROADCAST_FORWARDING_ALGORITHM == ( e_simple or e_unspecified ) required for executing the TC ***");
                        setverdict(inconc);
                        stop;
                    }
                    
                    // Test component configuration
                    f_cf02Up();
                    
                    // Preamble
                    
                    // Start components
                    v_nodeB := f_getComponent(c_compNodeB);                    
                    v_nodeD := f_getComponent(c_compNodeD);
                    v_nodeB.start(f_GEONW_PON_GBC_BO_04_nodeB());
                    v_nodeD.start(f_GEONW_PON_GBC_BO_04_nodeD());
                    
                    // Synchronization
                    f_serverSync2ClientsAndStop({c_prDone, c_tbDone});
                    
                    // Cleanup
                    f_cf02Down();
                    
                } // end f_GEONW_PON_GBC_BO_04
                
                /**
                 * @desc    Behavior function for NodeB (TC_GEONW_PON_GBC_BO_04)
                 */
                function f_GEONW_PON_GBC_BO_04_nodeB() runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB);
                    var template (present) GeoNetworkingPdu v_gnPacket;
                    
                    // Preamble
                    f_prNeighbour();
                    v_gnPacket := m_geoNwPdu(
                                      m_geoNwBroadcastPacket(
                                          v_longPosVectorNodeB,
                                          vc_localSeqNumber,
                                          f_getGeoBroadcastArea(c_area1)
                                      ),
                                      -,
                                      c_defaultHopLimit
                                  );
                    f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(valueof(v_gnPacket)));
                    
                    tc_ac.start;
                    alt {
                        [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwBroadcastPacketWithArea(
                                mw_longPosVectorPosition(v_longPosVectorNodeB),
                                ?,
                                f_getGeoBroadcastArea(c_area1)
                            )))) {
                            tc_ac.stop;
                            log("*** " & testcasename() & ": PASS: Pre-conditions: GBC message received correctly ***");
                            f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                        }
                        [] tc_ac.timeout {
                            log("*** " & testcasename() & ": INCONC: Pre-conditions: GBC message not received ***");
                            f_selfOrClientSyncAndVerdict(c_prDone, e_timeout);
                        }
                    }
                    
                    // Test Body
                    tc_noac.start;
                    alt {
                        [] a_receiveGeoBroadcast(
                                ?,
                                ?) {
                            tc_noac.stop;
                            log("*** " & testcasename() & ": FAIL: GBC message re-broadcasted ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                        }
                        [] tc_noac.timeout {
                            log("*** " & testcasename() & ": PASS: GBC message not re-broadcasted ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                        }
                    }
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BO_04_nodeB
                
                /**
                 * @desc    Behavior function for NodeD (TC_GEONW_PON_GBC_BO_04)
                 */
                function f_GEONW_PON_GBC_BO_04_nodeD() runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB);
                    var template (present) GeoNetworkingInd v_msgInd;
                    
                    // Preamble
                    f_prNeighbour();
                    tc_ac.start;
                    alt {
                        [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwBroadcastPacketWithArea(
                                mw_longPosVectorPosition(v_longPosVectorNodeB),
                                ?,
                                f_getGeoBroadcastArea(c_area1)
                            )))) -> value v_msgInd {
                            tc_ac.stop;
                            log("*** " & testcasename() & ": PASS: Pre-conditions: GBC message received correctly ***");
                            f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                        }
                        [] tc_ac.timeout {
                            log("*** " & testcasename() & ": FAIL: Pre-conditions: GBC message not received ***");
                            f_selfOrClientSyncAndVerdict(c_prDone, e_error);
                        }
                    }
                    
                    // Test Body
                    // send geoBroadcast for second time (same source + same seq Nr + lower RHL)
                    v_msgInd.msgIn.basicHeader.routerHopLimit := valueof(v_msgInd.msgIn.basicHeader.routerHopLimit) - 1;
                    f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(valueof(v_msgInd.msgIn)));
                    
                    v_msgInd.msgIn.basicHeader.routerHopLimit := ?;
                    tc_noac.start;
                    alt {
                        [] a_receiveGeoBroadcast(
                                ?,
                                ?) {
                            tc_noac.stop;
                            log("*** " & testcasename() & ": FAIL: GBC message re-broadcasted ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                        }
                        [] tc_noac.timeout {
                            log("*** " & testcasename() & ": PASS: GBC message not re-broadcasted ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                        }
                    }
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BO_04_nodeD
                
            } // end GEONW_PON_GBC_BO_04
            
            group GEONW_PON_GBC_BV_05 {
                
                /**
                 * @desc    TP Function for TC_GEONW_PON_GBC_BV_05
                 */
                function f_GEONW_PON_GBC_BV_05() runs on ItsMtc {
                    
                    // Local variables
                    var ItsGeoNetworking v_nodeB;
                    var ItsGeoNetworking v_nodeC;
                    var ItsGeoNetworking v_nodeD;
                    
                    // Test control
                    if (not PICS_GN_GBC_FWD) {
                        log("*** " & testcasename() & ": PICS_GN_GBC_FWD required for executing the TC ***");
                        setverdict(inconc);
                        stop;
                    }
                    
                    // Test component configuration
                    f_cf04Up();
                    
                    // Preamble
                    
                    // Start components
                    v_nodeB := f_getComponent(c_compNodeB);
                    v_nodeC := f_getComponent(c_compNodeC);
                    v_nodeD := f_getComponent(c_compNodeD);
                    v_nodeB.start(f_GEONW_PON_GBC_BV_05_nodeB());
                    v_nodeC.start(f_GEONW_PON_GBC_BV_05_nodeC());
                    v_nodeD.start(f_GEONW_PON_GBC_BV_05_nodeD());
                    
                    // Synchronization
                    f_serverSync3ClientsAndStop({c_prDone, c_tbDone});
                    
                    // Cleanup
                    f_cf04Down();
                    
                } // end f_GEONW_PON_GBC_BV_05
                
                /**
                 * @desc    Behavior function for NodeB (TC_GEONW_PON_GBC_BV_05)
                 */
                function f_GEONW_PON_GBC_BV_05_nodeB() runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorNodeC := f_getPosition(c_compNodeC);
                    
                    // Preamble
                    f_prNeighbour();
                    f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                    
                    // Test Body
                    tc_ac.start;
                    alt {
                        [] a_receiveGeoBroadcastWithArea(
                                mw_longPosVectorPosition(v_longPosVectorNodeC),
                                ?,
                                f_getGeoBroadcastArea(c_area2)) {
                            tc_ac.stop;
                            log("*** " & testcasename() & ": PASS: GBC message correctly forwarded to area center ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                        }
                        [] tc_ac.timeout {
                            log("*** " & testcasename() & ": FAIL: GBC message not received ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                        }
                    }
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BV_05_nodeB
                
                /**
                 * @desc    Behavior function for NodeC (TC_GEONW_PON_GBC_BV_05)
                 */
                function f_GEONW_PON_GBC_BV_05_nodeC() runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorNodeC := f_getPosition(c_compNodeC);
                    var GeoNetworkingInd v_msgInd;
                    
                    // Preamble
                    f_prNeighbour();
                    f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                    
                    // Test Body
                    f_sendGeoNetMessage(
                        m_geoNwReq_linkLayerBroadcast(
                            m_geoNwPdu(
                                m_geoNwBroadcastPacket(
                                    v_longPosVectorNodeC,
                                    vc_localSeqNumber,
                                    f_getGeoBroadcastArea(c_area2)
                                )
                            )
                        )
                    );
                    f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BV_05_nodeC
                
                /**
                 * @desc    Behavior function for NodeD (TC_GEONW_PON_GBC_BV_05)
                 */
                function f_GEONW_PON_GBC_BV_05_nodeD() runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorNodeC := f_getPosition(c_compNodeC);
                    
                    // Preamble
                    f_prNeighbour();
                    f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                    
                    // Test Body
                    tc_noac.start;
                    alt {
                        [] a_receiveGeoBroadcastWithArea(
                                mw_longPosVectorPosition(v_longPosVectorNodeC),
                                ?,
                                f_getGeoBroadcastArea(c_area2)) {
                            tc_noac.stop;
                            log("*** " & testcasename() & ": FAIL: GBC message not forwarded to area center ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                        }
                        
                        [] tc_noac.timeout {
                            log("*** " & testcasename() & ": PASS: GBC message not received ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                        }
                    }
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BV_05_nodeD
                
            } // end GEONW_PON_GBC_BV_05
            
            group GEONW_PON_GBC_BO_06 {
                
                /**
                 * @desc    TP Function for TC_GEONW_PON_GBC_BO_06
                 */
                function f_GEONW_PON_GBC_BO_06() runs on ItsMtc {
                    
                    // Local variables
                    var ItsGeoNetworking v_nodeB;
                    var ItsGeoNetworking v_nodeC;
                    var ItsGeoNetworking v_nodeD;
                    var UInt16 v_sequenceNumber := f_getInitialSequenceNumber();
                    
                    // Test control
                    if (not PICS_GN_GBC_FWD) {
                        log("*** " & testcasename() & ": PICS_GN_GBC_FWD required for executing the TC ***");
                        setverdict(inconc);
                        stop;
                    }
                    if ((f_getGeoBroadcastForwardingAlgorithm() != e_simple) and (f_getGeoBroadcastForwardingAlgorithm() != e_unspecified)) {
                        log("*** " & testcasename() & ": PICS_GN_GEOBROADCAST_FORWARDING_ALGORITHM == ( e_simple or e_unspecified ) required for executing the TC ***");
                        setverdict(inconc);
                        stop;
                    }
                    
                    // Test component configuration
                    f_cf04Up();
                    
                    // Preamble
                    
                    // Start components
                    v_nodeB := f_getComponent(c_compNodeB);
                    v_nodeC := f_getComponent(c_compNodeC);
                    v_nodeD := f_getComponent(c_compNodeD);
                    v_nodeB.start(f_GEONW_PON_GBC_BO_06_nodeB());
                    v_nodeC.start(f_GEONW_PON_GBC_BO_06_nodeC(v_sequenceNumber));
                    v_nodeD.start(f_GEONW_PON_GBC_BO_06_nodeD(v_sequenceNumber));
                    
                    // Synchronization
                    f_serverSync3ClientsAndStop({c_prDone, c_tbDone});
                    
                    // Cleanup
                    f_cf04Down();
                    
                } // end f_GEONW_PON_GBC_BO_06
                
                /**
                 * @desc    Behavior function for NodeB (TC_GEONW_PON_GBC_BO_06)
                 */
                function f_GEONW_PON_GBC_BO_06_nodeB() runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorNodeC := f_getPosition(c_compNodeC);
                    var template (present) GeoNetworkingInd v_msgInd;
                    
                    // Preamble
                    f_prNeighbour();
                    tc_ac.start;
                    alt {
                        [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwBroadcastPacketWithArea(
                                mw_longPosVectorPosition(v_longPosVectorNodeC),
                                ?,
                                f_getGeoBroadcastArea(c_area2)
                            )))) -> value v_msgInd {
                            tc_ac.stop;
                            log("*** " & testcasename() & ": PASS: Pre-conditions: GBC message correctly forwarded to area center ***");
                            f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                        }
                        [] tc_ac.timeout {
                            log("*** " & testcasename() & ": INCONC: Pre-conditions: GBC message not received ***");
                            f_selfOrClientSyncAndVerdict(c_prDone, e_timeout);
                        }
                    }
                    
                    // Test Body
                    v_msgInd.msgIn.basicHeader.routerHopLimit := ?;
                    tc_noac.start;
                    alt {
                        [] geoNetworkingPort.receive(v_msgInd) {
                            tc_noac.stop;
                            log("*** " & testcasename() & ": FAIL: GBC message re-forwarded to area center ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                        }
                        [] tc_noac.timeout {
                            log("*** " & testcasename() & ": PASS: GBC message not re-forwarded ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                        }
                    }
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BO_06_nodeB
                
                /**
                 * @desc    Behavior function for NodeC (TC_GEONW_PON_GBC_BO_06)
                 */
                function f_GEONW_PON_GBC_BO_06_nodeC(in UInt16 p_sequenceNumber) runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorNodeC := f_getPosition(c_compNodeC);
                    
                    // Preamble
                    f_prNeighbour();
                    f_sendGeoNetMessage(
                        m_geoNwReq_linkLayerBroadcast(
                            m_geoNwPdu(
                                m_geoNwBroadcastPacket(
                                    v_longPosVectorNodeC,
                                    p_sequenceNumber,
                                    f_getGeoBroadcastArea(c_area2)
                                ),
                                -,
                                c_defaultHopLimit
                            )
                        )
                    );
                    f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                    
                    // Test Body
                    f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BO_06_nodeC
                
                /**
                 * @desc    Behavior function for NodeD (TC_GEONW_PON_GBC_BO_06)
                 */
                function f_GEONW_PON_GBC_BO_06_nodeD(in UInt16 p_sequenceNumber) runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorNodeC := f_getPosition(c_compNodeC);
                    
                    // Preamble
                    f_prNeighbour();
                    tc_noac.start;
                    alt {
                        [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwBroadcastPacketWithArea(
                                mw_longPosVectorPosition(v_longPosVectorNodeC),
                                ?,
                                f_getGeoBroadcastArea(c_area2)
                            )))) {
                            tc_noac.stop;
                            log("*** " & testcasename() & ": INCONC: Pre-conditions: GBC message not forwarded to area center ***");
                            f_selfOrClientSyncAndVerdict(c_prDone, e_error);
                        }
                        [] tc_noac.timeout {
                            log("*** " & testcasename() & ": PASS: Pre-conditions: GBC message not received ***");
                            f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                        }
                    }
                    
                    // Test Body
                    // send geoBroadcast for second time (same source + same seq Nr + lower RHL)
                    f_sendGeoNetMessage(
                        m_geoNwReq_linkLayerBroadcast(
                            m_geoNwPdu(
                                m_geoNwBroadcastPacket(
                                    v_longPosVectorNodeC,
                                    p_sequenceNumber,
                                    f_getGeoBroadcastArea(c_area2)
                                ),
                                -,
                                c_defaultHopLimit - 1
                            )
                        )
                    );
                    
                    tc_noac.start;
                    alt {
                        [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwBroadcastPacketWithArea(
                                mw_longPosVectorPosition(v_longPosVectorNodeC),
                                ?,
                                f_getGeoBroadcastArea(c_area2)
                            )))) {
                            tc_noac.stop;
                            log("*** " & testcasename() & ": FAIL: GBC re-forwarded! (not to area center!) ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                        }
                        [] tc_noac.timeout {
                            log("*** " & testcasename() & ": PASS: GBC message not received ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                        }
                    }
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BO_06_nodeD
                
            } // end GEONW_PON_GBC_BO_06
            
            group GEONW_PON_GBC_BV_07 {
                
                /**
                 * @desc    TP Function for TC_GEONW_PON_GBC_BV_07
                 */
                function f_GEONW_PON_GBC_BV_07() runs on ItsMtc {
                    
                    // Local variables
                    var ItsGeoNetworking v_nodeB;
                    var ItsGeoNetworking v_nodeD;
                    
                    // Test control
                    if (not PICS_GN_GBC_FWD) {
                        log("*** " & testcasename() & ": PICS_GN_GBC_FWD required for executing the TC ***");
                        setverdict(inconc);
                        stop;
                    }
                    
                    // Test component configuration
                    f_cf02Up();
                    
                    // Preamble
                    
                    // Start components
                    v_nodeB := f_getComponent(c_compNodeB);
                    v_nodeD := f_getComponent(c_compNodeD);
                    v_nodeB.start(f_GEONW_PON_GBC_BV_07_nodeB());
                    v_nodeD.start(f_GEONW_PON_GBC_BV_07_nodeD());
                    
                    // Synchronization
                    f_serverSync2ClientsAndStop({c_prDone, c_tbDone});
                    
                    // Cleanup
                    f_cf02Down();
                    
                } // end f_GEONW_PON_GBC_BV_07
                
                /**
                 * @desc    Behavior function for NodeB (TC_GEONW_PON_GBC_BV_07)
                 */
                function f_GEONW_PON_GBC_BV_07_nodeB() runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB);
                    
                    // Preamble
                    f_prNeighbour();
                    f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                    
                    // Test Body
                    f_sendGeoNetMessage(
                        m_geoNwReq_linkLayerBroadcast(
                            m_geoNwPdu(
                                m_geoNwBroadcastPacket(
                                    v_longPosVectorNodeB,
                                    vc_localSeqNumber,
                                    f_getGeoBroadcastArea(c_area1),
                                    c_defaultHopLimit
                                ),
                                -,
                                c_defaultHopLimit
                            )
                        )
                    );
                    
                    tc_ac.start;
                    alt {
                        [] a_receiveGeoBroadcastWithAreaWithHopLimit(
                                mw_longPosVectorPosition(v_longPosVectorNodeB),
                                ?,
                                f_getGeoBroadcastArea(c_area1),
                                c_defaultHopLimit - 1,
                                c_defaultHopLimit) {
                            tc_ac.stop;
                            log("*** " & testcasename() & ": PASS: GBC message correctly re-broadcasted ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                        }
                        [] tc_ac.timeout {
                            log("*** " & testcasename() & ": FAIL: GBC message not re-broadcasted ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                        }
                    }
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BV_07_nodeB
                
                /**
                 * @desc    Behavior function for NodeD (TC_GEONW_PON_GBC_BV_07)
                 */
                function f_GEONW_PON_GBC_BV_07_nodeD() runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB);
                    var GeoNetworkingInd v_msgInd;
                    
                    // Preamble
                    f_prNeighbour();
                    f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                    
                    // Test Body
                    tc_ac.start;
                    alt {
                        [] a_receiveGeoBroadcastWithAreaWithHopLimit(
                                mw_longPosVectorPosition(v_longPosVectorNodeB),
                                ?,
                                f_getGeoBroadcastArea(c_area1),
                                c_defaultHopLimit - 1,
                                c_defaultHopLimit) {
                            tc_ac.stop;
                            log("*** " & testcasename() & ": PASS: GBC message correctly re-broadcasted ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                        }
                        [] tc_ac.timeout {
                            log("*** " & testcasename() & ": FAIL: GBC message not re-broadcasted ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                        }
                    }
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BV_07_nodeD
                
            } // end GEONW_PON_GBC_BV_07
            
            group GEONW_PON_GBC_BV_08 {
                
                /**
                 * @desc    TP Function for TC_GEONW_PON_GBC_BV_08
                 */
                function f_GEONW_PON_GBC_BV_08() runs on ItsMtc {
                    
                    // Local variables
                    var ItsGeoNetworking v_nodeB;
                    var ItsGeoNetworking v_nodeD;
                    
                    // Test control
                    if (not PICS_GN_GBC_FWD) {
                        log("*** " & testcasename() & ": PICS_GN_GBC_FWD required for executing the TC ***");
                        setverdict(inconc);
                        stop;
                    }
                    
                    // Test component configuration
                    f_cf02Up();
                    
                    // Preamble
                    
                    // Start components
                    v_nodeB := f_getComponent(c_compNodeB);
                    v_nodeD := f_getComponent(c_compNodeD);
                    v_nodeB.start(f_GEONW_PON_GBC_BV_08_nodeB());
                    v_nodeD.start(f_GEONW_PON_GBC_BV_08_nodeD());
                    
                    // Synchronization
                    f_serverSync2ClientsAndStop({c_prDone, c_tbDone});
                    
                    // Cleanup
                    f_cf02Down();
                    
                } // end f_GEONW_PON_GBC_BV_08
                
                /**
                 * @desc    Behavior function for NodeB (TC_GEONW_PON_GBC_BV_08)
                 */
                function f_GEONW_PON_GBC_BV_08_nodeB() runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB);
                    
                    // Preamble
                    f_prNeighbour();
                    f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                    
                    // Test Body
                    f_sendGeoNetMessage(
                        m_geoNwReq_linkLayerBroadcast(
                            m_geoNwPdu(
                                m_geoNwBroadcastPacket(
                                    v_longPosVectorNodeB,
                                    vc_localSeqNumber,
                                    f_getGeoBroadcastArea(c_area1)
                                ),
                                -,
                                c_hopLimit1
                            )
                        )
                    );
                    
                    tc_noac.start;
                    alt {
                        [] a_receiveGeoBroadcast(
                                mw_longPosVectorPosition(v_longPosVectorNodeB),
                                ?) {
                            tc_noac.stop;
                            log("*** " & testcasename() & ": FAIL: GBC message re-broadcasted ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                        }
                        [] tc_noac.timeout {
                            log("*** " & testcasename() & ": PASS: GBC message not re-broadcasted ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                        }
                    }
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BV_08_nodeB
                
                /**
                 * @desc    Behavior function for NodeD (TC_GEONW_PON_GBC_BV_08)
                 */
                function f_GEONW_PON_GBC_BV_08_nodeD() runs on ItsGeoNetworking {
                    
                    // Local variables
                    var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB);
                    
                    // Preamble
                    f_prNeighbour();
                    f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                    
                    // Test Body
                    tc_noac.start;
                    alt {
                        [] a_receiveGeoBroadcast(
                                mw_longPosVectorPosition(v_longPosVectorNodeB),
                                ?) {
                            tc_noac.stop;
                            log("*** " & testcasename() & ": FAIL: GBC message re-broadcasted ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                        }
                        [] tc_noac.timeout {
                            log("*** " & testcasename() & ": PASS: GBC message not re-broadcasted ***");
                            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                        }
                    }
                    
                    // Postamble
                    f_poNeighbour();
                    
                } // end f_GEONW_PON_GBC_BV_08_nodeD
                
            } // end GEONW_PON_GBC_BV_08
            
            /**
             * @desc    TP Function for TC_GEONW_PON_GBC_BV_09
             */
            function f_GEONW_PON_GBC_BV_09() runs on ItsGeoNetworking {
                
                // Local variables
                var LongPosVector v_longPosVectorNodeB;
                var template (value) GeoNetworkingPdu v_gnPacket;
                var integer i;
                
                // Test control
                    if (not PICS_GN_GBC_DST) {
                        log("*** " & testcasename() & ": PICS_GN_GBC_DST required for executing the TC ***");
                        setverdict(inconc);
                        stop;
                    }
                
                // Test component configuration
                f_cf01Up();
                v_longPosVectorNodeB := f_getPosition(c_compNodeB);
                
                // Test adapter configuration
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdict(c_prDone, e_success);
                
                // Test Body
                v_gnPacket := m_geoNwPdu(m_geoNwBroadcastPacket(
                                            v_longPosVectorNodeB,
                                            vc_localSeqNumber,
                                            f_getGeoBroadcastArea(c_area1)
                                        )
                                    );
                f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(v_gnPacket));
                
                f_sleep(PX_TAC);
                
                for(i:=0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_gnPacket.gnPacket.packet.payload.rawPayload); i:=i+1) {
                    // empty on purpose 
                }
                if(i < lengthof(vc_utInds)) {
                    log("*** " & testcasename() & ": PASS: GN was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                }
                else {
                    log("*** " & testcasename() & ": FAIL: GN was not transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
                
            } // end f_GEONW_PON_GBC_BV_09
            
            group GEONW_PON_GBC_BO_10 {
                
                /**
                 * @desc    TP Function for TC_GEONW_PON_GBC_BO_10
                 */
                function f_GEONW_PON_GBC_BO_10() runs on ItsMtc {
                    
                    // Local variables
                    var ItsGeoNetworking v_nodeB;
                    var ItsGeoNetworking v_nodeD;
                    
                    // Test control
                    if (not PICS_GN_GBC_DST) {
                        log("*** " & testcasename() & ": PICS_GN_GBC_DST required for executing the TC ***");
                        setverdict(inconc);
                        stop;
                    }
                    if ((f_getGeoBroadcastForwardingAlgorithm() != e_simple) and (f_getGeoBroadcastForwardingAlgorithm() != e_unspecified)) {
                        log("*** " & testcasename() & ": PICS_GN_GEOBROADCAST_FORWARDING_ALGORITHM == ( e_simple or e_unspecified ) required for executing the TC ***");
                        setverdict(inconc);
                        stop;
                    }
                    
                    // Test component configuration
                    f_cf02Up(c_compNodeB);
                    
                    // Preamble
                    
                    // Start components
                    v_nodeB := f_getComponent(c_compNodeB);
                    v_nodeD := f_getComponent(c_compNodeD);
                    v_nodeB.start(f_GEONW_PON_GBC_BO_10_nodeB());
                    v_nodeD.start(f_GEONW_PON_GBC_BO_10_nodeD());
                    
                    // Synchronization
                    f_serverSync2ClientsAndStop({c_prDone, c_tbDone});
                    
                    // Cleanup
                    f_cf02Down();
                    
                } // end f_GEONW_PON_GBC_BO_10
                
                /**