From 991108c28ea0a4c586f73f7927d22cf5e5d72900 Mon Sep 17 00:00:00 2001 From: deoliveira Date: Thu, 11 Oct 2007 16:22:55 +0000 Subject: * Refactoring * New Tests git-svn-id: svn+ssh://pessac/svn/cesar/trunk@821 017c9cb6-072f-447c-8318-d5b54f68fe89 --- cp/msg/test/inc/test_conn.h | 8 +- cp/msg/test/src/test_msg.c | 6 + cp/msg/test/src/test_msg_cm_conn_mod_cnf.c | 801 ++++++++++++++++++++++++++ cp/msg/test/src/test_msg_cm_conn_mod_req.c | 755 +++++++++++++++++++++++++ cp/msg/test/src/test_msg_cm_conn_new_cnf.c | 816 ++++++++++++++++++++++++++ cp/msg/test/src/test_msg_cm_conn_new_req.c | 879 +++++++++++++++++++++++++++++ cp/msg/test/src/test_msg_cm_conn_rel_ind.c | 800 ++++++++++++++++++++++++++ cp/msg/test/src/test_msg_cm_conn_rel_rsp.c | 90 +++ cp/msg/test/src/test_msg_field.c | 108 ++-- 9 files changed, 4207 insertions(+), 56 deletions(-) create mode 100644 cp/msg/test/src/test_msg_cm_conn_mod_cnf.c create mode 100644 cp/msg/test/src/test_msg_cm_conn_mod_req.c create mode 100644 cp/msg/test/src/test_msg_cm_conn_new_cnf.c create mode 100644 cp/msg/test/src/test_msg_cm_conn_new_req.c create mode 100644 cp/msg/test/src/test_msg_cm_conn_rel_ind.c create mode 100644 cp/msg/test/src/test_msg_cm_conn_rel_rsp.c (limited to 'cp') diff --git a/cp/msg/test/inc/test_conn.h b/cp/msg/test/inc/test_conn.h index 263c1eb0d0..d7fe99fac9 100644 --- a/cp/msg/test/inc/test_conn.h +++ b/cp/msg/test/inc/test_conn.h @@ -24,7 +24,11 @@ // Function declaration -void conn_test_id(test_t t); void test_msg_field(test_t t); - +void test_msg_cm_conn_new_req(test_t t); +void test_msg_cm_conn_new_cnf(test_t t); +void test_msg_cm_conn_rel_ind(test_t t); +void test_msg_cm_conn_rel_rsp(test_t t); +void test_msg_cm_conn_mod_cnf(test_t t); +void test_msg_cm_conn_mod_req(test_t t); #endif /*TEST_H_*/ diff --git a/cp/msg/test/src/test_msg.c b/cp/msg/test/src/test_msg.c index c16ba9f164..080e6fe602 100644 --- a/cp/msg/test/src/test_msg.c +++ b/cp/msg/test/src/test_msg.c @@ -25,6 +25,12 @@ int main(int argc, char ** argv) test_init(t, argc, argv); test_msg_field(t); + test_msg_cm_conn_new_req(t); + test_msg_cm_conn_new_cnf(t); + test_msg_cm_conn_rel_ind(t); + test_msg_cm_conn_rel_rsp(t); + test_msg_cm_conn_mod_cnf(t); + test_msg_cm_conn_mod_req(t); test_result (t); HAL_PLATFORM_EXIT (test_nb_failed (t) == 0 ? 0 : 1); return test_nb_failed (t) == 0 ? 0 : 1;; diff --git a/cp/msg/test/src/test_msg_cm_conn_mod_cnf.c b/cp/msg/test/src/test_msg_cm_conn_mod_cnf.c new file mode 100644 index 0000000000..60c0fcfad1 --- /dev/null +++ b/cp/msg/test/src/test_msg_cm_conn_mod_cnf.c @@ -0,0 +1,801 @@ +/* Cesar project {{{ + * + * Copyright (C) 2007 Spidcom + * + * <<>> + * + * }}} + * \file test_msg_cm_conn_mod_cnf.c + * \brief File Description + * \ingroup cp/msg + * + */ + + +#include "common/std.h" +#include "cp/msg/inc/msg_cm.h" + + +msg_mme_t msg_cm_conn_mod_cnf_1 = +{ + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA + 0, // vlan tag + 0x88E1, + 0, // mmv + CM_CONN_MOD_CNF, + {0,0,0}, + { + 0x53, // CID + 0x25, // CID + 0x00 // result (=success) + } +}; + +msg_mme_t msg_cm_conn_mod_cnf_2 = +{ + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA + 0, // vlan tag + 0x88E1, + 0, // mmv + CM_CONN_MOD_CNF, + {0,0,0}, + { + 0x53, // CID + 0x25, // CID + 0x01, // result (=failure) + 0x01, // CSPEC Length :338 bytes + 0x54, // CSPEC Length : + CINFO_VALID, // CINFO Valid? CINFO Forward + MAC_CONTENTION, // Mac Service Type + USER_PRIORITY_CAP0, // User Priori ty + ATS_FOR_HLE, // Arrival Time Stamp + SMOOTHING_REQUESTED, // Smoothing + CINFO_VALID, // CINFO Valid? CINFO Reverse + MAC_CONTENTION, // Mac Service Type + USER_PRIORITY_CAP0, // User Priority + ATS_FOR_HLE, // Arrival Time Stamp + SMOOTHING_REQUESTED, // Smoothing + QMP_FORWARD, + 0x04, // QMP body length + 0x00, // FID: Delay bound + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + QMP_FORWARD, + 0x04, // QMP body length + 0x01, // FID: Jitter bound + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x02, // FID: Average MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x03, // FID: Maximum MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x04, // FID: Average Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x05, // FID: Minimum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x06, // FID: Maximum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x07, // FID: Maximum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x08, // FID: Minimum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x09, // FID: Maximum Burst Size + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x0A, // FID: Exception Policy + 0x01, // QMP BODY + QMP_FORWARD, + 0x04, // QMP body length + 0x0B, // FID: inactivity_interval + 0x00, // QMP BODY + 0xFF, // QMP BODY + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x0C, // FID: MSDU Error Rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x0D, // FID: CLST + 0x00, // QMP BODY + QMP_FORWARD, + 0x0E, // QMP body length + 0x0E, // FID: CDESC + 0x00, // IP Version 4 + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x0F, // source port + 0xF1, // source port + 0x01, // Dest IP + 0x01, // dest IP + 0x01, // dest IP + 0x01, // dest IP + 0xFF, // dest port + 0xF1, // dest port + 0x00, // ip proto type + QMP_FORWARD, + 0x02, // QMP body length + 0x10, // FID: ATS Tolerance + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x11, // FID: Smallest tolerable Average data rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x12, // FID: Original Average data rate + 0x00, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x13, // FID: rx_window_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x03, // QMP body length + 0x14, // FID: smoothing_buffer_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + 0x10, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x15, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x80, // FID: TXOPs per Beacon Period + 0x15, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x81, // FID: Average Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x82, // FID: Minimum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x83, // FID: Maximum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x84, // FID: PPB_Threshold + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x85, // FID: Surplus Bandwidth + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x88, // FID: Original Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x89, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x00, // FID: Delay bound + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x01, // FID: Jitter bound + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x02, // FID: Average MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x03, // FID: Maximum MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x04, // FID: Average Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x05, // FID: Minimum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x06, // FID: Maximum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x07, // FID: Maximum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x08, // FID: Minimum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x09, // FID: Maximum Burst Size + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x0A, // FID: Exception Policy + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x0B, // FID: inactivity_interval + 0x00, // QMP BODY + 0xFF, // QMP BODY + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x0C, // FID: MSDU Error Rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x0D, // FID: CLST + 0x00, // QMP BODY + QMP_REVERSE, + 0x0E, // QMP body length + 0x0E, // FID: CDESC + 0x00, // IP Version 4 + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x0F, // source port + 0xF1, // source port + 0x01, // Dest IP + 0x01, // dest IP + 0x01, // dest IP + 0x01, // dest IP + 0xFF, // dest port + 0xF1, // dest port + 0x00, // ip proto type + QMP_REVERSE, + 0x02, // QMP body length + 0x10, // FID: ATS Tolerance + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x11, // FID: Smallest tolerable Average data rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x12, // FID: Original Average data rate + 0x00, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x13, // FID: rx_window_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x03, // QMP body length + 0x14, // FID: smoothing_buffer_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + 0x10, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x15, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x80, // FID: TXOPs per Beacon Period + 0x15, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x81, // FID: Average Number of PBs per TXOP + 0x10, // QMP BODY copy + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x82, // FID: Minimum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x83, // FID: Maximum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x84, // FID: PPB_Threshold + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x85, // FID: Surplus Bandwidth + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x88, // FID: Original Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x89, // FID: Bidirectional Burst + 0x01 // QMP BODY + } +}; + + +void +test_msg_cm_conn_mod_cnf_get_from_mme_msg(test_t t) +{ + msg_cm_conn_mod_cnf_t msg; + + test_case_begin(t, "TEST cm_conn_mod_cnf_get_from_mme_msg"); + + test_begin(t, "test case 1") + { + msg_cm_conn_mod_cnf_init(&msg); + + msg_cm_conn_mod_cnf_get_from_mme_msg( &msg_cm_conn_mod_cnf_1, &msg); + + test_fail_unless(msg.cid == 0x5325); + test_fail_unless(msg.result == CONN_MOD_SUCCESS); + + }test_end; + + test_begin(t, "test case 2") + { + + msg_cm_conn_mod_cnf_init(&msg); + + msg_cm_conn_mod_cnf_get_from_mme_msg( &msg_cm_conn_mod_cnf_2, &msg); + + test_fail_unless( msg.cid == 0x5325 ); + test_fail_unless( msg.result == CONN_MOD_FAILED ); + + + + + // CINFO FORWARD + test_fail_unless( msg.proposed_cspec.cinfo_forward.valid == CINFO_VALID); + test_fail_unless( msg.proposed_cspec.cinfo_forward.mac_service_type == MAC_CONTENTION); + test_fail_unless( msg.proposed_cspec.cinfo_forward.user_priority == USER_PRIORITY_CAP0); + test_fail_unless( msg.proposed_cspec.cinfo_forward.ats == ATS_FOR_HLE); + test_fail_unless( msg.proposed_cspec.cinfo_forward.smoothing == SMOOTHING_REQUESTED); + + // CINFO REVERSE + test_fail_unless( msg.proposed_cspec.cinfo_reverse.valid == CINFO_VALID ); + test_fail_unless( msg.proposed_cspec.cinfo_reverse.mac_service_type == MAC_CONTENTION ); + test_fail_unless( msg.proposed_cspec.cinfo_reverse.user_priority == USER_PRIORITY_CAP0 ); + test_fail_unless( msg.proposed_cspec.cinfo_reverse.ats == ATS_FOR_HLE ); + test_fail_unless( msg.proposed_cspec.cinfo_reverse.smoothing == SMOOTHING_REQUESTED ); + + // QMP FORWARD + test_fail_unless( msg.proposed_cspec.qmp_forward.forward_or_reverse == QMP_FORWARD); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.delay_bound_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.jitter_bound_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.average_msdu_size_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.maximum_msdu_size_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.average_data_rate_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.minimum_data_rate_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.maximum_data_rate_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.minimum_inter_txop_time_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.maximum_inter_txop_time_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.maximum_burst_size_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.exception_policy_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.inactivity_interval_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.msdu_error_rate_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.clst_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.cdesc_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.ats_tolerance_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.smallest_tolerable_data_rate_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.original_average_data_rate_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.rx_window_size_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.smoothing_buffer_size_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.bidirectional_burst_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.txops_per_beacon_period_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.ppb_threshold_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.surplus_bandwith_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.valid.cco_bidirectional_burst_available == true); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.delay_bound == 0x01010101); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.jitter_bound == 0x10101010); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.average_msdu_size == 0XF0F0); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.maximum_msdu_size == 0XF0F0); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.average_data_rate == 0x0F0F); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.minimum_data_rate == 0x0F0F); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.maximum_data_rate == 0x0F0F); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.maximum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.minimum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.maximum_burst_size == 0x00FF); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.inactivity_interval == 0X00FF00FF); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.msdu_error_rate == 0x00FF); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.clst == 0x00); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ip_version == 0x00); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.source_port == 0x0FF1); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.destination_port == 0xFFF1); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.protocol_type == 0x00); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.ats_tolerance == 0x00FF); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.smallest_tolerable_data_rate == 0x00FF); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.original_average_data_rate == 0x000F); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.rx_window_size == 0x100F); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.smoothing_buffer_size == 0x100F10); + test_fail_unless( msg.proposed_cspec.qmp_forward.cm.bidirectional_burst == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_forward.cco.txops_per_beacon_period == 0x15); + test_fail_unless( msg.proposed_cspec.qmp_forward.cco.average_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.proposed_cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.proposed_cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.proposed_cspec.qmp_forward.cco.ppb_threshold == 0x0FF0); + test_fail_unless( msg.proposed_cspec.qmp_forward.cco.surplus_bandwith == 0x0FF0); + test_fail_unless( msg.proposed_cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.proposed_cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.proposed_cspec.qmp_forward.cco.cco_bidirectional_burst == 0x01); + + + // QMP REVERSE + test_fail_unless( msg.proposed_cspec.qmp_reverse.forward_or_reverse == QMP_REVERSE); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.delay_bound_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.jitter_bound_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.average_msdu_size_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.maximum_msdu_size_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.average_data_rate_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.minimum_data_rate_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.maximum_data_rate_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.minimum_inter_txop_time_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.maximum_inter_txop_time_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.maximum_burst_size_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.exception_policy_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.inactivity_interval_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.msdu_error_rate_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.clst_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.cdesc_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.ats_tolerance_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.original_average_data_rate_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.rx_window_size_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.smoothing_buffer_size_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.bidirectional_burst_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.txops_per_beacon_period_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.ppb_threshold_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.surplus_bandwith_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.cco_bidirectional_burst_available == true); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.delay_bound == 0x01010101); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.jitter_bound == 0x10101010); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.average_msdu_size == 0XF0F0); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.maximum_msdu_size == 0XF0F0); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.average_data_rate == 0x0F0F); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.minimum_data_rate == 0x0F0F); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.maximum_data_rate == 0x0F0F); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.maximum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.minimum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.maximum_burst_size == 0x00FF); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.inactivity_interval == 0X00FF00FF); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.msdu_error_rate == 0x00FF); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.clst == 0x00); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ip_version == 0x00); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.source_port == 0x0FF1); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.destination_port == 0xFFF1); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.protocol_type == 0x00); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.ats_tolerance == 0x00FF); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.smallest_tolerable_data_rate == 0x00FF); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.original_average_data_rate == 0x000F); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.rx_window_size == 0x100F); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.smoothing_buffer_size == 0x100F10); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.bidirectional_burst == 0x01); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.txops_per_beacon_period == 0x15); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.average_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.ppb_threshold == 0x0FF0); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.surplus_bandwith == 0x0FF0); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.cco_bidirectional_burst == 0x01); + + test_fail_unless( msg.proposed_cspec.len == 0x0154 ); + + }test_end; + +} + + +void +test_msg_cm_conn_mod_cnf_set_on_mme_msg(test_t t) +{ + msg_cm_conn_mod_cnf_t msg; + msg_mme_t test_msg; + int i; + + test_case_begin(t, "TEST cm_conn_mod_cnf_set_on_mme_msg"); + + test_begin(t, "test case 1") + { + msg_cm_conn_mod_cnf_init(&msg); + + msg.cid = 0x5325; + msg.result = CONN_MOD_SUCCESS; + + msg_cm_conn_mod_cnf_set_on_mme_msg(&test_msg, &msg); + + for(i=0; i< 2;i++) + { + test_fail_unless( test_msg.mm_entry[i] == msg_cm_conn_mod_cnf_1.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_msg.mm_entry[i],msg_cm_conn_mod_cnf_1.mm_entry[i]); + } + + }test_end; + + test_begin(t, "test case 2") + { + msg.cid = 0x5325; + msg.result = CONN_MOD_FAILED; + + msg.proposed_cspec.cinfo_forward.valid = CINFO_VALID; + msg.proposed_cspec.cinfo_forward.mac_service_type = MAC_CONTENTION; + msg.proposed_cspec.cinfo_forward.user_priority = USER_PRIORITY_CAP0; + msg.proposed_cspec.cinfo_forward.ats = ATS_FOR_HLE; + msg.proposed_cspec.cinfo_forward.smoothing = SMOOTHING_REQUESTED; + msg.proposed_cspec.cinfo_reverse.valid = CINFO_VALID ; + msg.proposed_cspec.cinfo_reverse.mac_service_type = MAC_CONTENTION ; + msg.proposed_cspec.cinfo_reverse.user_priority = USER_PRIORITY_CAP0 ; + msg.proposed_cspec.cinfo_reverse.ats = ATS_FOR_HLE ; + msg.proposed_cspec.cinfo_reverse.smoothing = SMOOTHING_REQUESTED ; + msg.proposed_cspec.qmp_forward.forward_or_reverse = QMP_FORWARD; + msg.proposed_cspec.qmp_forward.valid.delay_bound_available = true; + msg.proposed_cspec.qmp_forward.valid.jitter_bound_available = true; + msg.proposed_cspec.qmp_forward.valid.average_msdu_size_available = true; + msg.proposed_cspec.qmp_forward.valid.maximum_msdu_size_available = true; + msg.proposed_cspec.qmp_forward.valid.average_data_rate_available = true; + msg.proposed_cspec.qmp_forward.valid.minimum_data_rate_available = true; + msg.proposed_cspec.qmp_forward.valid.maximum_data_rate_available = true; + msg.proposed_cspec.qmp_forward.valid.minimum_inter_txop_time_available = true; + msg.proposed_cspec.qmp_forward.valid.maximum_inter_txop_time_available = true; + msg.proposed_cspec.qmp_forward.valid.maximum_burst_size_available = true; + msg.proposed_cspec.qmp_forward.valid.exception_policy_available = true; + msg.proposed_cspec.qmp_forward.valid.inactivity_interval_available = true; + msg.proposed_cspec.qmp_forward.valid.msdu_error_rate_available = true; + msg.proposed_cspec.qmp_forward.valid.clst_available = true; + msg.proposed_cspec.qmp_forward.valid.cdesc_available = true; + msg.proposed_cspec.qmp_forward.valid.ats_tolerance_available = true; + msg.proposed_cspec.qmp_forward.valid.smallest_tolerable_data_rate_available = true; + msg.proposed_cspec.qmp_forward.valid.original_average_data_rate_available = true; + msg.proposed_cspec.qmp_forward.valid.rx_window_size_available = true; + msg.proposed_cspec.qmp_forward.valid.smoothing_buffer_size_available = true; + msg.proposed_cspec.qmp_forward.valid.bidirectional_burst_available = true; + msg.proposed_cspec.qmp_forward.valid.txops_per_beacon_period_available = true; + msg.proposed_cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available = true; + msg.proposed_cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available = true; + msg.proposed_cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available = true; + msg.proposed_cspec.qmp_forward.valid.ppb_threshold_available = true; + msg.proposed_cspec.qmp_forward.valid.surplus_bandwith_available = true; + msg.proposed_cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true; + msg.proposed_cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available = true; + msg.proposed_cspec.qmp_forward.valid.cco_bidirectional_burst_available = true; + msg.proposed_cspec.qmp_forward.cm.delay_bound = 0x01010101; + msg.proposed_cspec.qmp_forward.cm.jitter_bound = 0x10101010; + msg.proposed_cspec.qmp_forward.cm.average_msdu_size = 0XF0F0; + msg.proposed_cspec.qmp_forward.cm.maximum_msdu_size = 0XF0F0; + msg.proposed_cspec.qmp_forward.cm.average_data_rate = 0x0F0F; + msg.proposed_cspec.qmp_forward.cm.minimum_data_rate = 0x0F0F; + msg.proposed_cspec.qmp_forward.cm.maximum_data_rate = 0x0F0F; + msg.proposed_cspec.qmp_forward.cm.maximum_inter_txop_time = 0xFFFF; + msg.proposed_cspec.qmp_forward.cm.minimum_inter_txop_time = 0xFFFF; + msg.proposed_cspec.qmp_forward.cm.maximum_burst_size = 0x00FF; + msg.proposed_cspec.qmp_forward.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION; + msg.proposed_cspec.qmp_forward.cm.inactivity_interval = 0X00FF00FF; + msg.proposed_cspec.qmp_forward.cm.msdu_error_rate = 0x00FF; + msg.proposed_cspec.qmp_forward.cm.clst = 0x00; + msg.proposed_cspec.qmp_forward.cm.cdesc.ip_version = 0x00; + msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] = 0x01; + msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] = 0x01; + msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] = 0x01; + msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] = 0x01; + msg.proposed_cspec.qmp_forward.cm.cdesc.source_port = 0x0FF1; + msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] = 0x01; + msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] = 0x01; + msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] = 0x01; + msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] = 0x01; + msg.proposed_cspec.qmp_forward.cm.cdesc.destination_port = 0xFFF1; + msg.proposed_cspec.qmp_forward.cm.cdesc.protocol_type = 0x00; + msg.proposed_cspec.qmp_forward.cm.ats_tolerance = 0x00FF; + msg.proposed_cspec.qmp_forward.cm.smallest_tolerable_data_rate = 0x00FF; + msg.proposed_cspec.qmp_forward.cm.original_average_data_rate = 0x000F; + msg.proposed_cspec.qmp_forward.cm.rx_window_size = 0x100F; + msg.proposed_cspec.qmp_forward.cm.smoothing_buffer_size = 0x100F10; + msg.proposed_cspec.qmp_forward.cm.bidirectional_burst = 0x01; + msg.proposed_cspec.qmp_forward.cco.txops_per_beacon_period = 0x15; + msg.proposed_cspec.qmp_forward.cco.average_number_of_pbs_per_txop = 0x100F; + msg.proposed_cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop = 0x100F; + msg.proposed_cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop = 0x100F; + msg.proposed_cspec.qmp_forward.cco.ppb_threshold = 0x0FF0; + msg.proposed_cspec.qmp_forward.cco.surplus_bandwith = 0x0FF0; + msg.proposed_cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0; + msg.proposed_cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop = 0x0FF0; + msg.proposed_cspec.qmp_forward.cco.cco_bidirectional_burst = 0x01; + msg.proposed_cspec.qmp_reverse.forward_or_reverse = QMP_REVERSE; + msg.proposed_cspec.qmp_reverse.valid.delay_bound_available = true; + msg.proposed_cspec.qmp_reverse.valid.jitter_bound_available = true; + msg.proposed_cspec.qmp_reverse.valid.average_msdu_size_available = true; + msg.proposed_cspec.qmp_reverse.valid.maximum_msdu_size_available = true; + msg.proposed_cspec.qmp_reverse.valid.average_data_rate_available = true; + msg.proposed_cspec.qmp_reverse.valid.minimum_data_rate_available = true; + msg.proposed_cspec.qmp_reverse.valid.maximum_data_rate_available = true; + msg.proposed_cspec.qmp_reverse.valid.minimum_inter_txop_time_available = true; + msg.proposed_cspec.qmp_reverse.valid.maximum_inter_txop_time_available = true; + msg.proposed_cspec.qmp_reverse.valid.maximum_burst_size_available = true; + msg.proposed_cspec.qmp_reverse.valid.exception_policy_available = true; + msg.proposed_cspec.qmp_reverse.valid.inactivity_interval_available = true; + msg.proposed_cspec.qmp_reverse.valid.msdu_error_rate_available = true; + msg.proposed_cspec.qmp_reverse.valid.clst_available = true; + msg.proposed_cspec.qmp_reverse.valid.cdesc_available = true; + msg.proposed_cspec.qmp_reverse.valid.ats_tolerance_available = true; + msg.proposed_cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available = true; + msg.proposed_cspec.qmp_reverse.valid.original_average_data_rate_available = true; + msg.proposed_cspec.qmp_reverse.valid.rx_window_size_available = true; + msg.proposed_cspec.qmp_reverse.valid.smoothing_buffer_size_available = true; + msg.proposed_cspec.qmp_reverse.valid.bidirectional_burst_available = true; + msg.proposed_cspec.qmp_reverse.valid.txops_per_beacon_period_available = true; + msg.proposed_cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available = true; + msg.proposed_cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available = true; + msg.proposed_cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available = true; + msg.proposed_cspec.qmp_reverse.valid.ppb_threshold_available = true; + msg.proposed_cspec.qmp_reverse.valid.surplus_bandwith_available = true; + msg.proposed_cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true; + msg.proposed_cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available = true; + msg.proposed_cspec.qmp_reverse.valid.cco_bidirectional_burst_available = true; + msg.proposed_cspec.qmp_reverse.cm.delay_bound = 0x01010101; + msg.proposed_cspec.qmp_reverse.cm.jitter_bound = 0x10101010; + msg.proposed_cspec.qmp_reverse.cm.average_msdu_size = 0XF0F0; + msg.proposed_cspec.qmp_reverse.cm.maximum_msdu_size = 0XF0F0; + msg.proposed_cspec.qmp_reverse.cm.average_data_rate = 0x0F0F; + msg.proposed_cspec.qmp_reverse.cm.minimum_data_rate = 0x0F0F; + msg.proposed_cspec.qmp_reverse.cm.maximum_data_rate = 0x0F0F; + msg.proposed_cspec.qmp_reverse.cm.maximum_inter_txop_time = 0xFFFF; + msg.proposed_cspec.qmp_reverse.cm.minimum_inter_txop_time = 0xFFFF; + msg.proposed_cspec.qmp_reverse.cm.maximum_burst_size = 0x00FF; + msg.proposed_cspec.qmp_reverse.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION; + msg.proposed_cspec.qmp_reverse.cm.inactivity_interval = 0X00FF00FF; + msg.proposed_cspec.qmp_reverse.cm.msdu_error_rate = 0x00FF; + msg.proposed_cspec.qmp_reverse.cm.clst = 0x00; + msg.proposed_cspec.qmp_reverse.cm.cdesc.ip_version = 0x00; + msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] = 0x01; + msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] = 0x01; + msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] = 0x01; + msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] = 0x01; + msg.proposed_cspec.qmp_reverse.cm.cdesc.source_port = 0x0FF1; + msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] = 0x01; + msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] = 0x01; + msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] = 0x01; + msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] = 0x01; + msg.proposed_cspec.qmp_reverse.cm.cdesc.destination_port = 0xFFF1; + msg.proposed_cspec.qmp_reverse.cm.cdesc.protocol_type = 0x00; + msg.proposed_cspec.qmp_reverse.cm.ats_tolerance = 0x00FF; + msg.proposed_cspec.qmp_reverse.cm.smallest_tolerable_data_rate = 0x00FF; + msg.proposed_cspec.qmp_reverse.cm.original_average_data_rate = 0x000F; + msg.proposed_cspec.qmp_reverse.cm.rx_window_size = 0x100F; + msg.proposed_cspec.qmp_reverse.cm.smoothing_buffer_size = 0x100F10; + msg.proposed_cspec.qmp_reverse.cm.bidirectional_burst = 0x01; + msg.proposed_cspec.qmp_reverse.cco.txops_per_beacon_period = 0x15; + msg.proposed_cspec.qmp_reverse.cco.average_number_of_pbs_per_txop = 0x100F; + msg.proposed_cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop = 0x100F; + msg.proposed_cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop = 0x100F; + msg.proposed_cspec.qmp_reverse.cco.ppb_threshold = 0x0FF0; + msg.proposed_cspec.qmp_reverse.cco.surplus_bandwith = 0x0FF0; + msg.proposed_cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0; + msg.proposed_cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop = 0x0FF0; + msg.proposed_cspec.qmp_reverse.cco.cco_bidirectional_burst = 0x01; + msg.proposed_cspec.len = 0x0154 ; + + msg_cm_conn_mod_cnf_set_on_mme_msg(&test_msg, &msg); + + for(i=0; i< 341;i++) + { + test_fail_unless( test_msg.mm_entry[i] == msg_cm_conn_mod_cnf_2.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_msg.mm_entry[i],msg_cm_conn_mod_cnf_2.mm_entry[i]); + } + + }test_end; + +} + + +void +test_msg_cm_conn_mod_cnf(test_t t) +{ + dbg_assert(t); + + test_suite_begin(t, "TEST MESSAGE CM_CONN_MOD_CNF"); + + test_msg_cm_conn_mod_cnf_get_from_mme_msg(t); + test_msg_cm_conn_mod_cnf_set_on_mme_msg(t); + +} diff --git a/cp/msg/test/src/test_msg_cm_conn_mod_req.c b/cp/msg/test/src/test_msg_cm_conn_mod_req.c new file mode 100644 index 0000000000..2152156aed --- /dev/null +++ b/cp/msg/test/src/test_msg_cm_conn_mod_req.c @@ -0,0 +1,755 @@ +/* Cesar project {{{ + * + * Copyright (C) 2007 Spidcom + * + * <<>> + * + * }}} + * \file test_msg_cm_conn_mod_req.c + * \brief File Description + * \ingroup cp/msg + * + */ + + +#include "common/std.h" +#include "cp/msg/inc/msg_cm.h" + + +msg_mme_t msg_cm_conn_mod_req_1 = +{ + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA + 0, // vlan tag + 0x88E1, + 0, // mmv + CM_CONN_MOD_REQ, + {0,0,0}, + { + 0x53, // CID + 0x25, // CID + 0x01, // CSPEC Length :338 bytes + 0x54, // CSPEC Length : + CINFO_VALID, // CINFO Valid? CINFO Forward + MAC_CONTENTION, // Mac Service Type + USER_PRIORITY_CAP0, // User Priori ty + ATS_FOR_HLE, // Arrival Time Stamp + SMOOTHING_REQUESTED, // Smoothing + CINFO_VALID, // CINFO Valid? CINFO Reverse + MAC_CONTENTION, // Mac Service Type + USER_PRIORITY_CAP0, // User Priority + ATS_FOR_HLE, // Arrival Time Stamp + SMOOTHING_REQUESTED, // Smoothing + QMP_FORWARD, + 0x04, // QMP body length + 0x00, // FID: Delay bound + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + QMP_FORWARD, + 0x04, // QMP body length + 0x01, // FID: Jitter bound + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x02, // FID: Average MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x03, // FID: Maximum MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x04, // FID: Average Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x05, // FID: Minimum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x06, // FID: Maximum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x07, // FID: Maximum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x08, // FID: Minimum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x09, // FID: Maximum Burst Size + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x0A, // FID: Exception Policy + 0x01, // QMP BODY + QMP_FORWARD, + 0x04, // QMP body length + 0x0B, // FID: inactivity_interval + 0x00, // QMP BODY + 0xFF, // QMP BODY + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x0C, // FID: MSDU Error Rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x0D, // FID: CLST + 0x00, // QMP BODY + QMP_FORWARD, + 0x0E, // QMP body length + 0x0E, // FID: CDESC + 0x00, // IP Version 4 + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x0F, // source port + 0xF1, // source port + 0x01, // Dest IP + 0x01, // dest IP + 0x01, // dest IP + 0x01, // dest IP + 0xFF, // dest port + 0xF1, // dest port + 0x00, // ip proto type + QMP_FORWARD, + 0x02, // QMP body length + 0x10, // FID: ATS Tolerance + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x11, // FID: Smallest tolerable Average data rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x12, // FID: Original Average data rate + 0x00, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x13, // FID: rx_window_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x03, // QMP body length + 0x14, // FID: smoothing_buffer_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + 0x10, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x15, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x80, // FID: TXOPs per Beacon Period + 0x15, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x81, // FID: Average Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x82, // FID: Minimum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x83, // FID: Maximum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x84, // FID: PPB_Threshold + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x85, // FID: Surplus Bandwidth + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x88, // FID: Original Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x89, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x00, // FID: Delay bound + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x01, // FID: Jitter bound + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x02, // FID: Average MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x03, // FID: Maximum MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x04, // FID: Average Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x05, // FID: Minimum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x06, // FID: Maximum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x07, // FID: Maximum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x08, // FID: Minimum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x09, // FID: Maximum Burst Size + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x0A, // FID: Exception Policy + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x0B, // FID: inactivity_interval + 0x00, // QMP BODY + 0xFF, // QMP BODY + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x0C, // FID: MSDU Error Rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x0D, // FID: CLST + 0x00, // QMP BODY + QMP_REVERSE, + 0x0E, // QMP body length + 0x0E, // FID: CDESC + 0x00, // IP Version 4 + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x0F, // source port + 0xF1, // source port + 0x01, // Dest IP + 0x01, // dest IP + 0x01, // dest IP + 0x01, // dest IP + 0xFF, // dest port + 0xF1, // dest port + 0x00, // ip proto type + QMP_REVERSE, + 0x02, // QMP body length + 0x10, // FID: ATS Tolerance + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x11, // FID: Smallest tolerable Average data rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x12, // FID: Original Average data rate + 0x00, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x13, // FID: rx_window_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x03, // QMP body length + 0x14, // FID: smoothing_buffer_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + 0x10, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x15, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x80, // FID: TXOPs per Beacon Period + 0x15, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x81, // FID: Average Number of PBs per TXOP + 0x10, // QMP BODY copy + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x82, // FID: Minimum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x83, // FID: Maximum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x84, // FID: PPB_Threshold + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x85, // FID: Surplus Bandwidth + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x88, // FID: Original Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x89, // FID: Bidirectional Burst + 0x01 // QMP BODY + } +}; + + +void +test_msg_cm_conn_mod_req_get_from_mme_msg(test_t t) +{ + msg_cm_conn_mod_req_t msg; + + test_case_begin(t, "TEST cm_conn_mod_req_get_from_mme_msg"); + + test_begin(t, "test case 1") + { + + msg_cm_conn_mod_req_init(&msg); + + msg_cm_conn_mod_req_get_from_mme_msg( &msg_cm_conn_mod_req_1, &msg); + + test_fail_unless( msg.cid == 0x5325 ); + + // CINFO FORWARD + test_fail_unless( msg.modified_cspec.cinfo_forward.valid == CINFO_VALID); + test_fail_unless( msg.modified_cspec.cinfo_forward.mac_service_type == MAC_CONTENTION); + test_fail_unless( msg.modified_cspec.cinfo_forward.user_priority == USER_PRIORITY_CAP0); + test_fail_unless( msg.modified_cspec.cinfo_forward.ats == ATS_FOR_HLE); + test_fail_unless( msg.modified_cspec.cinfo_forward.smoothing == SMOOTHING_REQUESTED); + + // CINFO REVERSE + test_fail_unless( msg.modified_cspec.cinfo_reverse.valid == CINFO_VALID ); + test_fail_unless( msg.modified_cspec.cinfo_reverse.mac_service_type == MAC_CONTENTION ); + test_fail_unless( msg.modified_cspec.cinfo_reverse.user_priority == USER_PRIORITY_CAP0 ); + test_fail_unless( msg.modified_cspec.cinfo_reverse.ats == ATS_FOR_HLE ); + test_fail_unless( msg.modified_cspec.cinfo_reverse.smoothing == SMOOTHING_REQUESTED ); + + // QMP FORWARD + test_fail_unless( msg.modified_cspec.qmp_forward.forward_or_reverse == QMP_FORWARD); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.delay_bound_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.jitter_bound_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.average_msdu_size_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.maximum_msdu_size_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.average_data_rate_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.minimum_data_rate_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.maximum_data_rate_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.minimum_inter_txop_time_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.maximum_inter_txop_time_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.maximum_burst_size_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.exception_policy_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.inactivity_interval_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.msdu_error_rate_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.clst_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.cdesc_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.ats_tolerance_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.smallest_tolerable_data_rate_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.original_average_data_rate_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.rx_window_size_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.smoothing_buffer_size_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.bidirectional_burst_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.txops_per_beacon_period_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.ppb_threshold_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.surplus_bandwith_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.valid.cco_bidirectional_burst_available == true); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.delay_bound == 0x01010101); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.jitter_bound == 0x10101010); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.average_msdu_size == 0XF0F0); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.maximum_msdu_size == 0XF0F0); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.average_data_rate == 0x0F0F); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.minimum_data_rate == 0x0F0F); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.maximum_data_rate == 0x0F0F); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.maximum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.minimum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.maximum_burst_size == 0x00FF); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.inactivity_interval == 0X00FF00FF); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.msdu_error_rate == 0x00FF); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.clst == 0x00); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ip_version == 0x00); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.source_port == 0x0FF1); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.destination_port == 0xFFF1); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.protocol_type == 0x00); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.ats_tolerance == 0x00FF); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.smallest_tolerable_data_rate == 0x00FF); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.original_average_data_rate == 0x000F); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.rx_window_size == 0x100F); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.smoothing_buffer_size == 0x100F10); + test_fail_unless( msg.modified_cspec.qmp_forward.cm.bidirectional_burst == 0x01); + test_fail_unless( msg.modified_cspec.qmp_forward.cco.txops_per_beacon_period == 0x15); + test_fail_unless( msg.modified_cspec.qmp_forward.cco.average_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.modified_cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.modified_cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.modified_cspec.qmp_forward.cco.ppb_threshold == 0x0FF0); + test_fail_unless( msg.modified_cspec.qmp_forward.cco.surplus_bandwith == 0x0FF0); + test_fail_unless( msg.modified_cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.modified_cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.modified_cspec.qmp_forward.cco.cco_bidirectional_burst == 0x01); + + + // QMP REVERSE + test_fail_unless( msg.modified_cspec.qmp_reverse.forward_or_reverse == QMP_REVERSE); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.delay_bound_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.jitter_bound_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.average_msdu_size_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.maximum_msdu_size_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.average_data_rate_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.minimum_data_rate_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.maximum_data_rate_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.minimum_inter_txop_time_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.maximum_inter_txop_time_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.maximum_burst_size_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.exception_policy_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.inactivity_interval_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.msdu_error_rate_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.clst_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.cdesc_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.ats_tolerance_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.original_average_data_rate_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.rx_window_size_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.smoothing_buffer_size_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.bidirectional_burst_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.txops_per_beacon_period_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.ppb_threshold_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.surplus_bandwith_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.valid.cco_bidirectional_burst_available == true); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.delay_bound == 0x01010101); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.jitter_bound == 0x10101010); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.average_msdu_size == 0XF0F0); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.maximum_msdu_size == 0XF0F0); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.average_data_rate == 0x0F0F); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.minimum_data_rate == 0x0F0F); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.maximum_data_rate == 0x0F0F); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.maximum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.minimum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.maximum_burst_size == 0x00FF); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.inactivity_interval == 0X00FF00FF); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.msdu_error_rate == 0x00FF); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.clst == 0x00); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ip_version == 0x00); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.source_port == 0x0FF1); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] == 0x01); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.destination_port == 0xFFF1); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.protocol_type == 0x00); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.ats_tolerance == 0x00FF); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.smallest_tolerable_data_rate == 0x00FF); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.original_average_data_rate == 0x000F); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.rx_window_size == 0x100F); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.smoothing_buffer_size == 0x100F10); + test_fail_unless( msg.modified_cspec.qmp_reverse.cm.bidirectional_burst == 0x01); + test_fail_unless( msg.modified_cspec.qmp_reverse.cco.txops_per_beacon_period == 0x15); + test_fail_unless( msg.modified_cspec.qmp_reverse.cco.average_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.modified_cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.modified_cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.modified_cspec.qmp_reverse.cco.ppb_threshold == 0x0FF0); + test_fail_unless( msg.modified_cspec.qmp_reverse.cco.surplus_bandwith == 0x0FF0); + test_fail_unless( msg.modified_cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.modified_cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.modified_cspec.qmp_reverse.cco.cco_bidirectional_burst == 0x01); + + test_fail_unless( msg.modified_cspec.len == 0x0154 ); + + }test_end; + +} + + +void +test_msg_cm_conn_mod_req_set_on_mme_msg(test_t t) +{ + msg_cm_conn_mod_req_t msg; + msg_mme_t test_msg; + int i; + + test_case_begin(t, "TEST cm_conn_mod_req_set_on_mme_msg"); + + + test_begin(t, "test case 1") + { + + msg_cm_conn_mod_req_init(&msg); + + msg.cid = 0x5325; + + msg.modified_cspec.cinfo_forward.valid = CINFO_VALID; + msg.modified_cspec.cinfo_forward.mac_service_type = MAC_CONTENTION; + msg.modified_cspec.cinfo_forward.user_priority = USER_PRIORITY_CAP0; + msg.modified_cspec.cinfo_forward.ats = ATS_FOR_HLE; + msg.modified_cspec.cinfo_forward.smoothing = SMOOTHING_REQUESTED; + msg.modified_cspec.cinfo_reverse.valid = CINFO_VALID ; + msg.modified_cspec.cinfo_reverse.mac_service_type = MAC_CONTENTION ; + msg.modified_cspec.cinfo_reverse.user_priority = USER_PRIORITY_CAP0 ; + msg.modified_cspec.cinfo_reverse.ats = ATS_FOR_HLE ; + msg.modified_cspec.cinfo_reverse.smoothing = SMOOTHING_REQUESTED ; + msg.modified_cspec.qmp_forward.forward_or_reverse = QMP_FORWARD; + msg.modified_cspec.qmp_forward.valid.delay_bound_available = true; + msg.modified_cspec.qmp_forward.valid.jitter_bound_available = true; + msg.modified_cspec.qmp_forward.valid.average_msdu_size_available = true; + msg.modified_cspec.qmp_forward.valid.maximum_msdu_size_available = true; + msg.modified_cspec.qmp_forward.valid.average_data_rate_available = true; + msg.modified_cspec.qmp_forward.valid.minimum_data_rate_available = true; + msg.modified_cspec.qmp_forward.valid.maximum_data_rate_available = true; + msg.modified_cspec.qmp_forward.valid.minimum_inter_txop_time_available = true; + msg.modified_cspec.qmp_forward.valid.maximum_inter_txop_time_available = true; + msg.modified_cspec.qmp_forward.valid.maximum_burst_size_available = true; + msg.modified_cspec.qmp_forward.valid.exception_policy_available = true; + msg.modified_cspec.qmp_forward.valid.inactivity_interval_available = true; + msg.modified_cspec.qmp_forward.valid.msdu_error_rate_available = true; + msg.modified_cspec.qmp_forward.valid.clst_available = true; + msg.modified_cspec.qmp_forward.valid.cdesc_available = true; + msg.modified_cspec.qmp_forward.valid.ats_tolerance_available = true; + msg.modified_cspec.qmp_forward.valid.smallest_tolerable_data_rate_available = true; + msg.modified_cspec.qmp_forward.valid.original_average_data_rate_available = true; + msg.modified_cspec.qmp_forward.valid.rx_window_size_available = true; + msg.modified_cspec.qmp_forward.valid.smoothing_buffer_size_available = true; + msg.modified_cspec.qmp_forward.valid.bidirectional_burst_available = true; + msg.modified_cspec.qmp_forward.valid.txops_per_beacon_period_available = true; + msg.modified_cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available = true; + msg.modified_cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available = true; + msg.modified_cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available = true; + msg.modified_cspec.qmp_forward.valid.ppb_threshold_available = true; + msg.modified_cspec.qmp_forward.valid.surplus_bandwith_available = true; + msg.modified_cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true; + msg.modified_cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available = true; + msg.modified_cspec.qmp_forward.valid.cco_bidirectional_burst_available = true; + msg.modified_cspec.qmp_forward.cm.delay_bound = 0x01010101; + msg.modified_cspec.qmp_forward.cm.jitter_bound = 0x10101010; + msg.modified_cspec.qmp_forward.cm.average_msdu_size = 0XF0F0; + msg.modified_cspec.qmp_forward.cm.maximum_msdu_size = 0XF0F0; + msg.modified_cspec.qmp_forward.cm.average_data_rate = 0x0F0F; + msg.modified_cspec.qmp_forward.cm.minimum_data_rate = 0x0F0F; + msg.modified_cspec.qmp_forward.cm.maximum_data_rate = 0x0F0F; + msg.modified_cspec.qmp_forward.cm.maximum_inter_txop_time = 0xFFFF; + msg.modified_cspec.qmp_forward.cm.minimum_inter_txop_time = 0xFFFF; + msg.modified_cspec.qmp_forward.cm.maximum_burst_size = 0x00FF; + msg.modified_cspec.qmp_forward.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION; + msg.modified_cspec.qmp_forward.cm.inactivity_interval = 0X00FF00FF; + msg.modified_cspec.qmp_forward.cm.msdu_error_rate = 0x00FF; + msg.modified_cspec.qmp_forward.cm.clst = 0x00; + msg.modified_cspec.qmp_forward.cm.cdesc.ip_version = 0x00; + msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] = 0x01; + msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] = 0x01; + msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] = 0x01; + msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] = 0x01; + msg.modified_cspec.qmp_forward.cm.cdesc.source_port = 0x0FF1; + msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] = 0x01; + msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] = 0x01; + msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] = 0x01; + msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] = 0x01; + msg.modified_cspec.qmp_forward.cm.cdesc.destination_port = 0xFFF1; + msg.modified_cspec.qmp_forward.cm.cdesc.protocol_type = 0x00; + msg.modified_cspec.qmp_forward.cm.ats_tolerance = 0x00FF; + msg.modified_cspec.qmp_forward.cm.smallest_tolerable_data_rate = 0x00FF; + msg.modified_cspec.qmp_forward.cm.original_average_data_rate = 0x000F; + msg.modified_cspec.qmp_forward.cm.rx_window_size = 0x100F; + msg.modified_cspec.qmp_forward.cm.smoothing_buffer_size = 0x100F10; + msg.modified_cspec.qmp_forward.cm.bidirectional_burst = 0x01; + msg.modified_cspec.qmp_forward.cco.txops_per_beacon_period = 0x15; + msg.modified_cspec.qmp_forward.cco.average_number_of_pbs_per_txop = 0x100F; + msg.modified_cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop = 0x100F; + msg.modified_cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop = 0x100F; + msg.modified_cspec.qmp_forward.cco.ppb_threshold = 0x0FF0; + msg.modified_cspec.qmp_forward.cco.surplus_bandwith = 0x0FF0; + msg.modified_cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0; + msg.modified_cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop = 0x0FF0; + msg.modified_cspec.qmp_forward.cco.cco_bidirectional_burst = 0x01; + msg.modified_cspec.qmp_reverse.forward_or_reverse = QMP_REVERSE; + msg.modified_cspec.qmp_reverse.valid.delay_bound_available = true; + msg.modified_cspec.qmp_reverse.valid.jitter_bound_available = true; + msg.modified_cspec.qmp_reverse.valid.average_msdu_size_available = true; + msg.modified_cspec.qmp_reverse.valid.maximum_msdu_size_available = true; + msg.modified_cspec.qmp_reverse.valid.average_data_rate_available = true; + msg.modified_cspec.qmp_reverse.valid.minimum_data_rate_available = true; + msg.modified_cspec.qmp_reverse.valid.maximum_data_rate_available = true; + msg.modified_cspec.qmp_reverse.valid.minimum_inter_txop_time_available = true; + msg.modified_cspec.qmp_reverse.valid.maximum_inter_txop_time_available = true; + msg.modified_cspec.qmp_reverse.valid.maximum_burst_size_available = true; + msg.modified_cspec.qmp_reverse.valid.exception_policy_available = true; + msg.modified_cspec.qmp_reverse.valid.inactivity_interval_available = true; + msg.modified_cspec.qmp_reverse.valid.msdu_error_rate_available = true; + msg.modified_cspec.qmp_reverse.valid.clst_available = true; + msg.modified_cspec.qmp_reverse.valid.cdesc_available = true; + msg.modified_cspec.qmp_reverse.valid.ats_tolerance_available = true; + msg.modified_cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available = true; + msg.modified_cspec.qmp_reverse.valid.original_average_data_rate_available = true; + msg.modified_cspec.qmp_reverse.valid.rx_window_size_available = true; + msg.modified_cspec.qmp_reverse.valid.smoothing_buffer_size_available = true; + msg.modified_cspec.qmp_reverse.valid.bidirectional_burst_available = true; + msg.modified_cspec.qmp_reverse.valid.txops_per_beacon_period_available = true; + msg.modified_cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available = true; + msg.modified_cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available = true; + msg.modified_cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available = true; + msg.modified_cspec.qmp_reverse.valid.ppb_threshold_available = true; + msg.modified_cspec.qmp_reverse.valid.surplus_bandwith_available = true; + msg.modified_cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true; + msg.modified_cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available = true; + msg.modified_cspec.qmp_reverse.valid.cco_bidirectional_burst_available = true; + msg.modified_cspec.qmp_reverse.cm.delay_bound = 0x01010101; + msg.modified_cspec.qmp_reverse.cm.jitter_bound = 0x10101010; + msg.modified_cspec.qmp_reverse.cm.average_msdu_size = 0XF0F0; + msg.modified_cspec.qmp_reverse.cm.maximum_msdu_size = 0XF0F0; + msg.modified_cspec.qmp_reverse.cm.average_data_rate = 0x0F0F; + msg.modified_cspec.qmp_reverse.cm.minimum_data_rate = 0x0F0F; + msg.modified_cspec.qmp_reverse.cm.maximum_data_rate = 0x0F0F; + msg.modified_cspec.qmp_reverse.cm.maximum_inter_txop_time = 0xFFFF; + msg.modified_cspec.qmp_reverse.cm.minimum_inter_txop_time = 0xFFFF; + msg.modified_cspec.qmp_reverse.cm.maximum_burst_size = 0x00FF; + msg.modified_cspec.qmp_reverse.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION; + msg.modified_cspec.qmp_reverse.cm.inactivity_interval = 0X00FF00FF; + msg.modified_cspec.qmp_reverse.cm.msdu_error_rate = 0x00FF; + msg.modified_cspec.qmp_reverse.cm.clst = 0x00; + msg.modified_cspec.qmp_reverse.cm.cdesc.ip_version = 0x00; + msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] = 0x01; + msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] = 0x01; + msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] = 0x01; + msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] = 0x01; + msg.modified_cspec.qmp_reverse.cm.cdesc.source_port = 0x0FF1; + msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] = 0x01; + msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] = 0x01; + msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] = 0x01; + msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] = 0x01; + msg.modified_cspec.qmp_reverse.cm.cdesc.destination_port = 0xFFF1; + msg.modified_cspec.qmp_reverse.cm.cdesc.protocol_type = 0x00; + msg.modified_cspec.qmp_reverse.cm.ats_tolerance = 0x00FF; + msg.modified_cspec.qmp_reverse.cm.smallest_tolerable_data_rate = 0x00FF; + msg.modified_cspec.qmp_reverse.cm.original_average_data_rate = 0x000F; + msg.modified_cspec.qmp_reverse.cm.rx_window_size = 0x100F; + msg.modified_cspec.qmp_reverse.cm.smoothing_buffer_size = 0x100F10; + msg.modified_cspec.qmp_reverse.cm.bidirectional_burst = 0x01; + msg.modified_cspec.qmp_reverse.cco.txops_per_beacon_period = 0x15; + msg.modified_cspec.qmp_reverse.cco.average_number_of_pbs_per_txop = 0x100F; + msg.modified_cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop = 0x100F; + msg.modified_cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop = 0x100F; + msg.modified_cspec.qmp_reverse.cco.ppb_threshold = 0x0FF0; + msg.modified_cspec.qmp_reverse.cco.surplus_bandwith = 0x0FF0; + msg.modified_cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0; + msg.modified_cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop = 0x0FF0; + msg.modified_cspec.qmp_reverse.cco.cco_bidirectional_burst = 0x01; + msg.modified_cspec.len = 0x0154 ; + + msg_cm_conn_mod_req_set_on_mme_msg(&test_msg, &msg); + + for(i=0; i< 340;i++) + { + test_fail_unless( test_msg.mm_entry[i] == msg_cm_conn_mod_req_1.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_msg.mm_entry[i],msg_cm_conn_mod_req_1.mm_entry[i]); + } + + }test_end; + +} + + +void +test_msg_cm_conn_mod_req(test_t t) +{ + dbg_assert(t); + + test_suite_begin(t, "TEST MESSAGE CM_CONN_MOD_REQ"); + test_msg_cm_conn_mod_req_get_from_mme_msg(t); + test_msg_cm_conn_mod_req_set_on_mme_msg(t); + +} diff --git a/cp/msg/test/src/test_msg_cm_conn_new_cnf.c b/cp/msg/test/src/test_msg_cm_conn_new_cnf.c new file mode 100644 index 0000000000..d823069b42 --- /dev/null +++ b/cp/msg/test/src/test_msg_cm_conn_new_cnf.c @@ -0,0 +1,816 @@ +/* Cesar project {{{ + * + * Copyright (C) 2007 Spidcom + * + * <<>> + * + * }}} + * \file test_msg_cm_conn_new_cnf.c + * \brief File Description + * \ingroup cp/msg + * + */ + + +#include "common/std.h" +#include "cp/msg/inc/msg_cm.h" + + +msg_mme_t msg_cm_conn_new_cnf_1 = +{ + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA + 0, // vlan tag + 0x88E1, + 0, // mmv + CM_CONN_NEW_CNF, + {0,0,0}, + { + 0x53, // CID (=0x5325) + 0x25, // CID + 0x25, // LLID-R (=0x25) + 0x04, // Result + 0x01, // CSPEC Length :338 bytes + 0x54, // CSPEC Length : + CINFO_VALID, // CINFO Valid? CINFO Forward + MAC_CONTENTION, // Mac Service Type + USER_PRIORITY_CAP0, // User Priori ty + ATS_FOR_HLE, // Arrival Time Stamp + SMOOTHING_REQUESTED, // Smoothing + CINFO_VALID, // CINFO Valid? CINFO Reverse + MAC_CONTENTION, // Mac Service Type + USER_PRIORITY_CAP0, // User Priority + ATS_FOR_HLE, // Arrival Time Stamp + SMOOTHING_REQUESTED, // Smoothing + QMP_FORWARD, + 0x04, // QMP body length + 0x00, // FID: Delay bound + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + QMP_FORWARD, + 0x04, // QMP body length + 0x01, // FID: Jitter bound + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x02, // FID: Average MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x03, // FID: Maximum MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x04, // FID: Average Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x05, // FID: Minimum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x06, // FID: Maximum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x07, // FID: Maximum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x08, // FID: Minimum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x09, // FID: Maximum Burst Size + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x0A, // FID: Exception Policy + 0x01, // QMP BODY + QMP_FORWARD, + 0x04, // QMP body length + 0x0B, // FID: inactivity_interval + 0x00, // QMP BODY + 0xFF, // QMP BODY + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x0C, // FID: MSDU Error Rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x0D, // FID: CLST + 0x00, // QMP BODY + QMP_FORWARD, + 0x0E, // QMP body length + 0x0E, // FID: CDESC + 0x00, // IP Version 4 + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x0F, // source port + 0xF1, // source port + 0x01, // Dest IP + 0x01, // dest IP + 0x01, // dest IP + 0x01, // dest IP + 0xFF, // dest port + 0xF1, // dest port + 0x00, // ip proto type + QMP_FORWARD, + 0x02, // QMP body length + 0x10, // FID: ATS Tolerance + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x11, // FID: Smallest tolerable Average data rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x12, // FID: Original Average data rate + 0x00, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x13, // FID: rx_window_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x03, // QMP body length + 0x14, // FID: smoothing_buffer_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + 0x10, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x15, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x80, // FID: TXOPs per Beacon Period + 0x15, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x81, // FID: Average Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x82, // FID: Minimum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x83, // FID: Maximum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x84, // FID: PPB_Threshold + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x85, // 0x0FID: Surplus Bandwidth + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x88, // FID: Original Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x89, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x00, // FID: Delay bound + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x01, // FID: Jitter bound + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x02, // FID: Average MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x03, // FID: Maximum MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x04, // FID: Average Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x05, // FID: Minimum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x06, // FID: Maximum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x07, // FID: Maximum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x08, // FID: Minimum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x09, // FID: Maximum Burst Size + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x0A, // FID: Exception Policy + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x0B, // FID: inactivity_interval + 0x00, // QMP BODY + 0xFF, // QMP BODY + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x0C, // FID: MSDU Error Rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x0D, // FID: CLST + 0x00, // QMP BODY + QMP_REVERSE, + 0x0E, // QMP body length + 0x0E, // FID: CDESC + 0x00, // IP Version 4 + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x0F, // source port + 0xF1, // source port + 0x01, // Dest IP + 0x01, // dest IP + 0x01, // dest IP + 0x01, // dest IP + 0xFF, // dest port + 0xF1, // dest port + 0x00, // ip proto type + QMP_REVERSE, + 0x02, // QMP body length + 0x10, // FID: ATS Tolerance + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x11, // FID: Smallest tolerable Average data rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x12, // FID: Original Average data rate + 0x00, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x13, // FID: rx_window_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x03, // QMP body length + 0x14, // FID: smoothing_buffer_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + 0x10, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x15, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x80, // FID: TXOPs per Beacon Period + 0x15, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x81, // FID: Average Number of PBs per TXOP + 0x10, // QMP BODY copy + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x82, // FID: Minimum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x83, // FID: Maximum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x84, // FID: PPB_Threshold + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x85, // FID: Surplus Bandwidth + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x88, // FID: Original Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x89, // FID: Bidirectional Burst + 0x01, // QMP BODY + } +}; + + + +msg_mme_t msg_cm_conn_new_cnf_2 = +{ + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA + 0, // vlan tag + 0x88E1, + 0, // mmv + CM_CONN_NEW_CNF, + {0,0,0}, + { + 0x53, // CID (=0x5325) + 0x25, // CID + 0x25, // LLID-R (=0x25) + 0x00 // Result (=success) + } +}; + +void +test_msg_cm_conn_new_cnf_set_on_mme_msg(test_t t) +{ + msg_cm_conn_new_cnf_t msg; + + test_case_begin(t, "TEST msg_cm_conn_new_cnf_set_on_mme_msg"); + + test_begin(t, "test case 1") + { + + msg_cm_conn_new_cnf_init(&msg); + + + + msg.cid = 0x5325; + msg.llid_r = 0x25; + msg.result = CONN_FAILURE_OTHER; + msg.cspec_proposed.cinfo_forward.valid = CINFO_VALID; + msg.cspec_proposed.cinfo_forward.mac_service_type = MAC_CONTENTION; + msg.cspec_proposed.cinfo_forward.user_priority = USER_PRIORITY_CAP0; + msg.cspec_proposed.cinfo_forward.ats = ATS_FOR_HLE; + msg.cspec_proposed.cinfo_forward.smoothing = SMOOTHING_REQUESTED; + + msg.cspec_proposed.cinfo_reverse.valid = CINFO_VALID; + msg.cspec_proposed.cinfo_reverse.mac_service_type = MAC_CONTENTION; + msg.cspec_proposed.cinfo_reverse.user_priority = USER_PRIORITY_CAP0; + msg.cspec_proposed.cinfo_reverse.ats = ATS_FOR_HLE; + msg.cspec_proposed.cinfo_reverse.smoothing = SMOOTHING_REQUESTED; + + msg.cspec_proposed.qmp_forward.valid.delay_bound_available = true; + msg.cspec_proposed.qmp_forward.valid.jitter_bound_available = true; + msg.cspec_proposed.qmp_forward.valid.average_msdu_size_available = true; + msg.cspec_proposed.qmp_forward.valid.maximum_msdu_size_available = true; + msg.cspec_proposed.qmp_forward.valid.average_data_rate_available = true; + msg.cspec_proposed.qmp_forward.valid.minimum_data_rate_available = true; + msg.cspec_proposed.qmp_forward.valid.maximum_data_rate_available = true; + msg.cspec_proposed.qmp_forward.valid.minimum_inter_txop_time_available = true; + msg.cspec_proposed.qmp_forward.valid.maximum_inter_txop_time_available = true; + msg.cspec_proposed.qmp_forward.valid.maximum_burst_size_available = true; + msg.cspec_proposed.qmp_forward.valid.exception_policy_available = true; + msg.cspec_proposed.qmp_forward.valid.inactivity_interval_available = true; + msg.cspec_proposed.qmp_forward.valid.msdu_error_rate_available = true; + msg.cspec_proposed.qmp_forward.valid.clst_available = true; + msg.cspec_proposed.qmp_forward.valid.cdesc_available = true; + msg.cspec_proposed.qmp_forward.valid.ats_tolerance_available = true; + msg.cspec_proposed.qmp_forward.valid.smallest_tolerable_data_rate_available = true; + msg.cspec_proposed.qmp_forward.valid.original_average_data_rate_available = true; + msg.cspec_proposed.qmp_forward.valid.rx_window_size_available = true; + msg.cspec_proposed.qmp_forward.valid.smoothing_buffer_size_available = true; + msg.cspec_proposed.qmp_forward.valid.bidirectional_burst_available = true; + msg.cspec_proposed.qmp_forward.valid.txops_per_beacon_period_available = true; + msg.cspec_proposed.qmp_forward.valid.average_number_of_pbs_per_txop_available = true; + msg.cspec_proposed.qmp_forward.valid.minimum_number_of_pbs_per_txop_available = true; + msg.cspec_proposed.qmp_forward.valid.maximum_number_of_pbs_per_txop_available = true; + msg.cspec_proposed.qmp_forward.valid.ppb_threshold_available = true; + msg.cspec_proposed.qmp_forward.valid.surplus_bandwith_available = true; + msg.cspec_proposed.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true; + msg.cspec_proposed.qmp_forward.valid.original_average_number_of_pbs_per_txop_available = true; + msg.cspec_proposed.qmp_forward.valid.cco_bidirectional_burst_available = true; + msg.cspec_proposed.qmp_forward.cm.delay_bound = 0x01010101; + msg.cspec_proposed.qmp_forward.cm.jitter_bound = 0x10101010; + msg.cspec_proposed.qmp_forward.cm.average_msdu_size = 0XF0F0; + msg.cspec_proposed.qmp_forward.cm.maximum_msdu_size = 0XF0F0; + msg.cspec_proposed.qmp_forward.cm.average_data_rate = 0x0F0F; + msg.cspec_proposed.qmp_forward.cm.minimum_data_rate = 0x0F0F; + msg.cspec_proposed.qmp_forward.cm.maximum_data_rate = 0x0F0F; + msg.cspec_proposed.qmp_forward.cm.maximum_inter_txop_time = 0xFFFF; + msg.cspec_proposed.qmp_forward.cm.minimum_inter_txop_time = 0xFFFF; + msg.cspec_proposed.qmp_forward.cm.maximum_burst_size = 0x00FF; + msg.cspec_proposed.qmp_forward.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION; + msg.cspec_proposed.qmp_forward.cm.inactivity_interval = 0X00FF00FF; + msg.cspec_proposed.qmp_forward.cm.msdu_error_rate = 0x00FF; + msg.cspec_proposed.qmp_forward.cm.clst = 0x00; + msg.cspec_proposed.qmp_forward.cm.cdesc.ip_version = 0x00; + msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[0] = 0x01; + msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[1] = 0x01; + msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[2] = 0x01; + msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[3] = 0x01; + msg.cspec_proposed.qmp_forward.cm.cdesc.source_port = 0x0FF1; + msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[0] = 0x01; + msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[1] = 0x01; + msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[2] = 0x01; + msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[3] = 0x01; + msg.cspec_proposed.qmp_forward.cm.cdesc.destination_port = 0xFFF1; + msg.cspec_proposed.qmp_forward.cm.cdesc.protocol_type = 0x00; + msg.cspec_proposed.qmp_forward.cm.ats_tolerance = 0x00FF; + msg.cspec_proposed.qmp_forward.cm.smallest_tolerable_data_rate = 0x00FF; + msg.cspec_proposed.qmp_forward.cm.original_average_data_rate = 0x000F; + msg.cspec_proposed.qmp_forward.cm.rx_window_size = 0x100F; + msg.cspec_proposed.qmp_forward.cm.smoothing_buffer_size = 0x100F10; + msg.cspec_proposed.qmp_forward.cm.bidirectional_burst = 0x01; + msg.cspec_proposed.qmp_forward.cco.txops_per_beacon_period = 0x15; + msg.cspec_proposed.qmp_forward.cco.average_number_of_pbs_per_txop = 0x100F; + msg.cspec_proposed.qmp_forward.cco.minimum_number_of_pbs_per_txop = 0x100F; + msg.cspec_proposed.qmp_forward.cco.maximum_number_of_pbs_per_txop = 0x100F; + msg.cspec_proposed.qmp_forward.cco.ppb_threshold = 0x0FF0; + msg.cspec_proposed.qmp_forward.cco.surplus_bandwith = 0x0FF0; + msg.cspec_proposed.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0; + msg.cspec_proposed.qmp_forward.cco.original_average_number_of_pbs_per_txop = 0x0FF0; + msg.cspec_proposed.qmp_forward.cco.cco_bidirectional_burst = 0x01; + + msg.cspec_proposed.qmp_reverse.valid.delay_bound_available = true; + msg.cspec_proposed.qmp_reverse.valid.jitter_bound_available = true; + msg.cspec_proposed.qmp_reverse.valid.average_msdu_size_available = true; + msg.cspec_proposed.qmp_reverse.valid.maximum_msdu_size_available = true; + msg.cspec_proposed.qmp_reverse.valid.average_data_rate_available = true; + msg.cspec_proposed.qmp_reverse.valid.minimum_data_rate_available = true; + msg.cspec_proposed.qmp_reverse.valid.maximum_data_rate_available = true; + msg.cspec_proposed.qmp_reverse.valid.minimum_inter_txop_time_available = true; + msg.cspec_proposed.qmp_reverse.valid.maximum_inter_txop_time_available = true; + msg.cspec_proposed.qmp_reverse.valid.maximum_burst_size_available = true; + msg.cspec_proposed.qmp_reverse.valid.exception_policy_available = true; + msg.cspec_proposed.qmp_reverse.valid.inactivity_interval_available = true; + msg.cspec_proposed.qmp_reverse.valid.msdu_error_rate_available = true; + msg.cspec_proposed.qmp_reverse.valid.clst_available = true; + msg.cspec_proposed.qmp_reverse.valid.cdesc_available = true; + msg.cspec_proposed.qmp_reverse.valid.ats_tolerance_available = true; + msg.cspec_proposed.qmp_reverse.valid.smallest_tolerable_data_rate_available = true; + msg.cspec_proposed.qmp_reverse.valid.original_average_data_rate_available = true; + msg.cspec_proposed.qmp_reverse.valid.rx_window_size_available = true; + msg.cspec_proposed.qmp_reverse.valid.smoothing_buffer_size_available = true; + msg.cspec_proposed.qmp_reverse.valid.bidirectional_burst_available = true; + msg.cspec_proposed.qmp_reverse.valid.txops_per_beacon_period_available = true; + msg.cspec_proposed.qmp_reverse.valid.average_number_of_pbs_per_txop_available = true; + msg.cspec_proposed.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available = true; + msg.cspec_proposed.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available = true; + msg.cspec_proposed.qmp_reverse.valid.ppb_threshold_available = true; + msg.cspec_proposed.qmp_reverse.valid.surplus_bandwith_available = true; + msg.cspec_proposed.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true; + msg.cspec_proposed.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available = true; + msg.cspec_proposed.qmp_reverse.valid.cco_bidirectional_burst_available = true; + msg.cspec_proposed.qmp_reverse.cm.delay_bound = 0x01010101; + msg.cspec_proposed.qmp_reverse.cm.jitter_bound = 0x10101010; + msg.cspec_proposed.qmp_reverse.cm.average_msdu_size = 0XF0F0; + msg.cspec_proposed.qmp_reverse.cm.maximum_msdu_size = 0XF0F0; + msg.cspec_proposed.qmp_reverse.cm.average_data_rate = 0x0F0F; + msg.cspec_proposed.qmp_reverse.cm.minimum_data_rate = 0x0F0F; + msg.cspec_proposed.qmp_reverse.cm.maximum_data_rate = 0x0F0F; + msg.cspec_proposed.qmp_reverse.cm.maximum_inter_txop_time = 0xFFFF; + msg.cspec_proposed.qmp_reverse.cm.minimum_inter_txop_time = 0xFFFF; + msg.cspec_proposed.qmp_reverse.cm.maximum_burst_size = 0x00FF; + msg.cspec_proposed.qmp_reverse.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION; + msg.cspec_proposed.qmp_reverse.cm.inactivity_interval = 0X00FF00FF; + msg.cspec_proposed.qmp_reverse.cm.msdu_error_rate = 0x00FF; + msg.cspec_proposed.qmp_reverse.cm.clst = 0x00; + msg.cspec_proposed.qmp_reverse.cm.cdesc.ip_version = 0x00; + msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[0] = 0x01; + msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[1] = 0x01; + msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[2] = 0x01; + msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[3] = 0x01; + msg.cspec_proposed.qmp_reverse.cm.cdesc.source_port = 0x0FF1; + msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[0] = 0x01; + msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[1] = 0x01; + msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[2] = 0x01; + msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[3] = 0x01; + msg.cspec_proposed.qmp_reverse.cm.cdesc.destination_port = 0xFFF1; + msg.cspec_proposed.qmp_reverse.cm.cdesc.protocol_type = 0x00; + msg.cspec_proposed.qmp_reverse.cm.ats_tolerance = 0x00FF; + msg.cspec_proposed.qmp_reverse.cm.smallest_tolerable_data_rate = 0x00FF; + msg.cspec_proposed.qmp_reverse.cm.original_average_data_rate = 0x000F; + msg.cspec_proposed.qmp_reverse.cm.rx_window_size = 0x100F; + msg.cspec_proposed.qmp_reverse.cm.smoothing_buffer_size = 0x100F10; + msg.cspec_proposed.qmp_reverse.cm.bidirectional_burst = 0x01; + msg.cspec_proposed.qmp_reverse.cco.txops_per_beacon_period = 0x15; + msg.cspec_proposed.qmp_reverse.cco.average_number_of_pbs_per_txop = 0x100F; + msg.cspec_proposed.qmp_reverse.cco.minimum_number_of_pbs_per_txop = 0x100F; + msg.cspec_proposed.qmp_reverse.cco.maximum_number_of_pbs_per_txop = 0x100F; + msg.cspec_proposed.qmp_reverse.cco.ppb_threshold = 0x0FF0; + msg.cspec_proposed.qmp_reverse.cco.surplus_bandwith = 0x0FF0; + msg.cspec_proposed.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0; + msg.cspec_proposed.qmp_reverse.cco.original_average_number_of_pbs_per_txop = 0x0FF0; + msg.cspec_proposed.qmp_reverse.cco.cco_bidirectional_burst = 0x01; + + + { + + msg_mme_t test_mme; + + msg_cm_conn_new_cnf_set_on_mme_msg(&test_mme, &msg); + + + int i; + + for(i=0; i < 378; i++) + { + test_fail_unless(test_mme.mm_entry[i] == msg_cm_conn_new_cnf_1.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_mme.mm_entry[i],msg_cm_conn_new_cnf_1.mm_entry[i]); + } + } + + + }test_end; + + + test_begin(t, "test case 2") + { + + msg_cm_conn_new_cnf_init(&msg); + msg.cid = 0x5325; + msg.llid_r = 0x25; + msg.result = CONN_SUCCESS; + + { + msg_mme_t test_mme; + int i; + + msg_cm_conn_new_cnf_set_on_mme_msg(&test_mme, &msg); + + for(i=0; i < 3; i++) + { + test_fail_unless(test_mme.mm_entry[i] == msg_cm_conn_new_cnf_2.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_mme.mm_entry[i],msg_cm_conn_new_cnf_2.mm_entry[i]); + } + } + + + + + }test_end; + + +} + + +void +test_msg_cm_conn_new_cnf_get_from_mme_msg(test_t t) +{ + msg_cm_conn_new_cnf_t msg; + + test_case_begin(t, "TEST msg_cm_conn_new_cnf_get_from_mme_msg"); + + test_begin(t, "test case 1") + { + msg_cm_conn_new_cnf_init(&msg); + + msg_cm_conn_new_cnf_get_from_mme_msg(&msg_cm_conn_new_cnf_1, &msg); + + test_fail_unless( msg.cid == 0x5325 ); + test_fail_unless( msg.llid_r == 0x25 ); + test_fail_unless( msg.result == CONN_FAILURE_OTHER ); + test_fail_unless(msg.cspec_proposed.cinfo_forward.valid == CINFO_VALID ); + test_fail_unless(msg.cspec_proposed.cinfo_forward.mac_service_type == MAC_CONTENTION); + test_fail_unless(msg.cspec_proposed.cinfo_forward.user_priority == USER_PRIORITY_CAP0); + test_fail_unless(msg.cspec_proposed.cinfo_forward.ats == ATS_FOR_HLE); + test_fail_unless(msg.cspec_proposed.cinfo_forward.smoothing = SMOOTHING_REQUESTED); + + test_fail_unless(msg.cspec_proposed.cinfo_reverse.valid == CINFO_VALID ); + test_fail_unless(msg.cspec_proposed.cinfo_reverse.mac_service_type == MAC_CONTENTION); + test_fail_unless(msg.cspec_proposed.cinfo_reverse.user_priority == USER_PRIORITY_CAP0); + test_fail_unless(msg.cspec_proposed.cinfo_reverse.ats == ATS_FOR_HLE); + test_fail_unless(msg.cspec_proposed.cinfo_reverse.smoothing = SMOOTHING_REQUESTED); + + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.delay_bound_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.jitter_bound_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.average_msdu_size_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_msdu_size_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.average_data_rate_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.minimum_data_rate_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_data_rate_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.minimum_inter_txop_time_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_inter_txop_time_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_burst_size_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.exception_policy_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.inactivity_interval_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.msdu_error_rate_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.clst_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.cdesc_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.ats_tolerance_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.smallest_tolerable_data_rate_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.original_average_data_rate_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.rx_window_size_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.smoothing_buffer_size_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.bidirectional_burst_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.txops_per_beacon_period_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.ppb_threshold_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.surplus_bandwith_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.cco_bidirectional_burst_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.delay_bound == 0x01010101); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.jitter_bound == 0x10101010); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.average_msdu_size == 0XF0F0); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.maximum_msdu_size == 0XF0F0); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.average_data_rate == 0x0F0F); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.minimum_data_rate == 0x0F0F); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.maximum_data_rate == 0x0F0F); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.maximum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.minimum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.maximum_burst_size == 0x00FF); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.inactivity_interval == 0X00FF00FF); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.msdu_error_rate == 0x00FF); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.clst == 0x00); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ip_version == 0x00); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[0] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[1] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[2] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[3] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.source_port == 0x0FF1); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[0] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[1] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[2] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[3] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.destination_port == 0xFFF1); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.protocol_type == 0x00); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.ats_tolerance == 0x00FF); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.smallest_tolerable_data_rate == 0x00FF); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.original_average_data_rate == 0x000F); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.rx_window_size == 0x100F); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.smoothing_buffer_size == 0x100F10); + test_fail_unless( msg.cspec_proposed.qmp_forward.cm.bidirectional_burst == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_forward.cco.txops_per_beacon_period == 0x15); + test_fail_unless( msg.cspec_proposed.qmp_forward.cco.average_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.cspec_proposed.qmp_forward.cco.minimum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.cspec_proposed.qmp_forward.cco.maximum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.cspec_proposed.qmp_forward.cco.ppb_threshold == 0x0FF0); + test_fail_unless( msg.cspec_proposed.qmp_forward.cco.surplus_bandwith == 0x0FF0); + test_fail_unless( msg.cspec_proposed.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.cspec_proposed.qmp_forward.cco.original_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.cspec_proposed.qmp_forward.cco.cco_bidirectional_burst == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.delay_bound_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.jitter_bound_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.average_msdu_size_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_msdu_size_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.average_data_rate_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.minimum_data_rate_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_data_rate_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.minimum_inter_txop_time_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_inter_txop_time_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_burst_size_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.exception_policy_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.inactivity_interval_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.msdu_error_rate_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.clst_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.cdesc_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.ats_tolerance_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.smallest_tolerable_data_rate_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.original_average_data_rate_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.rx_window_size_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.smoothing_buffer_size_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.bidirectional_burst_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.ppb_threshold_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.surplus_bandwith_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec_proposed.qmp_forward.valid.cco_bidirectional_burst_available == true); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.delay_bound == 0x01010101); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.jitter_bound == 0x10101010); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.average_msdu_size == 0XF0F0); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.maximum_msdu_size == 0XF0F0); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.average_data_rate == 0x0F0F); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.minimum_data_rate == 0x0F0F); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.maximum_data_rate == 0x0F0F); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.maximum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.minimum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.maximum_burst_size == 0x00FF); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.inactivity_interval == 0X00FF00FF); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.msdu_error_rate == 0x00FF); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.clst == 0x00); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ip_version == 0x00); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[0] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[1] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[2] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[3] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.source_port == 0x0FF1); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[0] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[1] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[2] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[3] == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.destination_port == 0xFFF1); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.protocol_type == 0x00); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.ats_tolerance == 0x00FF); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.smallest_tolerable_data_rate == 0x00FF); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.original_average_data_rate == 0x000F); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.rx_window_size == 0x100F); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.smoothing_buffer_size == 0x100F10); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.bidirectional_burst == 0x01); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.txops_per_beacon_period == 0x15); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.average_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.minimum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.maximum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.ppb_threshold == 0x0FF0); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.surplus_bandwith == 0x0FF0); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.original_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.cco_bidirectional_burst == 0x01); + + + }test_end; + + test_begin(t, "test case 2") + { + + msg_cm_conn_new_cnf_init(&msg); + + msg_cm_conn_new_cnf_get_from_mme_msg(&msg_cm_conn_new_cnf_2, &msg); + + + test_fail_unless( msg.cid == 0x5325 ); + test_fail_unless( msg.llid_r == 0x25 ); + test_fail_unless( msg.result == CONN_SUCCESS ); + + + }test_end; +} + + +void +test_msg_cm_conn_new_cnf(test_t t) +{ + dbg_assert(t); + + test_suite_begin(t, "TEST MESSAGE CM_CONN_NEW_CNF"); + + test_msg_cm_conn_new_cnf_get_from_mme_msg(t); + test_msg_cm_conn_new_cnf_set_on_mme_msg(t); + +} diff --git a/cp/msg/test/src/test_msg_cm_conn_new_req.c b/cp/msg/test/src/test_msg_cm_conn_new_req.c new file mode 100644 index 0000000000..489a777cb0 --- /dev/null +++ b/cp/msg/test/src/test_msg_cm_conn_new_req.c @@ -0,0 +1,879 @@ +/* Cesar project {{{ + * + * Copyright (C) 2007 Spidcom + * + * <<>> + * + * }}} + * \file test_msg_cm_conn_new_req.c + * \brief File Description + * \ingroup cp/msg + * + */ + +#include "common/std.h" +#include "cp/msg/inc/msg_cm.h" + + +msg_mme_t msg_cm_conn_new_req = +{ + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // oda + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // osa + 0, // ieee tag + 0x88E1, // m_type + 0, // mmv + CM_CONN_NEW_REQ, // mm_types + { 0, 0, 0}, //fmi + { + 0x53, // CID + 0x53, //CID + 0x01, // CSPEC Length :338 bytes + 0x54, // CSPEC Length : + CINFO_VALID, // CINFO Valid? CINFO Forward + MAC_CONTENTION, // Mac Service Type + USER_PRIORITY_CAP0, // User Priori ty + ATS_FOR_HLE, // Arrival Time Stamp + SMOOTHING_REQUESTED, // Smoothing + CINFO_VALID, // CINFO Valid? CINFO Reverse + MAC_CONTENTION, // Mac Service Type + USER_PRIORITY_CAP0, // User Priority + ATS_FOR_HLE, // Arrival Time Stamp + SMOOTHING_REQUESTED, // Smoothing + QMP_FORWARD, + 0x04, // QMP body length + 0x00, // FID: Delay bound + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + QMP_FORWARD, + 0x04, // QMP body length + 0x01, // FID: Jitter bound + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x02, // FID: Average MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x03, // FID: Maximum MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x04, // FID: Average Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x05, // FID: Minimum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x06, // FID: Maximum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x07, // FID: Maximum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x08, // FID: Minimum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x09, // FID: Maximum Burst Size + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x0A, // FID: Exception Policy + 0x01, // QMP BODY + QMP_FORWARD, + 0x04, // QMP body length + 0x0B, // FID: inactivity_interval + 0x00, // QMP BODY + 0xFF, // QMP BODY + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x0C, // FID: MSDU Error Rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x0D, // FID: CLST + 0x00, // QMP BODY + QMP_FORWARD, + 0x0E, // QMP body length + 0x0E, // FID: CDESC + 0x00, // IP Version 4 + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x0F, // source port + 0xF1, // source port + 0x01, // Dest IP + 0x01, // dest IP + 0x01, // dest IP + 0x01, // dest IP + 0xFF, // dest port + 0xF1, // dest port + 0x00, // ip proto type + QMP_FORWARD, + 0x02, // QMP body length + 0x10, // FID: ATS Tolerance + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x11, // FID: Smallest tolerable Average data rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x12, // FID: Original Average data rate + 0x00, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x13, // FID: rx_window_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x03, // QMP body length + 0x14, // FID: smoothing_buffer_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + 0x10, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x15, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x80, // FID: TXOPs per Beacon Period + 0x15, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x81, // FID: Average Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x82, // FID: Minimum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x83, // FID: Maximum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x84, // FID: PPB_Threshold + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x85, // FID: Surplus Bandwidth + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x88, // FID: Original Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x89, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x00, // FID: Delay bound + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x01, // FID: Jitter bound + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x02, // FID: Average MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x03, // FID: Maximum MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x04, // FID: Average Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x05, // FID: Minimum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x06, // FID: Maximum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x07, // FID: Maximum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x08, // FID: Minimum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x09, // FID: Maximum Burst Size + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x0A, // FID: Exception Policy + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x0B, // FID: inactivity_interval + 0x00, // QMP BODY + 0xFF, // QMP BODY + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x0C, // FID: MSDU Error Rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x0D, // FID: CLST + 0x00, // QMP BODY + QMP_REVERSE, + 0x0E, // QMP body length + 0x0E, // FID: CDESC + 0x00, // IP Version 4 + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x0F, // source port + 0xF1, // source port + 0x01, // Dest IP + 0x01, // dest IP + 0x01, // dest IP + 0x01, // dest IP + 0xFF, // dest port + 0xF1, // dest port + 0x00, // ip proto type + QMP_REVERSE, + 0x02, // QMP body length + 0x10, // FID: ATS Tolerance + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x11, // FID: Smallest tolerable Average data rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x12, // FID: Original Average data rate + 0x00, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x13, // FID: rx_window_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x03, // QMP body length + 0x14, // FID: smoothing_buffer_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + 0x10, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x15, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x80, // FID: TXOPs per Beacon Period + 0x15, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x81, // FID: Average Number of PBs per TXOP + 0x10, // QMP BODY copy + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x82, // FID: Minimum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x83, // FID: Maximum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x84, // FID: PPB_Threshold + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x85, // FID: Surplus Bandwidth + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x88, // FID: Original Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x89, // FID: Bidirectional Burst + 0x01, // QMP BODY + 0x00, // Classifier Version Classifier_rule + 0x08, // Number of classifier rule + 0x00, // Classifier Rule identifier //Ethernet Destination Address + 0x01, // Classifier Rule data + 0x02, // Classifier Rule data + 0x03, // Classifier Rule data + 0x04, // Classifier Rule data + 0x05, // Classifier Rule data + 0x06, // Classifier Rule data + 0x01, // Classifier Rule identifier //Ethernet Source Address + 0x06, // Classifier Rule data + 0x05, // Classifier Rule data + 0x04, // Classifier Rule data + 0x03, // Classifier Rule data + 0x02, // Classifier Rule data + 0x01, // Classifier Rule data + 0X04, // Classifier Rule identifier //IPV4 type of service + 0x08, // Classifier Rule data + 0x05, // Classifier Rule identifier //IPV4 Proto + 0x02, // Classifier Rule data + 0x06, // Classifier Rule identifier //IPV4 source addr + 0x04, // Classifier Rule data + 0x04, // Classifier Rule data + 0x04, // Classifier Rule data + 0x04, // Classifier Rule data + 0x07, // Classifier Rule identifier //IPV4 destination addr + 0x34, // Classifier Rule data + 0x34, // Classifier Rule data + 0x34, // Classifier Rule data + 0x34, // Classifier Rule data + 0x0C, // Classifier Rule identifier //TCP Source port + 0x54, // Classifier Rule data + 0X32, + 0x0D, // Classifier Rule identifier //TCP Destination Port + 0x34, // Classifier Rule data + 0x54, // Classifier Rule data + +}}; + + + +void +test_msg_cm_conn_new_req_get_from_mme_msg(test_t t) +{ + msg_cm_conn_new_req_t msg; + + test_case_begin(t, "TEST msg_cm_conn_new_req_get_from_mme_msg"); + + test_begin(t, "test case 1") + { + + msg_cm_conn_new_req_init(&msg); + + msg_cm_conn_new_req_get_from_mme_msg(&(msg_cm_conn_new_req), &msg); + + test_fail_unless(msg.cid == 0x5353); + + test_fail_unless(msg.cspec.cinfo_forward.valid == CINFO_VALID ); + test_fail_unless(msg.cspec.cinfo_forward.mac_service_type == MAC_CONTENTION); + test_fail_unless(msg.cspec.cinfo_forward.user_priority == USER_PRIORITY_CAP0); + test_fail_unless(msg.cspec.cinfo_forward.ats == ATS_FOR_HLE); + test_fail_unless(msg.cspec.cinfo_forward.smoothing = SMOOTHING_REQUESTED); + + test_fail_unless(msg.cspec.cinfo_reverse.valid == CINFO_VALID ); + test_fail_unless(msg.cspec.cinfo_reverse.mac_service_type == MAC_CONTENTION); + test_fail_unless(msg.cspec.cinfo_reverse.user_priority == USER_PRIORITY_CAP0); + test_fail_unless(msg.cspec.cinfo_reverse.ats == ATS_FOR_HLE); + test_fail_unless(msg.cspec.cinfo_reverse.smoothing = SMOOTHING_REQUESTED); + + test_fail_unless( msg.cspec.qmp_forward.valid.delay_bound_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.jitter_bound_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.average_msdu_size_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.maximum_msdu_size_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.average_data_rate_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.minimum_data_rate_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.maximum_data_rate_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.minimum_inter_txop_time_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.maximum_inter_txop_time_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.maximum_burst_size_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.exception_policy_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.inactivity_interval_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.msdu_error_rate_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.clst_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.cdesc_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.ats_tolerance_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.smallest_tolerable_data_rate_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.original_average_data_rate_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.rx_window_size_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.smoothing_buffer_size_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.bidirectional_burst_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.txops_per_beacon_period_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.ppb_threshold_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.surplus_bandwith_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.cco_bidirectional_burst_available == true); + test_fail_unless( msg.cspec.qmp_forward.cm.delay_bound == 0x01010101); + test_fail_unless( msg.cspec.qmp_forward.cm.jitter_bound == 0x10101010); + test_fail_unless( msg.cspec.qmp_forward.cm.average_msdu_size == 0XF0F0); + test_fail_unless( msg.cspec.qmp_forward.cm.maximum_msdu_size == 0XF0F0); + test_fail_unless( msg.cspec.qmp_forward.cm.average_data_rate == 0x0F0F); + test_fail_unless( msg.cspec.qmp_forward.cm.minimum_data_rate == 0x0F0F); + test_fail_unless( msg.cspec.qmp_forward.cm.maximum_data_rate == 0x0F0F); + test_fail_unless( msg.cspec.qmp_forward.cm.maximum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.cspec.qmp_forward.cm.minimum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.cspec.qmp_forward.cm.maximum_burst_size == 0x00FF); + test_fail_unless( msg.cspec.qmp_forward.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION); + test_fail_unless( msg.cspec.qmp_forward.cm.inactivity_interval == 0X00FF00FF); + test_fail_unless( msg.cspec.qmp_forward.cm.msdu_error_rate == 0x00FF); + test_fail_unless( msg.cspec.qmp_forward.cm.clst == 0x00); + test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ip_version == 0x00); + test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] == 0x01); + test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] == 0x01); + test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] == 0x01); + test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] == 0x01); + test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.source_port == 0x0FF1); + test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] == 0x01); + test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] == 0x01); + test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] == 0x01); + test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] == 0x01); + test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.destination_port == 0xFFF1); + test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.protocol_type == 0x00); + test_fail_unless( msg.cspec.qmp_forward.cm.ats_tolerance == 0x00FF); + test_fail_unless( msg.cspec.qmp_forward.cm.smallest_tolerable_data_rate == 0x00FF); + test_fail_unless( msg.cspec.qmp_forward.cm.original_average_data_rate == 0x000F); + test_fail_unless( msg.cspec.qmp_forward.cm.rx_window_size == 0x100F); + test_fail_unless( msg.cspec.qmp_forward.cm.smoothing_buffer_size == 0x100F10); + test_fail_unless( msg.cspec.qmp_forward.cm.bidirectional_burst == 0x01); + test_fail_unless( msg.cspec.qmp_forward.cco.txops_per_beacon_period == 0x15); + test_fail_unless( msg.cspec.qmp_forward.cco.average_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.cspec.qmp_forward.cco.ppb_threshold == 0x0FF0); + test_fail_unless( msg.cspec.qmp_forward.cco.surplus_bandwith == 0x0FF0); + test_fail_unless( msg.cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.cspec.qmp_forward.cco.cco_bidirectional_burst == 0x01); + + test_fail_unless( msg.cspec.qmp_forward.valid.delay_bound_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.jitter_bound_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.average_msdu_size_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.maximum_msdu_size_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.average_data_rate_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.minimum_data_rate_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.maximum_data_rate_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.minimum_inter_txop_time_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.maximum_inter_txop_time_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.maximum_burst_size_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.exception_policy_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.inactivity_interval_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.msdu_error_rate_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.clst_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.cdesc_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.ats_tolerance_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.smallest_tolerable_data_rate_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.original_average_data_rate_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.rx_window_size_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.smoothing_buffer_size_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.bidirectional_burst_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.txops_per_beacon_period_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.ppb_threshold_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.surplus_bandwith_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.cspec.qmp_forward.valid.cco_bidirectional_burst_available == true); + + test_fail_unless( msg.cspec.qmp_reverse.cm.delay_bound == 0x01010101); + test_fail_unless( msg.cspec.qmp_reverse.cm.jitter_bound == 0x10101010); + test_fail_unless( msg.cspec.qmp_reverse.cm.average_msdu_size == 0XF0F0); + test_fail_unless( msg.cspec.qmp_reverse.cm.maximum_msdu_size == 0XF0F0); + test_fail_unless( msg.cspec.qmp_reverse.cm.average_data_rate == 0x0F0F); + test_fail_unless( msg.cspec.qmp_reverse.cm.minimum_data_rate == 0x0F0F); + test_fail_unless( msg.cspec.qmp_reverse.cm.maximum_data_rate == 0x0F0F); + test_fail_unless( msg.cspec.qmp_reverse.cm.maximum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.cspec.qmp_reverse.cm.minimum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.cspec.qmp_reverse.cm.maximum_burst_size == 0x00FF); + test_fail_unless( msg.cspec.qmp_reverse.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION); + test_fail_unless( msg.cspec.qmp_reverse.cm.inactivity_interval == 0X00FF00FF); + test_fail_unless( msg.cspec.qmp_reverse.cm.msdu_error_rate == 0x00FF); + test_fail_unless( msg.cspec.qmp_reverse.cm.clst == 0x00); + test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ip_version == 0x00); + test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] == 0x01); + test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] == 0x01); + test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] == 0x01); + test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] == 0x01); + test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.source_port == 0x0FF1); + test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] == 0x01); + test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] == 0x01); + test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] == 0x01); + test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] == 0x01); + test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.destination_port == 0xFFF1); + test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.protocol_type == 0x00); + test_fail_unless( msg.cspec.qmp_reverse.cm.ats_tolerance == 0x00FF); + test_fail_unless( msg.cspec.qmp_reverse.cm.smallest_tolerable_data_rate == 0x00FF); + test_fail_unless( msg.cspec.qmp_reverse.cm.original_average_data_rate == 0x000F); + test_fail_unless( msg.cspec.qmp_reverse.cm.rx_window_size == 0x100F); + test_fail_unless( msg.cspec.qmp_reverse.cm.smoothing_buffer_size == 0x100F10); + test_fail_unless( msg.cspec.qmp_reverse.cm.bidirectional_burst == 0x01); + test_fail_unless( msg.cspec.qmp_reverse.cco.txops_per_beacon_period == 0x15); + test_fail_unless( msg.cspec.qmp_reverse.cco.average_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.cspec.qmp_reverse.cco.ppb_threshold == 0x0FF0); + test_fail_unless( msg.cspec.qmp_reverse.cco.surplus_bandwith == 0x0FF0); + test_fail_unless( msg.cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.cspec.qmp_reverse.cco.cco_bidirectional_burst == 0x01); + + test_fail_unless( msg.classifier_rule.classifier_version == CLASSIFIER_CURRENT_VERSION); + test_fail_unless( msg.classifier_rule.nbr_rules == 8 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ethernet_destination_address_field_available == 1 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ethernet_source_address_field_available == 1 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.vlan_user_priority_field_available == 0 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.vlan_id_field_available == 0 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv4_type_of_protocol_field_available == 1 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv4_protocol_field_available == 1 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv4_source_address_field_available == 1 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv4_destination_address_field_available == 1 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv6_traffic_class_field_available == 0 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv6_flow_label_field_available == 0 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv6_source_address_field_available == 0 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv6_destination_address_field_available == 0 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.tcp_source_port_field_available == 1 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.tcp_destination_port_field_available == 1 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.udp_source_port_field_available == 0 ); + test_fail_unless( msg.classifier_rule.data.classifier_rules_available.udp_destination_port_field_available == 0 ); + test_fail_unless( msg.classifier_rule.data.ethernet_destination_address[0] == 0x01 ); + test_fail_unless( msg.classifier_rule.data.ethernet_destination_address[1] == 0x02 ); + test_fail_unless( msg.classifier_rule.data.ethernet_destination_address[2] == 0x03 ); + test_fail_unless( msg.classifier_rule.data.ethernet_destination_address[3] == 0x04 ); + test_fail_unless( msg.classifier_rule.data.ethernet_destination_address[4] == 0x05 ); + test_fail_unless( msg.classifier_rule.data.ethernet_destination_address[5] == 0x06 ); + test_fail_unless( msg.classifier_rule.data.ethernet_source_address[0] == 0x06 ); + test_fail_unless( msg.classifier_rule.data.ethernet_source_address[1] == 0x05 ); + test_fail_unless( msg.classifier_rule.data.ethernet_source_address[2] == 0x04 ); + test_fail_unless( msg.classifier_rule.data.ethernet_source_address[3] == 0x03 ); + test_fail_unless( msg.classifier_rule.data.ethernet_source_address[4] == 0x02 ); + test_fail_unless( msg.classifier_rule.data.ethernet_source_address[5] == 0x01 ); + test_fail_unless( msg.classifier_rule.data.ipv4_type_of_service == 0x08 ); + test_fail_unless( msg.classifier_rule.data.ipv4_protocol == 0x02); + test_fail_unless( msg.classifier_rule.data.ipv4_source_address[0] == 0x04 ); + test_fail_unless( msg.classifier_rule.data.ipv4_source_address[1] == 0x04 ); + test_fail_unless( msg.classifier_rule.data.ipv4_source_address[2] == 0x04 ); + test_fail_unless( msg.classifier_rule.data.ipv4_source_address[3] == 0x04 ); + test_fail_unless( msg.classifier_rule.data.ipv4_destination_address[0] == 0x34 ); + test_fail_unless( msg.classifier_rule.data.ipv4_destination_address[1] == 0x34 ); + test_fail_unless( msg.classifier_rule.data.ipv4_destination_address[2] == 0x34 ); + test_fail_unless( msg.classifier_rule.data.ipv4_destination_address[3] == 0x34 ); + test_fail_unless( msg.classifier_rule.data.tcp_destination_port == 0x3454 ); + test_fail_unless( msg.classifier_rule.data.tcp_source_port == 0x5432 ); + + }test_end; + +} + + +void +test_msg_cm_conn_new_req_set_on_mme_msg(test_t t) +{ + msg_cm_conn_new_req_t msg; + msg_mme_t test_mme; + + test_case_begin(t, "TEST set_msg_cm_conn_new_req"); + + test_begin(t, "test case 1") + { + + msg_cm_conn_new_req_init(&msg); + + msg.cid = 0x5353; + + + msg.cspec.cinfo_forward.valid = CINFO_VALID; + msg.cspec.cinfo_forward.mac_service_type = MAC_CONTENTION; + msg.cspec.cinfo_forward.user_priority = USER_PRIORITY_CAP0; + msg.cspec.cinfo_forward.ats = ATS_FOR_HLE; + msg.cspec.cinfo_forward.smoothing = SMOOTHING_REQUESTED; + + msg.cspec.cinfo_reverse.valid = CINFO_VALID ; + msg.cspec.cinfo_reverse.mac_service_type = MAC_CONTENTION; + msg.cspec.cinfo_reverse.user_priority = USER_PRIORITY_CAP0; + msg.cspec.cinfo_reverse.ats = ATS_FOR_HLE; + msg.cspec.cinfo_reverse.smoothing = SMOOTHING_REQUESTED; + + msg.cspec.qmp_forward.forward_or_reverse = QMP_FORWARD; + msg.cspec.qmp_forward.valid.delay_bound_available = true; + msg.cspec.qmp_forward.valid.jitter_bound_available = true; + msg.cspec.qmp_forward.valid.average_msdu_size_available = true; + msg.cspec.qmp_forward.valid.maximum_msdu_size_available = true; + msg.cspec.qmp_forward.valid.average_data_rate_available = true; + msg.cspec.qmp_forward.valid.minimum_data_rate_available = true; + msg.cspec.qmp_forward.valid.maximum_data_rate_available = true; + msg.cspec.qmp_forward.valid.minimum_inter_txop_time_available = true; + msg.cspec.qmp_forward.valid.maximum_inter_txop_time_available = true; + msg.cspec.qmp_forward.valid.maximum_burst_size_available = true; + msg.cspec.qmp_forward.valid.exception_policy_available = true; + msg.cspec.qmp_forward.valid.inactivity_interval_available = true; + msg.cspec.qmp_forward.valid.msdu_error_rate_available = true; + msg.cspec.qmp_forward.valid.clst_available = true; + msg.cspec.qmp_forward.valid.cdesc_available = true; + msg.cspec.qmp_forward.valid.ats_tolerance_available = true; + msg.cspec.qmp_forward.valid.smallest_tolerable_data_rate_available = true; + msg.cspec.qmp_forward.valid.original_average_data_rate_available = true; + msg.cspec.qmp_forward.valid.rx_window_size_available = true; + msg.cspec.qmp_forward.valid.smoothing_buffer_size_available = true; + msg.cspec.qmp_forward.valid.bidirectional_burst_available = true; + msg.cspec.qmp_forward.valid.txops_per_beacon_period_available = true; + msg.cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available = true; + msg.cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available = true; + msg.cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available = true; + msg.cspec.qmp_forward.valid.ppb_threshold_available = true; + msg.cspec.qmp_forward.valid.surplus_bandwith_available = true; + msg.cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true; + msg.cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available = true; + msg.cspec.qmp_forward.valid.cco_bidirectional_burst_available = true; + msg.cspec.qmp_forward.cm.delay_bound = 0x01010101; + msg.cspec.qmp_forward.cm.jitter_bound = 0x10101010; + msg.cspec.qmp_forward.cm.average_msdu_size = 0XF0F0; + msg.cspec.qmp_forward.cm.maximum_msdu_size = 0XF0F0; + msg.cspec.qmp_forward.cm.average_data_rate = 0x0F0F; + msg.cspec.qmp_forward.cm.minimum_data_rate = 0x0F0F; + msg.cspec.qmp_forward.cm.maximum_data_rate = 0x0F0F; + msg.cspec.qmp_forward.cm.maximum_inter_txop_time = 0xFFFF; + msg.cspec.qmp_forward.cm.minimum_inter_txop_time = 0xFFFF; + msg.cspec.qmp_forward.cm.maximum_burst_size = 0x00FF; + msg.cspec.qmp_forward.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION; + msg.cspec.qmp_forward.cm.inactivity_interval = 0X00FF00FF; + msg.cspec.qmp_forward.cm.msdu_error_rate = 0x00FF; + msg.cspec.qmp_forward.cm.clst = 0x00; + msg.cspec.qmp_forward.cm.cdesc.ip_version = 0x00; + msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] = 0x01; + msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] = 0x01; + msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] = 0x01; + msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] = 0x01; + msg.cspec.qmp_forward.cm.cdesc.source_port = 0x0FF1; + msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] = 0x01; + msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] = 0x01; + msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] = 0x01; + msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] = 0x01; + msg.cspec.qmp_forward.cm.cdesc.destination_port = 0xFFF1; + msg.cspec.qmp_forward.cm.cdesc.protocol_type = 0x00; + msg.cspec.qmp_forward.cm.ats_tolerance = 0x00FF; + msg.cspec.qmp_forward.cm.smallest_tolerable_data_rate = 0x00FF; + msg.cspec.qmp_forward.cm.original_average_data_rate = 0x000F; + msg.cspec.qmp_forward.cm.rx_window_size = 0x100F; + msg.cspec.qmp_forward.cm.smoothing_buffer_size = 0x100F10; + msg.cspec.qmp_forward.cm.bidirectional_burst = 0x01; + msg.cspec.qmp_forward.cco.txops_per_beacon_period = 0x15; + msg.cspec.qmp_forward.cco.average_number_of_pbs_per_txop = 0x100F; + msg.cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop = 0x100F; + msg.cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop = 0x100F; + msg.cspec.qmp_forward.cco.ppb_threshold = 0x0FF0; + msg.cspec.qmp_forward.cco.surplus_bandwith = 0x0FF0; + msg.cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0; + msg.cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop = 0x0FF0; + msg.cspec.qmp_forward.cco.cco_bidirectional_burst = 0x01; + + msg.cspec.qmp_reverse.forward_or_reverse = QMP_REVERSE; + msg.cspec.qmp_reverse.valid.delay_bound_available = true; + msg.cspec.qmp_reverse.valid.jitter_bound_available = true; + msg.cspec.qmp_reverse.valid.average_msdu_size_available = true; + msg.cspec.qmp_reverse.valid.maximum_msdu_size_available = true; + msg.cspec.qmp_reverse.valid.average_data_rate_available = true; + msg.cspec.qmp_reverse.valid.minimum_data_rate_available = true; + msg.cspec.qmp_reverse.valid.maximum_data_rate_available = true; + msg.cspec.qmp_reverse.valid.minimum_inter_txop_time_available = true; + msg.cspec.qmp_reverse.valid.maximum_inter_txop_time_available = true; + msg.cspec.qmp_reverse.valid.maximum_burst_size_available = true; + msg.cspec.qmp_reverse.valid.exception_policy_available = true; + msg.cspec.qmp_reverse.valid.inactivity_interval_available = true; + msg.cspec.qmp_reverse.valid.msdu_error_rate_available = true; + msg.cspec.qmp_reverse.valid.clst_available = true; + msg.cspec.qmp_reverse.valid.cdesc_available = true; + msg.cspec.qmp_reverse.valid.ats_tolerance_available = true; + msg.cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available = true; + msg.cspec.qmp_reverse.valid.original_average_data_rate_available = true; + msg.cspec.qmp_reverse.valid.rx_window_size_available = true; + msg.cspec.qmp_reverse.valid.smoothing_buffer_size_available = true; + msg.cspec.qmp_reverse.valid.bidirectional_burst_available = true; + msg.cspec.qmp_reverse.valid.txops_per_beacon_period_available = true; + msg.cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available = true; + msg.cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available = true; + msg.cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available = true; + msg.cspec.qmp_reverse.valid.ppb_threshold_available = true; + msg.cspec.qmp_reverse.valid.surplus_bandwith_available = true; + msg.cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true; + msg.cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available = true; + msg.cspec.qmp_reverse.valid.cco_bidirectional_burst_available = true; + + msg.cspec.qmp_reverse.cm.delay_bound = 0x01010101; + msg.cspec.qmp_reverse.cm.jitter_bound = 0x10101010; + msg.cspec.qmp_reverse.cm.average_msdu_size = 0XF0F0; + msg.cspec.qmp_reverse.cm.maximum_msdu_size = 0XF0F0; + msg.cspec.qmp_reverse.cm.average_data_rate = 0x0F0F; + msg.cspec.qmp_reverse.cm.minimum_data_rate = 0x0F0F; + msg.cspec.qmp_reverse.cm.maximum_data_rate = 0x0F0F; + msg.cspec.qmp_reverse.cm.maximum_inter_txop_time = 0xFFFF; + msg.cspec.qmp_reverse.cm.minimum_inter_txop_time = 0xFFFF; + msg.cspec.qmp_reverse.cm.maximum_burst_size = 0x00FF; + msg.cspec.qmp_reverse.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION; + msg.cspec.qmp_reverse.cm.inactivity_interval = 0X00FF00FF; + msg.cspec.qmp_reverse.cm.msdu_error_rate = 0x00FF; + msg.cspec.qmp_reverse.cm.clst = 0x00; + msg.cspec.qmp_reverse.cm.cdesc.ip_version = 0x00; + msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] = 0x01; + msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] = 0x01; + msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] = 0x01; + msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] = 0x01; + msg.cspec.qmp_reverse.cm.cdesc.source_port = 0x0FF1; + msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] = 0x01; + msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] = 0x01; + msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] = 0x01; + msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] = 0x01; + msg.cspec.qmp_reverse.cm.cdesc.destination_port = 0xFFF1; + msg.cspec.qmp_reverse.cm.cdesc.protocol_type = 0x00; + msg.cspec.qmp_reverse.cm.ats_tolerance = 0x00FF; + msg.cspec.qmp_reverse.cm.smallest_tolerable_data_rate = 0x00FF; + msg.cspec.qmp_reverse.cm.original_average_data_rate = 0x000F; + msg.cspec.qmp_reverse.cm.rx_window_size = 0x100F; + msg.cspec.qmp_reverse.cm.smoothing_buffer_size = 0x100F10; + msg.cspec.qmp_reverse.cm.bidirectional_burst = 0x01; + msg.cspec.qmp_reverse.cco.txops_per_beacon_period = 0x15; + msg.cspec.qmp_reverse.cco.average_number_of_pbs_per_txop = 0x100F; + msg.cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop = 0x100F; + msg.cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop = 0x100F; + msg.cspec.qmp_reverse.cco.ppb_threshold = 0x0FF0; + msg.cspec.qmp_reverse.cco.surplus_bandwith = 0x0FF0; + msg.cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0; + msg.cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop = 0x0FF0; + msg.cspec.qmp_reverse.cco.cco_bidirectional_burst = 0x01; + + msg.classifier_rule.classifier_version = CLASSIFIER_CURRENT_VERSION; + msg.classifier_rule.nbr_rules = 8 ; + msg.classifier_rule.data.classifier_rules_available.ethernet_destination_address_field_available = 1 ; + msg.classifier_rule.data.classifier_rules_available.ethernet_source_address_field_available = 1 ; + msg.classifier_rule.data.classifier_rules_available.vlan_user_priority_field_available = 0 ; + msg.classifier_rule.data.classifier_rules_available.vlan_id_field_available = 0 ; + msg.classifier_rule.data.classifier_rules_available.ipv4_type_of_protocol_field_available = 1 ; + msg.classifier_rule.data.classifier_rules_available.ipv4_protocol_field_available = 1 ; + msg.classifier_rule.data.classifier_rules_available.ipv4_source_address_field_available = 1 ; + msg.classifier_rule.data.classifier_rules_available.ipv4_destination_address_field_available = 1 ; + msg.classifier_rule.data.classifier_rules_available.ipv6_traffic_class_field_available = 0 ; + msg.classifier_rule.data.classifier_rules_available.ipv6_flow_label_field_available = 0 ; + msg.classifier_rule.data.classifier_rules_available.ipv6_source_address_field_available = 0 ; + msg.classifier_rule.data.classifier_rules_available.ipv6_destination_address_field_available = 0 ; + msg.classifier_rule.data.classifier_rules_available.tcp_source_port_field_available = 1 ; + msg.classifier_rule.data.classifier_rules_available.tcp_destination_port_field_available = 1 ; + msg.classifier_rule.data.classifier_rules_available.udp_source_port_field_available = 0 ; + msg.classifier_rule.data.classifier_rules_available.udp_destination_port_field_available = 0 ; + msg.classifier_rule.data.ethernet_destination_address[0] = 0x01 ; + msg.classifier_rule.data.ethernet_destination_address[1] = 0x02 ; + msg.classifier_rule.data.ethernet_destination_address[2] = 0x03 ; + msg.classifier_rule.data.ethernet_destination_address[3] = 0x04 ; + msg.classifier_rule.data.ethernet_destination_address[4] = 0x05 ; + msg.classifier_rule.data.ethernet_destination_address[5] = 0x06 ; + msg.classifier_rule.data.ethernet_source_address[0] = 0x06 ; + msg.classifier_rule.data.ethernet_source_address[1] = 0x05 ; + msg.classifier_rule.data.ethernet_source_address[2] = 0x04 ; + msg.classifier_rule.data.ethernet_source_address[3] = 0x03 ; + msg.classifier_rule.data.ethernet_source_address[4] = 0x02 ; + msg.classifier_rule.data.ethernet_source_address[5] = 0x01 ; + msg.classifier_rule.data.ipv4_type_of_service = 0x08 ; + msg.classifier_rule.data.ipv4_protocol = 0x02; + msg.classifier_rule.data.ipv4_source_address[0] = 0x04 ; + msg.classifier_rule.data.ipv4_source_address[1] = 0x04 ; + msg.classifier_rule.data.ipv4_source_address[2] = 0x04 ; + msg.classifier_rule.data.ipv4_source_address[3] = 0x04 ; + msg.classifier_rule.data.ipv4_destination_address[0] = 0x34 ; + msg.classifier_rule.data.ipv4_destination_address[1] = 0x34 ; + msg.classifier_rule.data.ipv4_destination_address[2] = 0x34 ; + msg.classifier_rule.data.ipv4_destination_address[3] = 0x34 ; + msg.classifier_rule.data.tcp_destination_port = 0x3454 ; + msg.classifier_rule.data.tcp_source_port = 0x5432 ; + + + msg_cm_conn_new_req_set_on_mme_msg(&test_mme, &msg); + + { + // test block + int i; + + for(i=0; i < 378; i++) + { + test_fail_unless(test_mme.mm_entry[i] == msg_cm_conn_new_req.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_mme.mm_entry[i],msg_cm_conn_new_req.mm_entry[i]); + } + } + } + test_end; +} + + + +void +test_msg_cm_conn_new_req(test_t t) +{ + dbg_assert(t); + + test_suite_begin(t, "TEST MESSAGE CM_CONN_NEW_REQ"); + + test_msg_cm_conn_new_req_get_from_mme_msg(t); + test_msg_cm_conn_new_req_set_on_mme_msg(t); + + +} diff --git a/cp/msg/test/src/test_msg_cm_conn_rel_ind.c b/cp/msg/test/src/test_msg_cm_conn_rel_ind.c new file mode 100644 index 0000000000..2e4abb8e4b --- /dev/null +++ b/cp/msg/test/src/test_msg_cm_conn_rel_ind.c @@ -0,0 +1,800 @@ +/* Cesar project {{{ + * + * Copyright (C) 2007 Spidcom + * + * <<>> + * + * }}} + * \file test_msg_cm_conn_rel_ind.c + * \brief This file provides management functions for message CM_CONN_REL.IND. + * \ingroup cp/msg + * + */ + + +#include "common/std.h" +#include "cp/msg/inc/msg_cm.h" + + +msg_mme_t msg_cm_conn_rel_ind_1 = +{ + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA + 0, // vlan tag + 0x88E1, + 0, // mmv + CM_CONN_NEW_CNF, + {0,0,0}, + { + 0x53, // CID (=0x5325) + 0x25, // CID + 0x01, // reason code (=violated cspec) + 0x01, // CSPEC Length :338 bytes + 0x54, // CSPEC Length : + CINFO_VALID, // CINFO Valid? CINFO Forward + MAC_CONTENTION, // Mac Service Type + USER_PRIORITY_CAP0, // User Priori ty + ATS_FOR_HLE, // Arrival Time Stamp + SMOOTHING_REQUESTED, // Smoothing + CINFO_VALID, // CINFO Valid? CINFO Reverse + MAC_CONTENTION, // Mac Service Type + USER_PRIORITY_CAP0, // User Priority + ATS_FOR_HLE, // Arrival Time Stamp + SMOOTHING_REQUESTED, // Smoothing + QMP_FORWARD, + 0x04, // QMP body length + 0x00, // FID: Delay bound + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + QMP_FORWARD, + 0x04, // QMP body length + 0x01, // FID: Jitter bound + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x02, // FID: Average MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x03, // FID: Maximum MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x04, // FID: Average Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x05, // FID: Minimum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x06, // FID: Maximum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x07, // FID: Maximum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x08, // FID: Minimum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x09, // FID: Maximum Burst Size + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x0A, // FID: Exception Policy + 0x01, // QMP BODY + QMP_FORWARD, + 0x04, // QMP body length + 0x0B, // FID: inactivity_interval + 0x00, // QMP BODY + 0xFF, // QMP BODY + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x0C, // FID: MSDU Error Rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x0D, // FID: CLST + 0x00, // QMP BODY + QMP_FORWARD, + 0x0E, // QMP body length + 0x0E, // FID: CDESC + 0x00, // IP Version 4 + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x0F, // source port + 0xF1, // source port + 0x01, // Dest IP + 0x01, // dest IP + 0x01, // dest IP + 0x01, // dest IP + 0xFF, // dest port + 0xF1, // dest port + 0x00, // ip proto type + QMP_FORWARD, + 0x02, // QMP body length + 0x10, // FID: ATS Tolerance + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x11, // FID: Smallest tolerable Average data rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x12, // FID: Original Average data rate + 0x00, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x13, // FID: rx_window_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x03, // QMP body length + 0x14, // FID: smoothing_buffer_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + 0x10, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x15, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x80, // FID: TXOPs per Beacon Period + 0x15, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x81, // FID: Average Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x82, // FID: Minimum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x83, // FID: Maximum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x84, // FID: PPB_Threshold + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x85, // 0x0FID: Surplus Bandwidth + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x02, // QMP body length + 0x88, // FID: Original Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_FORWARD, + 0x01, // QMP body length + 0x89, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x00, // FID: Delay bound + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x01, // FID: Jitter bound + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + 0x10, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x02, // FID: Average MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x03, // FID: Maximum MSDU Size + 0xF0, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x04, // FID: Average Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x05, // FID: Minimum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x06, // FID: Maximum Data Rate + 0x0F, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x07, // FID: Maximum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x08, // FID: Minimum Inter-TXOP time + 0xFF, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x09, // FID: Maximum Burst Size + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x0A, // FID: Exception Policy + 0x01, // QMP BODY + QMP_REVERSE, + 0x04, // QMP body length + 0x0B, // FID: inactivity_interval + 0x00, // QMP BODY + 0xFF, // QMP BODY + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x0C, // FID: MSDU Error Rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x0D, // FID: CLST + 0x00, // QMP BODY + QMP_REVERSE, + 0x0E, // QMP body length + 0x0E, // FID: CDESC + 0x00, // IP Version 4 + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x01, // Source IP + 0x0F, // source port + 0xF1, // source port + 0x01, // Dest IP + 0x01, // dest IP + 0x01, // dest IP + 0x01, // dest IP + 0xFF, // dest port + 0xF1, // dest port + 0x00, // ip proto type + QMP_REVERSE, + 0x02, // QMP body length + 0x10, // FID: ATS Tolerance + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x11, // FID: Smallest tolerable Average data rate + 0x00, // QMP BODY + 0xFF, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x12, // FID: Original Average data rate + 0x00, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x13, // FID: rx_window_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x03, // QMP body length + 0x14, // FID: smoothing_buffer_size + 0x10, // QMP BODY + 0x0F, // QMP BODY + 0x10, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x15, // FID: Bidirectional Burst + 0x01, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x80, // FID: TXOPs per Beacon Period + 0x15, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x81, // FID: Average Number of PBs per TXOP + 0x10, // QMP BODY copy + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x82, // FID: Minimum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x83, // FID: Maximum Number of PBs per TXOP + 0x10, // QMP BODY + 0x0F, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x84, // FID: PPB_Threshold + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x85, // FID: Surplus Bandwidth + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x02, // QMP body length + 0x88, // FID: Original Average Number of PBs per TXOP + 0x0F, // QMP BODY + 0xF0, // QMP BODY + QMP_REVERSE, + 0x01, // QMP body length + 0x89, // FID: Bidirectional Burst + 0x01, // QMP BODY + } +}; + +msg_mme_t msg_cm_conn_rel_ind_2 = +{ + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA + 0, // vlan tag + 0x88E1, + 0, // mmv + CM_CONN_NEW_CNF, + {0,0,0}, + { + 0x53, // CID (=0x5325) + 0x25, // CID + 0x00 // reason code (= normal release) + } +}; + + +void +test_msg_cm_conn_rel_ind_set_on_mme_msg(test_t t) +{ + msg_cm_conn_rel_ind_t msg; + + test_case_begin(t, "TEST msg_cm_conn_rel_ind_set_on_mme_msg"); + + test_begin(t, "test case 1") + { + + msg_cm_conn_rel_ind_init(&msg); + + + + msg.cid = 0x5325; + msg.reason_code = VIOLATED_CSPEC; + msg.violated_cspec.cinfo_forward.valid = CINFO_VALID; + msg.violated_cspec.cinfo_forward.mac_service_type = MAC_CONTENTION; + msg.violated_cspec.cinfo_forward.user_priority = USER_PRIORITY_CAP0; + msg.violated_cspec.cinfo_forward.ats = ATS_FOR_HLE; + msg.violated_cspec.cinfo_forward.smoothing = SMOOTHING_REQUESTED; + + msg.violated_cspec.cinfo_reverse.valid = CINFO_VALID; + msg.violated_cspec.cinfo_reverse.mac_service_type = MAC_CONTENTION; + msg.violated_cspec.cinfo_reverse.user_priority = USER_PRIORITY_CAP0; + msg.violated_cspec.cinfo_reverse.ats = ATS_FOR_HLE; + msg.violated_cspec.cinfo_reverse.smoothing = SMOOTHING_REQUESTED; + + msg.violated_cspec.qmp_forward.valid.delay_bound_available = true; + msg.violated_cspec.qmp_forward.valid.jitter_bound_available = true; + msg.violated_cspec.qmp_forward.valid.average_msdu_size_available = true; + msg.violated_cspec.qmp_forward.valid.maximum_msdu_size_available = true; + msg.violated_cspec.qmp_forward.valid.average_data_rate_available = true; + msg.violated_cspec.qmp_forward.valid.minimum_data_rate_available = true; + msg.violated_cspec.qmp_forward.valid.maximum_data_rate_available = true; + msg.violated_cspec.qmp_forward.valid.minimum_inter_txop_time_available = true; + msg.violated_cspec.qmp_forward.valid.maximum_inter_txop_time_available = true; + msg.violated_cspec.qmp_forward.valid.maximum_burst_size_available = true; + msg.violated_cspec.qmp_forward.valid.exception_policy_available = true; + msg.violated_cspec.qmp_forward.valid.inactivity_interval_available = true; + msg.violated_cspec.qmp_forward.valid.msdu_error_rate_available = true; + msg.violated_cspec.qmp_forward.valid.clst_available = true; + msg.violated_cspec.qmp_forward.valid.cdesc_available = true; + msg.violated_cspec.qmp_forward.valid.ats_tolerance_available = true; + msg.violated_cspec.qmp_forward.valid.smallest_tolerable_data_rate_available = true; + msg.violated_cspec.qmp_forward.valid.original_average_data_rate_available = true; + msg.violated_cspec.qmp_forward.valid.rx_window_size_available = true; + msg.violated_cspec.qmp_forward.valid.smoothing_buffer_size_available = true; + msg.violated_cspec.qmp_forward.valid.bidirectional_burst_available = true; + msg.violated_cspec.qmp_forward.valid.txops_per_beacon_period_available = true; + msg.violated_cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available = true; + msg.violated_cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available = true; + msg.violated_cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available = true; + msg.violated_cspec.qmp_forward.valid.ppb_threshold_available = true; + msg.violated_cspec.qmp_forward.valid.surplus_bandwith_available = true; + msg.violated_cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true; + msg.violated_cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available = true; + msg.violated_cspec.qmp_forward.valid.cco_bidirectional_burst_available = true; + msg.violated_cspec.qmp_forward.cm.delay_bound = 0x01010101; + msg.violated_cspec.qmp_forward.cm.jitter_bound = 0x10101010; + msg.violated_cspec.qmp_forward.cm.average_msdu_size = 0XF0F0; + msg.violated_cspec.qmp_forward.cm.maximum_msdu_size = 0XF0F0; + msg.violated_cspec.qmp_forward.cm.average_data_rate = 0x0F0F; + msg.violated_cspec.qmp_forward.cm.minimum_data_rate = 0x0F0F; + msg.violated_cspec.qmp_forward.cm.maximum_data_rate = 0x0F0F; + msg.violated_cspec.qmp_forward.cm.maximum_inter_txop_time = 0xFFFF; + msg.violated_cspec.qmp_forward.cm.minimum_inter_txop_time = 0xFFFF; + msg.violated_cspec.qmp_forward.cm.maximum_burst_size = 0x00FF; + msg.violated_cspec.qmp_forward.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION; + msg.violated_cspec.qmp_forward.cm.inactivity_interval = 0X00FF00FF; + msg.violated_cspec.qmp_forward.cm.msdu_error_rate = 0x00FF; + msg.violated_cspec.qmp_forward.cm.clst = 0x00; + msg.violated_cspec.qmp_forward.cm.cdesc.ip_version = 0x00; + msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] = 0x01; + msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] = 0x01; + msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] = 0x01; + msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] = 0x01; + msg.violated_cspec.qmp_forward.cm.cdesc.source_port = 0x0FF1; + msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] = 0x01; + msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] = 0x01; + msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] = 0x01; + msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] = 0x01; + msg.violated_cspec.qmp_forward.cm.cdesc.destination_port = 0xFFF1; + msg.violated_cspec.qmp_forward.cm.cdesc.protocol_type = 0x00; + msg.violated_cspec.qmp_forward.cm.ats_tolerance = 0x00FF; + msg.violated_cspec.qmp_forward.cm.smallest_tolerable_data_rate = 0x00FF; + msg.violated_cspec.qmp_forward.cm.original_average_data_rate = 0x000F; + msg.violated_cspec.qmp_forward.cm.rx_window_size = 0x100F; + msg.violated_cspec.qmp_forward.cm.smoothing_buffer_size = 0x100F10; + msg.violated_cspec.qmp_forward.cm.bidirectional_burst = 0x01; + msg.violated_cspec.qmp_forward.cco.txops_per_beacon_period = 0x15; + msg.violated_cspec.qmp_forward.cco.average_number_of_pbs_per_txop = 0x100F; + msg.violated_cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop = 0x100F; + msg.violated_cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop = 0x100F; + msg.violated_cspec.qmp_forward.cco.ppb_threshold = 0x0FF0; + msg.violated_cspec.qmp_forward.cco.surplus_bandwith = 0x0FF0; + msg.violated_cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0; + msg.violated_cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop = 0x0FF0; + msg.violated_cspec.qmp_forward.cco.cco_bidirectional_burst = 0x01; + + msg.violated_cspec.qmp_reverse.valid.delay_bound_available = true; + msg.violated_cspec.qmp_reverse.valid.jitter_bound_available = true; + msg.violated_cspec.qmp_reverse.valid.average_msdu_size_available = true; + msg.violated_cspec.qmp_reverse.valid.maximum_msdu_size_available = true; + msg.violated_cspec.qmp_reverse.valid.average_data_rate_available = true; + msg.violated_cspec.qmp_reverse.valid.minimum_data_rate_available = true; + msg.violated_cspec.qmp_reverse.valid.maximum_data_rate_available = true; + msg.violated_cspec.qmp_reverse.valid.minimum_inter_txop_time_available = true; + msg.violated_cspec.qmp_reverse.valid.maximum_inter_txop_time_available = true; + msg.violated_cspec.qmp_reverse.valid.maximum_burst_size_available = true; + msg.violated_cspec.qmp_reverse.valid.exception_policy_available = true; + msg.violated_cspec.qmp_reverse.valid.inactivity_interval_available = true; + msg.violated_cspec.qmp_reverse.valid.msdu_error_rate_available = true; + msg.violated_cspec.qmp_reverse.valid.clst_available = true; + msg.violated_cspec.qmp_reverse.valid.cdesc_available = true; + msg.violated_cspec.qmp_reverse.valid.ats_tolerance_available = true; + msg.violated_cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available = true; + msg.violated_cspec.qmp_reverse.valid.original_average_data_rate_available = true; + msg.violated_cspec.qmp_reverse.valid.rx_window_size_available = true; + msg.violated_cspec.qmp_reverse.valid.smoothing_buffer_size_available = true; + msg.violated_cspec.qmp_reverse.valid.bidirectional_burst_available = true; + msg.violated_cspec.qmp_reverse.valid.txops_per_beacon_period_available = true; + msg.violated_cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available = true; + msg.violated_cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available = true; + msg.violated_cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available = true; + msg.violated_cspec.qmp_reverse.valid.ppb_threshold_available = true; + msg.violated_cspec.qmp_reverse.valid.surplus_bandwith_available = true; + msg.violated_cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true; + msg.violated_cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available = true; + msg.violated_cspec.qmp_reverse.valid.cco_bidirectional_burst_available = true; + msg.violated_cspec.qmp_reverse.cm.delay_bound = 0x01010101; + msg.violated_cspec.qmp_reverse.cm.jitter_bound = 0x10101010; + msg.violated_cspec.qmp_reverse.cm.average_msdu_size = 0XF0F0; + msg.violated_cspec.qmp_reverse.cm.maximum_msdu_size = 0XF0F0; + msg.violated_cspec.qmp_reverse.cm.average_data_rate = 0x0F0F; + msg.violated_cspec.qmp_reverse.cm.minimum_data_rate = 0x0F0F; + msg.violated_cspec.qmp_reverse.cm.maximum_data_rate = 0x0F0F; + msg.violated_cspec.qmp_reverse.cm.maximum_inter_txop_time = 0xFFFF; + msg.violated_cspec.qmp_reverse.cm.minimum_inter_txop_time = 0xFFFF; + msg.violated_cspec.qmp_reverse.cm.maximum_burst_size = 0x00FF; + msg.violated_cspec.qmp_reverse.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION; + msg.violated_cspec.qmp_reverse.cm.inactivity_interval = 0X00FF00FF; + msg.violated_cspec.qmp_reverse.cm.msdu_error_rate = 0x00FF; + msg.violated_cspec.qmp_reverse.cm.clst = 0x00; + msg.violated_cspec.qmp_reverse.cm.cdesc.ip_version = 0x00; + msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] = 0x01; + msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] = 0x01; + msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] = 0x01; + msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] = 0x01; + msg.violated_cspec.qmp_reverse.cm.cdesc.source_port = 0x0FF1; + msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] = 0x01; + msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] = 0x01; + msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] = 0x01; + msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] = 0x01; + msg.violated_cspec.qmp_reverse.cm.cdesc.destination_port = 0xFFF1; + msg.violated_cspec.qmp_reverse.cm.cdesc.protocol_type = 0x00; + msg.violated_cspec.qmp_reverse.cm.ats_tolerance = 0x00FF; + msg.violated_cspec.qmp_reverse.cm.smallest_tolerable_data_rate = 0x00FF; + msg.violated_cspec.qmp_reverse.cm.original_average_data_rate = 0x000F; + msg.violated_cspec.qmp_reverse.cm.rx_window_size = 0x100F; + msg.violated_cspec.qmp_reverse.cm.smoothing_buffer_size = 0x100F10; + msg.violated_cspec.qmp_reverse.cm.bidirectional_burst = 0x01; + msg.violated_cspec.qmp_reverse.cco.txops_per_beacon_period = 0x15; + msg.violated_cspec.qmp_reverse.cco.average_number_of_pbs_per_txop = 0x100F; + msg.violated_cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop = 0x100F; + msg.violated_cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop = 0x100F; + msg.violated_cspec.qmp_reverse.cco.ppb_threshold = 0x0FF0; + msg.violated_cspec.qmp_reverse.cco.surplus_bandwith = 0x0FF0; + msg.violated_cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0; + msg.violated_cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop = 0x0FF0; + msg.violated_cspec.qmp_reverse.cco.cco_bidirectional_burst = 0x01; + + + { + + msg_mme_t test_mme; + + msg_cm_conn_rel_ind_set_on_mme_msg(&test_mme, &msg); + + + int i; + + for(i=0; i < 342; i++) + { + test_fail_unless(test_mme.mm_entry[i] == msg_cm_conn_rel_ind_1.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_mme.mm_entry[i],msg_cm_conn_rel_ind_1.mm_entry[i]); + } + } + + + }test_end; + + + test_begin(t,"test case 2"); + { + + msg.cid = 0x5325; + msg.reason_code = NORMAL_RELEASE; + + + { + msg_mme_t test_mme; + + msg_cm_conn_rel_ind_set_on_mme_msg(&test_mme, &msg); + + int i; + + for(i=0; i<2 ;i++) + { + test_fail_unless(test_mme.mm_entry[i] == msg_cm_conn_rel_ind_2.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_mme.mm_entry[i],msg_cm_conn_rel_ind_2.mm_entry[i]); + } + } + + }test_end; +} + + +void +test_msg_cm_conn_rel_ind_get_from_mme_msg(test_t t) +{ + msg_cm_conn_rel_ind_t msg; + + test_case_begin(t, "TEST msg_cm_conn_rel_ind_get_from_mme_msg"); + + test_begin(t, "test case 1") + { + msg_cm_conn_rel_ind_init(&msg); + + msg_cm_conn_rel_ind_get_from_mme_msg(&msg_cm_conn_rel_ind_1, &msg); + + test_fail_unless( msg.cid == 0x5325 ); + test_fail_unless( msg.reason_code == VIOLATED_CSPEC ); + test_fail_unless(msg.violated_cspec.cinfo_forward.valid == CINFO_VALID ); + test_fail_unless(msg.violated_cspec.cinfo_forward.mac_service_type == MAC_CONTENTION); + test_fail_unless(msg.violated_cspec.cinfo_forward.user_priority == USER_PRIORITY_CAP0); + test_fail_unless(msg.violated_cspec.cinfo_forward.ats == ATS_FOR_HLE); + test_fail_unless(msg.violated_cspec.cinfo_forward.smoothing = SMOOTHING_REQUESTED); + + test_fail_unless(msg.violated_cspec.cinfo_reverse.valid == CINFO_VALID ); + test_fail_unless(msg.violated_cspec.cinfo_reverse.mac_service_type == MAC_CONTENTION); + test_fail_unless(msg.violated_cspec.cinfo_reverse.user_priority == USER_PRIORITY_CAP0); + test_fail_unless(msg.violated_cspec.cinfo_reverse.ats == ATS_FOR_HLE); + test_fail_unless(msg.violated_cspec.cinfo_reverse.smoothing = SMOOTHING_REQUESTED); + + test_fail_unless( msg.violated_cspec.qmp_forward.valid.delay_bound_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.jitter_bound_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.average_msdu_size_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_msdu_size_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.average_data_rate_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.minimum_data_rate_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_data_rate_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.minimum_inter_txop_time_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_inter_txop_time_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_burst_size_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.exception_policy_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.inactivity_interval_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.msdu_error_rate_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.clst_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.cdesc_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.ats_tolerance_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.smallest_tolerable_data_rate_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.original_average_data_rate_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.rx_window_size_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.smoothing_buffer_size_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.bidirectional_burst_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.txops_per_beacon_period_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.ppb_threshold_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.surplus_bandwith_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.cco_bidirectional_burst_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.delay_bound == 0x01010101); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.jitter_bound == 0x10101010); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.average_msdu_size == 0XF0F0); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.maximum_msdu_size == 0XF0F0); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.average_data_rate == 0x0F0F); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.minimum_data_rate == 0x0F0F); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.maximum_data_rate == 0x0F0F); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.maximum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.minimum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.maximum_burst_size == 0x00FF); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.inactivity_interval == 0X00FF00FF); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.msdu_error_rate == 0x00FF); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.clst == 0x00); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ip_version == 0x00); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.source_port == 0x0FF1); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.destination_port == 0xFFF1); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.protocol_type == 0x00); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.ats_tolerance == 0x00FF); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.smallest_tolerable_data_rate == 0x00FF); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.original_average_data_rate == 0x000F); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.rx_window_size == 0x100F); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.smoothing_buffer_size == 0x100F10); + test_fail_unless( msg.violated_cspec.qmp_forward.cm.bidirectional_burst == 0x01); + test_fail_unless( msg.violated_cspec.qmp_forward.cco.txops_per_beacon_period == 0x15); + test_fail_unless( msg.violated_cspec.qmp_forward.cco.average_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.violated_cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.violated_cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.violated_cspec.qmp_forward.cco.ppb_threshold == 0x0FF0); + test_fail_unless( msg.violated_cspec.qmp_forward.cco.surplus_bandwith == 0x0FF0); + test_fail_unless( msg.violated_cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.violated_cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.violated_cspec.qmp_forward.cco.cco_bidirectional_burst == 0x01); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.delay_bound_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.jitter_bound_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.average_msdu_size_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_msdu_size_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.average_data_rate_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.minimum_data_rate_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_data_rate_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.minimum_inter_txop_time_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_inter_txop_time_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.exception_policy_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.inactivity_interval_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.msdu_error_rate_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.clst_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.cdesc_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.ats_tolerance_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.smallest_tolerable_data_rate_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.original_average_data_rate_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.rx_window_size_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.smoothing_buffer_size_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.bidirectional_burst_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.ppb_threshold_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.surplus_bandwith_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true); + test_fail_unless( msg.violated_cspec.qmp_forward.valid.cco_bidirectional_burst_available == true); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.delay_bound == 0x01010101); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.jitter_bound == 0x10101010); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.average_msdu_size == 0XF0F0); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.maximum_msdu_size == 0XF0F0); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.average_data_rate == 0x0F0F); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.minimum_data_rate == 0x0F0F); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.maximum_data_rate == 0x0F0F); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.maximum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.minimum_inter_txop_time == 0xFFFF); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.maximum_burst_size == 0x00FF); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.inactivity_interval == 0X00FF00FF); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.msdu_error_rate == 0x00FF); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.clst == 0x00); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ip_version == 0x00); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.source_port == 0x0FF1); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] == 0x01); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.destination_port == 0xFFF1); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.protocol_type == 0x00); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.ats_tolerance == 0x00FF); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.smallest_tolerable_data_rate == 0x00FF); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.original_average_data_rate == 0x000F); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.rx_window_size == 0x100F); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.smoothing_buffer_size == 0x100F10); + test_fail_unless( msg.violated_cspec.qmp_reverse.cm.bidirectional_burst == 0x01); + test_fail_unless( msg.violated_cspec.qmp_reverse.cco.txops_per_beacon_period == 0x15); + test_fail_unless( msg.violated_cspec.qmp_reverse.cco.average_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.violated_cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.violated_cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop == 0x100F); + test_fail_unless( msg.violated_cspec.qmp_reverse.cco.ppb_threshold == 0x0FF0); + test_fail_unless( msg.violated_cspec.qmp_reverse.cco.surplus_bandwith == 0x0FF0); + test_fail_unless( msg.violated_cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.violated_cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop == 0x0FF0); + test_fail_unless( msg.violated_cspec.qmp_reverse.cco.cco_bidirectional_burst == 0x01); + + + }test_end; + + test_begin(t, "test case 2") + { + msg_cm_conn_rel_ind_init(&msg); + + msg_cm_conn_rel_ind_get_from_mme_msg(&msg_cm_conn_rel_ind_2, &msg); + + test_fail_unless( msg.cid == 0x5325 ); + test_fail_unless( msg.reason_code == NORMAL_RELEASE ); + }test_end; +} + + +void +test_msg_cm_conn_rel_ind(test_t t) +{ + dbg_assert(t); + + test_suite_begin(t, "TEST MESSAGE CM_CONN_REL_IND"); + + test_msg_cm_conn_rel_ind_get_from_mme_msg(t); + test_msg_cm_conn_rel_ind_set_on_mme_msg(t); + +} diff --git a/cp/msg/test/src/test_msg_cm_conn_rel_rsp.c b/cp/msg/test/src/test_msg_cm_conn_rel_rsp.c new file mode 100644 index 0000000000..024fcefebc --- /dev/null +++ b/cp/msg/test/src/test_msg_cm_conn_rel_rsp.c @@ -0,0 +1,90 @@ +/* Cesar project {{{ + * + * Copyright (C) 2007 Spidcom + * + * <<>> + * + * }}} + * \file test_msg_cm_conn_rel_rsp.c + * \brief File Description + * \ingroup cp/msg + * + */ + + +#include "common/std.h" +#include "cp/msg/inc/msg_cm.h" + + +msg_mme_t msg_cm_conn_rel_rsp_1 = +{ + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA + 0, // vlan tag + 0x88E1, + 0, // mmv + CM_CONN_REL_RSP, + {0,0,0}, + { + 0x53, + 0x25 + } +}; + + + +void +test_msg_cm_conn_rel_rsp_get_from_mme_msg(test_t t) +{ + msg_cm_conn_rel_rsp_t msg; + + test_case_begin(t, "TEST msg_cm_conn_rel_rsp_get_from_mme_msg"); + + test_begin(t, "test case 1") + { + msg_cm_conn_rel_rsp_init(&msg); + + msg_cm_conn_rel_rsp_get_from_mme_msg(&msg_cm_conn_rel_rsp_1, &msg); + + test_fail_unless(msg.cid == 0x5325); + + }test_end; +} + + + +void +test_msg_cm_conn_rel_rsp_set_on_mme_msg(test_t t) +{ + msg_cm_conn_rel_rsp_t msg; + msg_mme_t result; + + test_case_begin(t, "TEST msg_cm_conn_rel_rsp_set_on_mme_msg"); + + test_begin(t, "test case 1") + { + msg_cm_conn_rel_rsp_init(&msg); + + msg.cid = 0x5325; + + msg_cm_conn_rel_rsp_set_on_mme_msg(&result, &msg); + + test_fail_unless( result.mm_entry[0] == 0x53); + test_fail_unless( result.mm_entry[1] == 0x25); + + }test_end; +} + + + +void +test_msg_cm_conn_rel_rsp(test_t t) +{ + dbg_assert(t); + + test_suite_begin(t, "TEST MESSAGE CM_CONN_REL_RSP"); + + test_msg_cm_conn_rel_rsp_get_from_mme_msg(t); + test_msg_cm_conn_rel_rsp_set_on_mme_msg(t); + +} diff --git a/cp/msg/test/src/test_msg_field.c b/cp/msg/test/src/test_msg_field.c index fc4eb17e9d..2663c13209 100644 --- a/cp/msg/test/src/test_msg_field.c +++ b/cp/msg/test/src/test_msg_field.c @@ -137,7 +137,7 @@ u8 test_stream_forward_1[255] = QMP_FORWARD, 0x01, // QMP body length 0x15, // FID: Bidirectional Burst - 0x10, // QMP BODY + 0x01, // QMP BODY QMP_FORWARD, 0x01, // QMP body length 0x80, // FID: TXOPs per Beacon Period @@ -307,7 +307,7 @@ u8 test_stream_reverse_1[255] = QMP_REVERSE, 0x01, // QMP body length 0x15, // FID: Bidirectional Burst - 0x10, // QMP BODY + 0x01, // QMP BODY QMP_REVERSE, 0x01, // QMP body length 0x80, // FID: TXOPs per Beacon Period @@ -495,7 +495,7 @@ msg_mme_t test_msg_1 = { { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }, // MAC_ADDRESS QMP_FORWARD, 0x01, // QMP body length 0x15, // FID: Bidirectional Burst - 0x10, // QMP BODY + 0x01, // QMP BODY QMP_FORWARD, 0x01, // QMP body length 0x80, // FID: TXOPs per Beacon Period @@ -659,7 +659,7 @@ msg_mme_t test_msg_1 = { { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }, // MAC_ADDRESS QMP_REVERSE, 0x01, // QMP body length 0x15, // FID: Bidirectional Burst - 0x10, // QMP BODY + 0x01, // QMP BODY QMP_REVERSE, 0x01, // QMP body length 0x80, // FID: TXOPs per Beacon Period @@ -880,7 +880,7 @@ msg_mme_t test_msg_2 = { { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }, // MAC_ADDRESS QMP_FORWARD, 0x01, // QMP body length 0x15, // FID: Bidirectional Burst - 0x10, // QMP BODY + 0x01, // QMP BODY QMP_FORWARD, 0x01, // QMP body length 0x80, // FID: TXOPs per Beacon Period @@ -1005,7 +1005,7 @@ msg_mme_t test_msg_3 = { { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }, // MAC_ADDRESS { 0x53, // CID 0x53, // CID 0x00, // CSPEC Length - 0xA4, // CSPEC Length + 0xAF, // CSPEC Length CINFO_NOT_VALID, // CINFO Valid? CINFO Forward CINFO_VALID, // CINFO Valid? CINFO Reverse MAC_CONTENTION, // Mac Service Type @@ -1132,7 +1132,7 @@ msg_mme_t test_msg_3 = { { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }, // MAC_ADDRESS QMP_REVERSE, 0x01, // QMP body length 0x15, // FID: Bidirectional Burst - 0x10, // QMP BODY + 0x01, // QMP BODY QMP_REVERSE, 0x01, // QMP body length 0x80, // FID: TXOPs per Beacon Period @@ -1334,11 +1334,11 @@ conn_test_set_cinfo_on_stream(test_t t ) test_begin(t, "test case 1 : cinfo valid") { - init_cinfo(&local_cinfo); + msg_field_cinfo_init(&local_cinfo); local_cinfo.valid = CINFO_NOT_VALID; - len = set_cinfo_on_stream(stream, &local_cinfo); + len = msg_field_cinfo_set_on_stream(stream, &local_cinfo); test_fail_unless( len == 1); test_fail_unless( stream[0] == CINFO_NOT_VALID); @@ -1347,7 +1347,7 @@ conn_test_set_cinfo_on_stream(test_t t ) test_begin(t, "test case 2 : cinfo not valid") { - init_cinfo(&local_cinfo); + msg_field_cinfo_init(&local_cinfo); local_cinfo.valid = CINFO_VALID; local_cinfo.mac_service_type = MAC_CONTENTION; @@ -1355,7 +1355,7 @@ conn_test_set_cinfo_on_stream(test_t t ) local_cinfo.ats = ATS_FOR_HLE; local_cinfo.smoothing = SMOOTHING_REQUESTED; - len = set_cinfo_on_stream(stream, &local_cinfo); + len = msg_field_cinfo_set_on_stream(stream, &local_cinfo); test_fail_unless( len == 5); test_fail_unless( stream[0] == CINFO_VALID); @@ -1380,9 +1380,9 @@ conn_test_get_cinfo_from_stream(test_t t) { u8 stream = CINFO_NOT_VALID; - init_cinfo( &local_cinfo ); + msg_field_cinfo_init( &local_cinfo ); - len = get_cinfo_from_stream(&stream, &local_cinfo); + len = msg_field_cinfo_get_from_stream(&stream, &local_cinfo); test_fail_unless( len == 1); test_fail_unless( local_cinfo.valid == CINFO_NOT_VALID); @@ -1395,9 +1395,9 @@ conn_test_get_cinfo_from_stream(test_t t) u8 stream[5] = {CINFO_VALID, 0X00, 0X01, 0X01, 0X00}; - init_cinfo(&local_cinfo); + msg_field_cinfo_init(&local_cinfo); - len = get_cinfo_from_stream(stream, &local_cinfo); + len = msg_field_cinfo_get_from_stream(stream, &local_cinfo); test_fail_unless( len == 5); test_fail_unless( local_cinfo.valid == CINFO_VALID); @@ -1462,9 +1462,9 @@ void conn_test_get_classifier_rules_from_stream (test_t t) stream[37] = 0xAA; // Classifier Rule data - init_classifier_rules(&local_classifier); + msg_field_classifier_init(&local_classifier); - len = get_classifier_rules_from_stream( stream, &local_classifier ); + len = msg_field_classifier_get_from_stream( stream, &local_classifier ); data_classifier = local_classifier.data; //test_fail_unless( len == 36, "invalid length : %i", len); @@ -1595,9 +1595,9 @@ void conn_test_get_classifier_rules_from_stream (test_t t) stream[65] = 0x83; // Classifier Rule Data stream[66] = 0x43;// Classifier Rule Data - init_classifier_rules(&local_classifier); + msg_field_classifier_init(&local_classifier); - len = get_classifier_rules_from_stream( stream, &local_classifier); + len = msg_field_classifier_get_from_stream( stream, &local_classifier); data_classifier = local_classifier.data; test_fail_unless( local_classifier.classifier_version == CLASSIFIER_CURRENT_VERSION); @@ -1704,9 +1704,9 @@ conn_test_get_cspec_from_stream(test_t t) stream = (test_msg_1.mm_entry) + 2; - init_cspec(&cspec); + msg_field_cspec_init(&cspec); - len = get_cspec_from_stream(stream, &cspec); + len = msg_field_cspec_get_from_stream(stream, &cspec); test_fail_unless( cspec.len == 0x0152 ); @@ -1758,7 +1758,7 @@ conn_test_get_cspec_from_stream(test_t t) test_fail_unless( cspec.qmp_forward.cm.original_average_data_rate == 0x000F); test_fail_unless( cspec.qmp_forward.cm.rx_window_size == 0x100F); test_fail_unless( cspec.qmp_forward.cm.smoothing_buffer_size == 0x100F10); - test_fail_unless( cspec.qmp_forward.cm.bidirectional_burst == 0x10); + test_fail_unless( cspec.qmp_forward.cm.bidirectional_burst == 0x01); test_fail_unless( cspec.qmp_forward.cco.txops_per_beacon_period == 0x15); test_fail_unless( cspec.qmp_forward.cco.average_number_of_pbs_per_txop == 0x100F); test_fail_unless( cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop == 0x100F); @@ -1833,7 +1833,7 @@ conn_test_get_cspec_from_stream(test_t t) test_fail_unless( cspec.qmp_reverse.cm.original_average_data_rate == 0x000F); test_fail_unless( cspec.qmp_reverse.cm.rx_window_size == 0x100F); test_fail_unless( cspec.qmp_reverse.cm.smoothing_buffer_size == 0x100F10); - test_fail_unless( cspec.qmp_reverse.cm.bidirectional_burst == 0x10); + test_fail_unless( cspec.qmp_reverse.cm.bidirectional_burst == 0x01); test_fail_unless( cspec.qmp_reverse.cco.txops_per_beacon_period == 0x15); test_fail_unless( cspec.qmp_reverse.cco.average_number_of_pbs_per_txop == 0x100F); test_fail_unless( cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop == 0x100F); @@ -1849,9 +1849,9 @@ conn_test_get_cspec_from_stream(test_t t) test_begin(t, "test case 2") { stream = (test_msg_2.mm_entry) + 2; - init_cspec(&cspec); + msg_field_cspec_init(&cspec); - len = get_cspec_from_stream(stream, &cspec); + len = msg_field_cspec_get_from_stream(stream, &cspec); test_fail_unless( cspec.len == 0xAA ); @@ -1898,7 +1898,7 @@ conn_test_get_cspec_from_stream(test_t t) test_fail_unless( cspec.qmp_forward.cm.original_average_data_rate == 0x000F); test_fail_unless( cspec.qmp_forward.cm.rx_window_size == 0x100F); test_fail_unless( cspec.qmp_forward.cm.smoothing_buffer_size == 0x100F10); - test_fail_unless( cspec.qmp_forward.cm.bidirectional_burst == 0x10); + test_fail_unless( cspec.qmp_forward.cm.bidirectional_burst == 0x01); test_fail_unless( cspec.qmp_forward.cco.txops_per_beacon_period == 0x15); test_fail_unless( cspec.qmp_forward.cco.average_number_of_pbs_per_txop == 0x100F); test_fail_unless( cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop == 0x100F); @@ -1918,12 +1918,12 @@ conn_test_get_cspec_from_stream(test_t t) { stream = (test_msg_3.mm_entry) + 2; - init_cspec(&cspec); + msg_field_cspec_init(&cspec); - len = get_cspec_from_stream(stream, &cspec); + len = msg_field_cspec_get_from_stream(stream, &cspec); - test_fail_unless( cspec.len == 0x00A4 ); + test_fail_unless( cspec.len == 0x00AF ); // cinfo forward test_fail_unless( (cspec.cinfo_forward.valid == CINFO_NOT_VALID) ); @@ -2002,7 +2002,7 @@ conn_test_get_cspec_from_stream(test_t t) test_fail_unless( cspec.qmp_reverse.cm.original_average_data_rate == 0x000F); test_fail_unless( cspec.qmp_reverse.cm.rx_window_size == 0x100F); test_fail_unless( cspec.qmp_reverse.cm.smoothing_buffer_size == 0x100F10); - test_fail_unless( cspec.qmp_reverse.cm.bidirectional_burst == 0x10); + test_fail_unless( cspec.qmp_reverse.cm.bidirectional_burst == 0x01); test_fail_unless( cspec.qmp_reverse.cco.txops_per_beacon_period == 0x15); test_fail_unless( cspec.qmp_reverse.cco.average_number_of_pbs_per_txop == 0x100F); test_fail_unless( cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop == 0x100F); @@ -2018,9 +2018,9 @@ conn_test_get_cspec_from_stream(test_t t) test_begin(t, "test case 4") { stream = (test_msg_4.mm_entry) + 2; - init_cspec(&cspec); + msg_field_cspec_init(&cspec); - len = get_cspec_from_stream(stream, &cspec); + len = msg_field_cspec_get_from_stream(stream, &cspec); @@ -2055,7 +2055,7 @@ conn_test_set_cspec_on_stream(test_t t) test_begin(t, "test case 1") { - init_cspec(&cspec); + msg_field_cspec_init(&cspec); // CINFO FORWARD @@ -2105,7 +2105,7 @@ conn_test_set_cspec_on_stream(test_t t) cspec.qmp_forward.cm.original_average_data_rate = 0x000F; cspec.qmp_forward.cm.rx_window_size = 0x100F; cspec.qmp_forward.cm.smoothing_buffer_size = 0x100F10; - cspec.qmp_forward.cm.bidirectional_burst = 0x10; + cspec.qmp_forward.cm.bidirectional_burst = 0x01; cspec.qmp_forward.cco.txops_per_beacon_period = 0x15; cspec.qmp_forward.cco.average_number_of_pbs_per_txop = 0x100F; cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop = 0x100F; @@ -2180,7 +2180,7 @@ conn_test_set_cspec_on_stream(test_t t) cspec.qmp_reverse.cm.original_average_data_rate = 0x000F; cspec.qmp_reverse.cm.rx_window_size = 0x100F; cspec.qmp_reverse.cm.smoothing_buffer_size = 0x100F10; - cspec.qmp_reverse.cm.bidirectional_burst = 0x10; + cspec.qmp_reverse.cm.bidirectional_burst = 0x01; cspec.qmp_reverse.cco.txops_per_beacon_period = 0x15; cspec.qmp_reverse.cco.average_number_of_pbs_per_txop = 0x100F; cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop = 0x100F; @@ -2191,7 +2191,7 @@ conn_test_set_cspec_on_stream(test_t t) cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop = 0x0FF0; cspec.qmp_reverse.cco.cco_bidirectional_burst = 0x01; - len = set_cspec_on_stream(stream, &cspec); + len = msg_field_cspec_set_on_stream(stream, &cspec); test_fail_unless(true); @@ -2288,7 +2288,7 @@ conn_test_set_classifier_rules_on_stream(test_t t) classifier_rule.data.udp_source_port = 0x3483; - set_classifier_rules_on_stream((u8*)&msg.mm_entry, &classifier_rule ); + msg_field_classifier_set_on_stream((u8*)&msg.mm_entry, &classifier_rule ); test_fail_unless(msg.mm_entry[0] == 0x00); test_fail_unless(msg.mm_entry[1] == 0x0A); @@ -2416,7 +2416,7 @@ conn_test_set_classifier_rules_on_stream(test_t t) classifier_rule.data.tcp_source_port = 0x5432; - set_classifier_rules_on_stream((u8*)&msg.mm_entry, &classifier_rule ); + msg_field_classifier_set_on_stream((u8*)&msg.mm_entry, &classifier_rule ); test_fail_unless(msg.mm_entry[0] == 0x00); test_fail_unless(msg.mm_entry[1] == 0x08); @@ -2472,7 +2472,7 @@ void conn_test_set_qmp_on_stream(test_t t) test_begin(t, "test case 1 - forward") { - init_qmp(&qmp); + msg_field_qmp_init(&qmp); qmp.forward_or_reverse = QMP_FORWARD; qmp.valid.delay_bound_available = true; @@ -2536,7 +2536,7 @@ void conn_test_set_qmp_on_stream(test_t t) qmp.cm.original_average_data_rate = 0x000F; qmp.cm.rx_window_size = 0x100F; qmp.cm.smoothing_buffer_size = 0x100F10; - qmp.cm.bidirectional_burst = 0x10; + qmp.cm.bidirectional_burst = 0x01; qmp.cco.txops_per_beacon_period = 0x15; qmp.cco.average_number_of_pbs_per_txop = 0x100F; qmp.cco.minimum_number_of_pbs_per_txop = 0x100F; @@ -2548,10 +2548,10 @@ void conn_test_set_qmp_on_stream(test_t t) qmp.cco.cco_bidirectional_burst = 0x01; - len = set_qmp_on_stream(msg,&qmp); + len = msg_field_qmp_set_on_stream(msg,&qmp); - test_fail_unless( len == 164 ); + test_fail_unless( len == 164, "Invalid value - current value %i", len ); for(i = 0; i < 164; i++) { @@ -2562,7 +2562,7 @@ void conn_test_set_qmp_on_stream(test_t t) test_begin(t, "test case 2") { - init_qmp(&qmp); + msg_field_qmp_init(&qmp); qmp.valid.delay_bound_available = true; qmp.valid.jitter_bound_available = true; @@ -2625,7 +2625,7 @@ void conn_test_set_qmp_on_stream(test_t t) qmp.cm.original_average_data_rate = 0x000F; qmp.cm.rx_window_size = 0x100F; qmp.cm.smoothing_buffer_size = 0x100F10; - qmp.cm.bidirectional_burst = 0x10; + qmp.cm.bidirectional_burst = 0x01; qmp.cco.txops_per_beacon_period = 0x15; qmp.cco.average_number_of_pbs_per_txop = 0x100F; qmp.cco.minimum_number_of_pbs_per_txop = 0x100F; @@ -2636,7 +2636,7 @@ void conn_test_set_qmp_on_stream(test_t t) qmp.cco.original_average_number_of_pbs_per_txop = 0x0FF0; qmp.cco.cco_bidirectional_burst = 0x01; - len = set_qmp_on_stream(msg, &qmp); + len = msg_field_qmp_set_on_stream(msg, &qmp); test_fail_unless( len == 164); @@ -2664,7 +2664,7 @@ conn_test_set_cid_on_stream (test_t t) { cid = 0X4352; - len = set_cid_on_stream(stream, &cid); + len = msg_field_cid_set_on_stream(stream, &cid); test_fail_unless( len == 2); test_fail_unless( stream[0] = 0x43); @@ -2686,10 +2686,10 @@ conn_test_get_cid_from_stream(test_t t) test_begin(t, "test case 1") { - init_cid(&cid); + msg_field_cid_init(&cid); - len = get_cid_from_stream(stream, &cid); + len = msg_field_cid_get_from_stream(stream, &cid); test_fail_unless( len == 2 ); test_fail_unless( cid == 0x3476); @@ -2708,9 +2708,9 @@ conn_test_get_qmp_from_stream(test_t t) test_begin(t, "test case 1") { - init_qmp(&qmp); + msg_field_qmp_init(&qmp); - len = get_qmp_from_stream(test_stream_forward_1, test_stream_forward_1 + 164, &qmp, QMP_FORWARD); + len = msg_field_qmp_get_from_stream(test_stream_forward_1, test_stream_forward_1 + 164, &qmp, QMP_FORWARD); test_fail_unless( len == 164); test_fail_unless( qmp.valid.delay_bound_available == true); @@ -2775,7 +2775,7 @@ conn_test_get_qmp_from_stream(test_t t) test_fail_unless( qmp.cm.original_average_data_rate == 0x000F); test_fail_unless( qmp.cm.rx_window_size == 0x100F); test_fail_unless( qmp.cm.smoothing_buffer_size == 0x100F10); - test_fail_unless( qmp.cm.bidirectional_burst == 0x10); + test_fail_unless( qmp.cm.bidirectional_burst == 0x01); test_fail_unless( qmp.cco.txops_per_beacon_period == 0x15); test_fail_unless( qmp.cco.average_number_of_pbs_per_txop == 0x100F); test_fail_unless( qmp.cco.minimum_number_of_pbs_per_txop == 0x100F); @@ -2789,9 +2789,9 @@ conn_test_get_qmp_from_stream(test_t t) test_begin(t, "test case 2") { - init_qmp(&qmp); + msg_field_qmp_init(&qmp); - get_qmp_from_stream(test_stream_reverse_1, test_stream_reverse_1 + 164, &qmp, QMP_REVERSE); + msg_field_qmp_get_from_stream(test_stream_reverse_1, test_stream_reverse_1 + 164, &qmp, QMP_REVERSE); test_fail_unless( qmp.valid.delay_bound_available == true); test_fail_unless( qmp.valid.jitter_bound_available == true); @@ -2854,7 +2854,7 @@ conn_test_get_qmp_from_stream(test_t t) test_fail_unless( qmp.cm.original_average_data_rate == 0x000F); test_fail_unless( qmp.cm.rx_window_size == 0x100F); test_fail_unless( qmp.cm.smoothing_buffer_size == 0x100F10); - test_fail_unless( qmp.cm.bidirectional_burst == 0x10); + test_fail_unless( qmp.cm.bidirectional_burst == 0x01); test_fail_unless( qmp.cco.txops_per_beacon_period == 0x15); test_fail_unless( qmp.cco.average_number_of_pbs_per_txop == 0x100F); test_fail_unless( qmp.cco.minimum_number_of_pbs_per_txop == 0x100F); -- cgit v1.2.3