/*
 * Copyright (C) 2019 by Sukchan Lee <acetcom@gmail.com>
 *
 * This file is part of Open5GS.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#include "ogs-sbi.h"
#include "core/abts.h"

static void sbi_message_test1(abts_case *tc, void *data)
{
    cJSON *item = NULL;
    OpenAPI_lnode_t *entry;

    OpenAPI_nf_profile_t *nf_profile1;
    OpenAPI_nf_profile_t *nf_profile2;

    OpenAPI_udr_info_t *udr_info1;
    OpenAPI_udr_info_t *udr_info2;

    OpenAPI_identity_range_t *identity_range1;
    OpenAPI_identity_range_t *identity_range2;

    OpenAPI_plmn_id_t plmn_id1[3];
    OpenAPI_plmn_id_t *plmn_id2;

    char *nsi;

    nf_profile1 = ogs_calloc(1, sizeof(*nf_profile1));
    ABTS_PTR_NOTNULL(tc, nf_profile1);
    nf_profile1->nf_instance_id = "NF_INSTANCE_ID";
    nf_profile1->nf_type = OpenAPI_nf_type_SMF;
    nf_profile1->nf_status = OpenAPI_nf_status_REGISTERED;

    memset(plmn_id1, 0, sizeof(plmn_id1));

    nf_profile1->plmn_list = OpenAPI_list_create();
    ABTS_PTR_NOTNULL(tc, nf_profile1->plmn_list);

    plmn_id1[0].mcc = "111";
    plmn_id1[0].mnc = "222";
    OpenAPI_list_add(nf_profile1->plmn_list, &plmn_id1[0]);
    plmn_id1[1].mcc = "333";
    plmn_id1[1].mnc = "444";
    OpenAPI_list_add(nf_profile1->plmn_list, &plmn_id1[1]);
    plmn_id1[2].mcc = "555";
    plmn_id1[2].mnc = "666";
    OpenAPI_list_add(nf_profile1->plmn_list, &plmn_id1[2]);

    nf_profile1->nsi_list = OpenAPI_list_create();
    OpenAPI_list_add(nf_profile1->nsi_list, "aaa");
    OpenAPI_list_add(nf_profile1->nsi_list, "bbbbb");

    nf_profile1->is_priority = true;
    nf_profile1->priority = 30;

    udr_info1 = nf_profile1->udr_info = ogs_calloc(1, sizeof(*udr_info1));
    ABTS_PTR_NOTNULL(tc, udr_info1);
    udr_info1->group_id = "group";

    udr_info1->supi_ranges = OpenAPI_list_create();
    ABTS_PTR_NOTNULL(tc, udr_info1->supi_ranges);

    udr_info1->gpsi_ranges = OpenAPI_list_create();
    ABTS_PTR_NOTNULL(tc, udr_info1->gpsi_ranges);

    identity_range1 = ogs_calloc(1, sizeof(*identity_range1));
    ABTS_PTR_NOTNULL(tc, identity_range1);
    identity_range1->start = "1";
    identity_range1->end = "9";
    OpenAPI_list_add(udr_info1->gpsi_ranges, identity_range1);

    item = OpenAPI_nf_profile_convertToJSON(nf_profile1);
    ABTS_PTR_NOTNULL(tc, item);

#if 0
    {
        char *str = cJSON_Print(item);
        printf("%s", str);
        ogs_free(str);
    }
#endif

    nf_profile2 = OpenAPI_nf_profile_parseFromJSON(item);
    ABTS_PTR_NOTNULL(tc, nf_profile2);

    ABTS_STR_EQUAL(tc,
            nf_profile1->nf_instance_id, nf_profile2->nf_instance_id);
    ABTS_INT_EQUAL(tc, nf_profile1->nf_type, nf_profile2->nf_type);
    ABTS_INT_EQUAL(tc, nf_profile1->nf_status, nf_profile2->nf_status);

    ABTS_PTR_NOTNULL(tc, nf_profile2->plmn_list);

    entry = nf_profile2->plmn_list->first;
    ABTS_PTR_NOTNULL(tc, entry);
    plmn_id2 = entry->data;
    ABTS_PTR_NOTNULL(tc, plmn_id2);
    ABTS_STR_EQUAL(tc, "111", plmn_id2->mcc);
    ABTS_STR_EQUAL(tc, "222", plmn_id2->mnc);

    entry = entry->next;
    ABTS_PTR_NOTNULL(tc, entry);
    plmn_id2 = entry->data;
    ABTS_PTR_NOTNULL(tc, plmn_id2);
    ABTS_STR_EQUAL(tc, "333", plmn_id2->mcc);
    ABTS_STR_EQUAL(tc, "444", plmn_id2->mnc);

    entry = entry->next;
    ABTS_PTR_NOTNULL(tc, entry);
    plmn_id2 = entry->data;
    ABTS_PTR_NOTNULL(tc, plmn_id2);
    ABTS_STR_EQUAL(tc, "555", plmn_id2->mcc);
    ABTS_STR_EQUAL(tc, "666", plmn_id2->mnc);

    entry = entry->next;
    ABTS_PTR_EQUAL(tc, NULL, entry);

    entry = nf_profile2->nsi_list->first;
    ABTS_PTR_NOTNULL(tc, entry);
    nsi = entry->data;
    ABTS_PTR_NOTNULL(tc, nsi);
    ABTS_STR_EQUAL(tc, "aaa", nsi);

    entry = entry->next;
    ABTS_PTR_NOTNULL(tc, entry);
    nsi = entry->data;
    ABTS_PTR_NOTNULL(tc, nsi);
    ABTS_STR_EQUAL(tc, "bbbbb", nsi);

    ABTS_TRUE(tc, nf_profile2->is_priority);
    ABTS_INT_EQUAL(tc, 30, nf_profile2->priority);

    udr_info2 = nf_profile2->udr_info;
    ABTS_PTR_NOTNULL(tc, udr_info2);
    ABTS_STR_EQUAL(tc, "group", udr_info2->group_id);

    ABTS_PTR_NOTNULL(tc, udr_info2->supi_ranges);
    ABTS_INT_EQUAL(tc, 0, udr_info2->supi_ranges->count);

    ABTS_PTR_NOTNULL(tc, udr_info2->gpsi_ranges);
    entry = udr_info2->gpsi_ranges->first;
    ABTS_PTR_NOTNULL(tc, entry);
    identity_range2 = entry->data;
    ABTS_PTR_NOTNULL(tc, identity_range2);
    ABTS_STR_EQUAL(tc, "1", identity_range2->start);
    ABTS_STR_EQUAL(tc, "9", identity_range2->end);

    ogs_free(identity_range1);

    OpenAPI_list_free(udr_info1->gpsi_ranges);
    OpenAPI_list_free(udr_info1->supi_ranges);
    ogs_free(udr_info1);

    OpenAPI_list_free(nf_profile1->plmn_list);
    OpenAPI_list_free(nf_profile1->nsi_list);
    ogs_free(nf_profile1);

    cJSON_Delete(item);

    OpenAPI_nf_profile_free(nf_profile2);
}

static void sbi_message_test2(abts_case *tc, void *data)
{
    cJSON *item = NULL;
    OpenAPI_lnode_t *entry;

    OpenAPI_nf_group_cond_t *nf_group_cond1;
    OpenAPI_nf_group_cond_t *nf_group_cond2;

    OpenAPI_smf_info_t *smf_info1;
    OpenAPI_smf_info_t *smf_info2;
    OpenAPI_access_type_e access_type;

    nf_group_cond1 = ogs_calloc(1, sizeof(*nf_group_cond1));
    ABTS_PTR_NOTNULL(tc, nf_group_cond1);
    nf_group_cond1->nf_type = OpenAPI_nf_group_cond_NFTYPE_UDR;
    nf_group_cond1->nf_group_id = "group";

    item = OpenAPI_nf_group_cond_convertToJSON(nf_group_cond1);
    ABTS_PTR_NOTNULL(tc, item);

#if 0
    {
        char *str = cJSON_Print(item);
        printf("%s", str);
        ogs_free(str);
    }
#endif

    nf_group_cond2 = OpenAPI_nf_group_cond_parseFromJSON(item);
    ABTS_PTR_NOTNULL(tc, nf_group_cond2);

    ABTS_STR_EQUAL(tc,
            nf_group_cond1->nf_group_id, nf_group_cond2->nf_group_id);
    ogs_free(nf_group_cond1);

    ABTS_INT_EQUAL(tc,
            OpenAPI_nf_group_cond_NFTYPE_UDR, nf_group_cond2->nf_type);

    cJSON_Delete(item);

    OpenAPI_nf_group_cond_free(nf_group_cond2);

    smf_info1 = ogs_calloc(1, sizeof(*smf_info1));
    ABTS_PTR_NOTNULL(tc, smf_info1);
    smf_info1->s_nssai_smf_info_list = OpenAPI_list_create();
    smf_info1->pgw_fqdn = "PGW_FQDN";
    smf_info1->access_type = OpenAPI_list_create();
    ABTS_PTR_NOTNULL(tc, smf_info1->access_type);

    OpenAPI_list_add(smf_info1->access_type,
            (void*)OpenAPI_access_type_3GPP_ACCESS);
    OpenAPI_list_add(smf_info1->access_type,
            (void*)OpenAPI_access_type_NON_3GPP_ACCESS);
    item = OpenAPI_smf_info_convertToJSON(smf_info1);
    ABTS_PTR_NOTNULL(tc, item);

#if 0
    {
        char *str = cJSON_Print(item);
        printf("%s", str);
        ogs_free(str);
    }
#endif

    smf_info2 = OpenAPI_smf_info_parseFromJSON(item);
    ABTS_PTR_NOTNULL(tc, smf_info2);

    ABTS_STR_EQUAL(tc,
            smf_info1->pgw_fqdn, smf_info2->pgw_fqdn);
    ABTS_PTR_NOTNULL(tc, smf_info2->s_nssai_smf_info_list);
    ABTS_INT_EQUAL(tc, smf_info1->s_nssai_smf_info_list->count,
                        smf_info2->s_nssai_smf_info_list->count);
    ABTS_PTR_NOTNULL(tc, smf_info2->access_type);
    ABTS_INT_EQUAL(tc, smf_info1->access_type->count,
                        smf_info2->access_type->count);

    entry = smf_info2->access_type->first;
    ABTS_PTR_NOTNULL(tc, entry);
    access_type = (intptr_t)entry->data;
    ABTS_INT_EQUAL(tc, OpenAPI_access_type_3GPP_ACCESS, access_type);

    entry = entry->next;
    ABTS_PTR_NOTNULL(tc, entry);
    access_type = (intptr_t)entry->data;
    ABTS_INT_EQUAL(tc, OpenAPI_access_type_NON_3GPP_ACCESS, access_type);

    OpenAPI_list_free(smf_info1->s_nssai_smf_info_list);
    OpenAPI_list_free(smf_info1->access_type);
    ogs_free(smf_info1);

    cJSON_Delete(item);

    OpenAPI_smf_info_free(smf_info2);
}

static void sbi_message_test3(abts_case *tc, void *data)
{
    cJSON *item = NULL;
    OpenAPI_lnode_t *entry;

    OpenAPI_nrf_info_t *nrf_info1;
    OpenAPI_nrf_info_t *nrf_info2;

    OpenAPI_map_t *served_pcf_info1 = NULL;
    OpenAPI_map_t *served_pcf_info2 = NULL;
    OpenAPI_pcf_info_t *pcf_info1;
    OpenAPI_pcf_info_t *pcf_info2;

    pcf_info1 = ogs_calloc(1, sizeof(*pcf_info1));
    ABTS_PTR_NOTNULL(tc, pcf_info1);
    pcf_info1->group_id = "pcf_group_id";
    pcf_info2 = ogs_calloc(1, sizeof(*pcf_info2));
    ABTS_PTR_NOTNULL(tc, pcf_info2);
    pcf_info2->group_id = "pcf_group_id2";

    served_pcf_info1 = OpenAPI_map_create("nfInstanceId", pcf_info1);
    ABTS_PTR_NOTNULL(tc, served_pcf_info1);
    served_pcf_info2 = OpenAPI_map_create("nfInstanceId2", pcf_info2);
    ABTS_PTR_NOTNULL(tc, served_pcf_info2);

    nrf_info1 = ogs_calloc(1, sizeof(*nrf_info1));
    ABTS_PTR_NOTNULL(tc, nrf_info1);

    nrf_info1->served_pcf_info = OpenAPI_list_create();
    ABTS_PTR_NOTNULL(tc, nrf_info1->served_pcf_info);
    OpenAPI_list_add(nrf_info1->served_pcf_info, served_pcf_info1);
    OpenAPI_list_add(nrf_info1->served_pcf_info, served_pcf_info2);

    item = OpenAPI_nrf_info_convertToJSON(nrf_info1);
    ABTS_PTR_NOTNULL(tc, item);

#if 0
    {
        char *str = cJSON_Print(item);
        printf("%s", str);
        ogs_free(str);
    }
#endif

    OpenAPI_map_free(served_pcf_info1);
    OpenAPI_map_free(served_pcf_info2);
    ogs_free(pcf_info1);
    ogs_free(pcf_info2);

    nrf_info2 = OpenAPI_nrf_info_parseFromJSON(item);
    ABTS_PTR_NOTNULL(tc, nrf_info2);

    ABTS_INT_EQUAL(tc, nrf_info1->served_pcf_info->count,
                        nrf_info2->served_pcf_info->count);

    OpenAPI_list_free(nrf_info1->served_pcf_info);
    ogs_free(nrf_info1);

    entry = nrf_info2->served_pcf_info->first;
    ABTS_PTR_NOTNULL(tc, entry);
    served_pcf_info1 = entry->data;
    ABTS_PTR_NOTNULL(tc, served_pcf_info1);
    ABTS_STR_EQUAL(tc, served_pcf_info1->key, "nfInstanceId");
    pcf_info1 = served_pcf_info1->value;
    ABTS_PTR_NOTNULL(tc, pcf_info1);
    ABTS_STR_EQUAL(tc, pcf_info1->group_id, "pcf_group_id");

    entry = entry->next;
    ABTS_PTR_NOTNULL(tc, entry);
    served_pcf_info1 = entry->data;
    ABTS_STR_EQUAL(tc, served_pcf_info1->key, "nfInstanceId2");
    pcf_info1 = served_pcf_info1->value;
    ABTS_PTR_NOTNULL(tc, pcf_info1);
    ABTS_STR_EQUAL(tc, pcf_info1->group_id, "pcf_group_id2");

    cJSON_Delete(item);
    OpenAPI_nrf_info_free(nrf_info2);
}

static void sbi_message_test4(abts_case *tc, void *data)
{
    ogs_time_t t;
    struct tm tm;
    bool rc;

    rc = ogs_sbi_time_from_string(&t, "1985-04-12T23:20:50.52");
    ABTS_INT_EQUAL(tc, 1, rc);

    ogs_gmtime(ogs_time_sec(t), &tm);
    ABTS_INT_EQUAL(tc, 85, tm.tm_year);
    ABTS_INT_EQUAL(tc, 3, tm.tm_mon);
    ABTS_INT_EQUAL(tc, 12, tm.tm_mday);
    ABTS_INT_EQUAL(tc, 23, tm.tm_hour);
    ABTS_INT_EQUAL(tc, 20, tm.tm_min);
    ABTS_INT_EQUAL(tc, 50, tm.tm_sec);
    ABTS_INT_EQUAL(tc, 0, tm.tm_isdst);
    ABTS_INT_EQUAL(tc, 0, tm.tm_gmtoff);
    ABTS_TRUE(tc, t == 482196050520000LL);

    rc = ogs_sbi_time_from_string(&t, "1996-12-19T16:39:57-0800");
    ABTS_INT_EQUAL(tc, 1, rc);

    ogs_gmtime(ogs_time_sec(t), &tm);
    ABTS_INT_EQUAL(tc, 96, tm.tm_year);
    ABTS_INT_EQUAL(tc, 11, tm.tm_mon);
    ABTS_INT_EQUAL(tc, 20, tm.tm_mday);
    ABTS_INT_EQUAL(tc, 0, tm.tm_hour);
    ABTS_INT_EQUAL(tc, 39, tm.tm_min);
    ABTS_INT_EQUAL(tc, 57, tm.tm_sec);
    ABTS_INT_EQUAL(tc, 0, tm.tm_isdst);
    ABTS_INT_EQUAL(tc, 0, tm.tm_gmtoff);
    ABTS_TRUE(tc, t == 851042397000000LL);

    tm.tm_mday = 19;
    tm.tm_hour = 16;
    tm.tm_gmtoff = -28800;

    rc = ogs_sbi_time_from_string(&t, "1996-12-19T16:39:57-08:00");
    ABTS_INT_EQUAL(tc, 1, rc);

    ogs_gmtime(ogs_time_sec(t), &tm);
    ABTS_INT_EQUAL(tc, 96, tm.tm_year);
    ABTS_INT_EQUAL(tc, 11, tm.tm_mon);
    ABTS_INT_EQUAL(tc, 20, tm.tm_mday);
    ABTS_INT_EQUAL(tc, 0, tm.tm_hour);
    ABTS_INT_EQUAL(tc, 39, tm.tm_min);
    ABTS_INT_EQUAL(tc, 57, tm.tm_sec);
    ABTS_INT_EQUAL(tc, 0, tm.tm_isdst);
    ABTS_INT_EQUAL(tc, 0, tm.tm_gmtoff);
    ABTS_TRUE(tc, t == 851042397000000LL);

    rc = ogs_sbi_time_from_string(&t, "1990-12-31T23:59:60Z");
    ABTS_INT_EQUAL(tc, 1, rc);

    ogs_gmtime(ogs_time_sec(t), &tm);
    ABTS_INT_EQUAL(tc, 91, tm.tm_year);
    ABTS_INT_EQUAL(tc, 0, tm.tm_mon);
    ABTS_INT_EQUAL(tc, 1, tm.tm_mday);
    ABTS_INT_EQUAL(tc, 0, tm.tm_hour);
    ABTS_INT_EQUAL(tc, 0, tm.tm_min);
    ABTS_INT_EQUAL(tc, 0, tm.tm_sec);
    ABTS_INT_EQUAL(tc, 0, tm.tm_isdst);
    ABTS_INT_EQUAL(tc, 0, tm.tm_gmtoff);
    ABTS_TRUE(tc, t == 662688000000000LL);

    rc = ogs_sbi_time_from_string(&t, "1990-12-31T15:59:60-0800");
    ABTS_INT_EQUAL(tc, 1, rc);

    ogs_gmtime(ogs_time_sec(t), &tm);
    ABTS_INT_EQUAL(tc, 91, tm.tm_year);
    ABTS_INT_EQUAL(tc, 0, tm.tm_mon);
    ABTS_INT_EQUAL(tc, 1, tm.tm_mday);
    ABTS_INT_EQUAL(tc, 0, tm.tm_hour);
    ABTS_INT_EQUAL(tc, 0, tm.tm_min);
    ABTS_INT_EQUAL(tc, 0, tm.tm_sec);
    ABTS_INT_EQUAL(tc, 0, tm.tm_isdst);
    ABTS_INT_EQUAL(tc, 0, tm.tm_gmtoff);
    ABTS_TRUE(tc, t == 662688000000000LL);

    rc = ogs_sbi_time_from_string(&t, "1990-12-31T15:59:60-08:00");
    ABTS_INT_EQUAL(tc, 1, rc);

    ogs_gmtime(ogs_time_sec(t), &tm);
    ABTS_INT_EQUAL(tc, 91, tm.tm_year);
    ABTS_INT_EQUAL(tc, 0, tm.tm_mon);
    ABTS_INT_EQUAL(tc, 1, tm.tm_mday);
    ABTS_INT_EQUAL(tc, 0, tm.tm_hour);
    ABTS_INT_EQUAL(tc, 0, tm.tm_min);
    ABTS_INT_EQUAL(tc, 0, tm.tm_sec);
    ABTS_INT_EQUAL(tc, 0, tm.tm_isdst);
    ABTS_INT_EQUAL(tc, 0, tm.tm_gmtoff);
    ABTS_TRUE(tc, t == 662688000000000LL);

    rc = ogs_sbi_time_from_string(&t, "1987-01-01T12:00:27.87+0020");
    ABTS_INT_EQUAL(tc, 1, rc);

    ogs_gmtime(ogs_time_sec(t), &tm);
    ABTS_INT_EQUAL(tc, 87, tm.tm_year);
    ABTS_INT_EQUAL(tc, 0, tm.tm_mon);
    ABTS_INT_EQUAL(tc, 1, tm.tm_mday);
    ABTS_INT_EQUAL(tc, 11, tm.tm_hour);
    ABTS_INT_EQUAL(tc, 40, tm.tm_min);
    ABTS_INT_EQUAL(tc, 27, tm.tm_sec);
    ABTS_INT_EQUAL(tc, 0, tm.tm_isdst);
    ABTS_INT_EQUAL(tc, 0, tm.tm_gmtoff);
    ABTS_TRUE(tc, t == 536499627870000LL);

    rc = ogs_sbi_time_from_string(&t, "1987-01-01T12:00:27.87+0020");
    ABTS_INT_EQUAL(tc, 1, rc);

    ogs_gmtime(ogs_time_sec(t), &tm);
    ABTS_INT_EQUAL(tc, 87, tm.tm_year);
    ABTS_INT_EQUAL(tc, 0, tm.tm_mon);
    ABTS_INT_EQUAL(tc, 1, tm.tm_mday);
    ABTS_INT_EQUAL(tc, 11, tm.tm_hour);
    ABTS_INT_EQUAL(tc, 40, tm.tm_min);
    ABTS_INT_EQUAL(tc, 27, tm.tm_sec);
    ABTS_INT_EQUAL(tc, 0, tm.tm_isdst);
    ABTS_INT_EQUAL(tc, 0, tm.tm_gmtoff);
    ABTS_TRUE(tc, t == 536499627870000LL);
}

static void sbi_message_test5(abts_case *tc, void *data)
{
    struct tm tm;

#define MAX_TIMESTR_LEN 128
    char datetime[MAX_TIMESTR_LEN];
    char timezone[MAX_TIMESTR_LEN];
    int len;

    char *str = NULL;

    str = ogs_sbi_timezone_string(-18000);
    ABTS_STR_EQUAL(tc, "-05:00", str);
    ogs_free(str);

    str = ogs_sbi_timezone_string(28800);
    ABTS_STR_EQUAL(tc, "+08:00", str);
    ogs_free(str);

    str = ogs_sbi_timezone_string(12600);
    ABTS_STR_EQUAL(tc, "+03:30", str);
    ogs_free(str);

    str = ogs_sbi_timezone_string(0);
    ABTS_STR_EQUAL(tc, "+00:00", str);
    ogs_free(str);

    ogs_localtime(ogs_time_sec(ogs_time_now()), &tm);
    ogs_strftime(datetime, sizeof datetime, "%Y-%m-%dT%H:%M:%S", &tm);

    len = ogs_strftimezone(timezone, MAX_TIMESTR_LEN, tm.tm_gmtoff);
    ABTS_INT_EQUAL(tc, 6, len);
}

static void sbi_message_test6(abts_case *tc, void *data)
{
    cJSON *item = NULL, *item2 = NULL;
    char *content = NULL;
    OpenAPI_smf_selection_subscription_data_t SmfSelectionSubscriptionData;
    OpenAPI_smf_selection_subscription_data_t *r1, *s1 = NULL;

    ogs_s_nssai_t s_nssai;

    OpenAPI_list_t *SubscribedSnssaiInfoList = NULL;
    OpenAPI_map_t *SubscribedSnssaiInfoMap = NULL;
    OpenAPI_snssai_info_t *SubscribedSnssaiInfo = NULL;

    OpenAPI_list_t *DnnInfoList = NULL;
    OpenAPI_dnn_info_t *DnnInfo = NULL;

    OpenAPI_lnode_t *node = NULL, *node2 = NULL;

    memset(&SmfSelectionSubscriptionData, 0,
            sizeof(SmfSelectionSubscriptionData));

    SubscribedSnssaiInfoList = OpenAPI_list_create();
    ogs_assert(SubscribedSnssaiInfoList);

    {
        DnnInfoList = OpenAPI_list_create();
        ogs_assert(DnnInfoList);

        {
            DnnInfo = ogs_calloc(1, sizeof(*DnnInfo));
            ogs_assert(DnnInfo);

            DnnInfo->dnn = "internet";

            DnnInfo->is_default_dnn_indicator = true;
            DnnInfo->default_dnn_indicator = true;

            OpenAPI_list_add(DnnInfoList, DnnInfo);
        }

        SubscribedSnssaiInfo = ogs_calloc(1, sizeof(*SubscribedSnssaiInfo));
        ogs_assert(SubscribedSnssaiInfo);

        if (DnnInfoList->count)
            SubscribedSnssaiInfo->dnn_infos = DnnInfoList;
        else
            OpenAPI_list_free(DnnInfoList);

        memset(&s_nssai, 0, sizeof(s_nssai));
        s_nssai.sst = 1;
        s_nssai.sd.v = OGS_S_NSSAI_NO_SD_VALUE;

        SubscribedSnssaiInfoMap = OpenAPI_map_create(
                ogs_sbi_s_nssai_to_string(&s_nssai),
                SubscribedSnssaiInfo);
        ogs_assert(SubscribedSnssaiInfoMap);
        ogs_assert(SubscribedSnssaiInfoMap->key);

        OpenAPI_list_add(SubscribedSnssaiInfoList, SubscribedSnssaiInfoMap);
    }

    if (SubscribedSnssaiInfoList->count)
        SmfSelectionSubscriptionData.subscribed_snssai_infos =
            SubscribedSnssaiInfoList;
    else
        OpenAPI_list_free(SubscribedSnssaiInfoList);

    item = OpenAPI_smf_selection_subscription_data_convertToJSON(
                &SmfSelectionSubscriptionData);

    SubscribedSnssaiInfoList =
        SmfSelectionSubscriptionData.subscribed_snssai_infos;
    OpenAPI_list_for_each(SubscribedSnssaiInfoList, node) {
        SubscribedSnssaiInfoMap = node->data;
        if (SubscribedSnssaiInfoMap) {
            SubscribedSnssaiInfo = SubscribedSnssaiInfoMap->value;
            if (SubscribedSnssaiInfo) {
                DnnInfoList = SubscribedSnssaiInfo->dnn_infos;
                if (DnnInfoList) {
                    OpenAPI_list_for_each(DnnInfoList, node2) {
                        DnnInfo = node2->data;
                        if (DnnInfo) {
                            ogs_free(DnnInfo);
                        }
                    }
                    OpenAPI_list_free(DnnInfoList);
                }
                ogs_free(SubscribedSnssaiInfo);
            }
            if (SubscribedSnssaiInfoMap->key)
                ogs_free(SubscribedSnssaiInfoMap->key);
            ogs_free(SubscribedSnssaiInfoMap);
        }
    }
    OpenAPI_list_free(SubscribedSnssaiInfoList);

    r1 = OpenAPI_smf_selection_subscription_data_parseFromJSON(item);
    cJSON_Delete(item);

    item = OpenAPI_smf_selection_subscription_data_convertToJSON(r1);

    SubscribedSnssaiInfoList = r1->subscribed_snssai_infos;
    OpenAPI_list_for_each(SubscribedSnssaiInfoList, node) {
        SubscribedSnssaiInfoMap = node->data;
        if (SubscribedSnssaiInfoMap) {
            memset(&s_nssai, 0, sizeof(s_nssai));
            ogs_sbi_s_nssai_from_string(&s_nssai, SubscribedSnssaiInfoMap->key);
            ABTS_INT_EQUAL(tc, 1, s_nssai.sst);
            ABTS_INT_EQUAL(tc, OGS_S_NSSAI_NO_SD_VALUE, s_nssai.sd.v);
        }
    }

    OpenAPI_smf_selection_subscription_data_free(r1);

    content = cJSON_Print(item);
    cJSON_Delete(item);
    ogs_assert(content);
    ABTS_INT_EQUAL(tc, 148, (int)strlen(content));
    ogs_free(content);
}

static void sbi_message_test7(abts_case *tc, void *data)
{
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_NRF,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NNRF_NFM));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NNRF_NFM,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NNRF_NFM));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NNRF_NFM,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NNRF_NFM));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_UDM,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NUDM_SDM));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NUDM_SDM,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NUDM_SDM));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NUDM_SDM,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NUDM_SDM));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_AMF,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NAMF_COMM));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NAMF_COMM,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NAMF_COMM));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NAMF_COMM,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NAMF_COMM));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_SMF,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NSMF_PDUSESSION));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NSMF_PDUSESSION,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NSMF_PDUSESSION));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NSMF_PDUSESSION,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NSMF_PDUSESSION));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_AUSF,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NAUSF_AUTH));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NAUSF_AUTH,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NAUSF_AUTH));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NAUSF_AUTH,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NAUSF_AUTH));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_NEF,
        ogs_sbi_service_type_to_nf_type(
            OGS_SBI_SERVICE_TYPE_NNEF_PFDMANAGEMENT));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NNEF_PFDMANAGEMENT,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NNEF_PFDMANAGEMENT));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NNEF_PFDMANAGEMENT,
        ogs_sbi_service_type_from_name(
            OGS_SBI_SERVICE_NAME_NNEF_PFDMANAGEMENT));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_PCF,
        ogs_sbi_service_type_to_nf_type(
            OGS_SBI_SERVICE_TYPE_NPCF_AM_POLICY_CONTROL));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NPCF_AM_POLICY_CONTROL,
        ogs_sbi_service_type_to_name(
            OGS_SBI_SERVICE_TYPE_NPCF_AM_POLICY_CONTROL));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NPCF_AM_POLICY_CONTROL,
        ogs_sbi_service_type_from_name(
            OGS_SBI_SERVICE_NAME_NPCF_AM_POLICY_CONTROL));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_SMSF,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NSMSF_SMS));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NSMSF_SMS,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NSMSF_SMS));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NSMSF_SMS,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NSMSF_SMS));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_NSSF,
        ogs_sbi_service_type_to_nf_type(
            OGS_SBI_SERVICE_TYPE_NNSSF_NSSELECTION));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NNSSF_NSSELECTION,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NNSSF_NSSELECTION));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NNSSF_NSSELECTION,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NNSSF_NSSELECTION));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_UDR,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NUDR_DR));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NUDR_DR,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NUDR_DR));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NUDR_DR,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NUDR_DR));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_LMF,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NLMF_LOC));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NLMF_LOC,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NLMF_LOC));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NLMF_LOC,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NLMF_LOC));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_5G_EIR,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_N5G_EIR_EIC));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_N5G_EIR_EIC,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_N5G_EIR_EIC));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_N5G_EIR_EIC,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_N5G_EIR_EIC));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_BSF,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NBSF_MANAGEMENT));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NBSF_MANAGEMENT,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NBSF_MANAGEMENT));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NBSF_MANAGEMENT,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NBSF_MANAGEMENT));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_CHF,
        ogs_sbi_service_type_to_nf_type(
            OGS_SBI_SERVICE_TYPE_NCHF_SPENDINGLIMITCONTROL));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NCHF_SPENDINGLIMITCONTROL,
        ogs_sbi_service_type_to_name(
            OGS_SBI_SERVICE_TYPE_NCHF_SPENDINGLIMITCONTROL));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NCHF_SPENDINGLIMITCONTROL,
        ogs_sbi_service_type_from_name(
            OGS_SBI_SERVICE_NAME_NCHF_SPENDINGLIMITCONTROL));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_NWDAF,
        ogs_sbi_service_type_to_nf_type(
            OGS_SBI_SERVICE_TYPE_NNWDAF_EVENTSSUBSCRIPTION));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NNWDAF_EVENTSSUBSCRIPTION,
        ogs_sbi_service_type_to_name(
            OGS_SBI_SERVICE_TYPE_NNWDAF_EVENTSSUBSCRIPTION));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NNWDAF_EVENTSSUBSCRIPTION,
        ogs_sbi_service_type_from_name(
            OGS_SBI_SERVICE_NAME_NNWDAF_EVENTSSUBSCRIPTION));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_GMLC,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NGMLC_LOC));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NGMLC_LOC,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NGMLC_LOC));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NGMLC_LOC,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NGMLC_LOC));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_UCMF,
        ogs_sbi_service_type_to_nf_type(
            OGS_SBI_SERVICE_TYPE_NUCMF_PROVISIONING));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NUCMF_PROVISIONING,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NUCMF_PROVISIONING));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NUCMF_PROVISIONING,
        ogs_sbi_service_type_from_name(
            OGS_SBI_SERVICE_NAME_NUCMF_PROVISIONING));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_HSS,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NHSS_SDM));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NHSS_SDM,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NHSS_SDM));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NHSS_SDM,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NHSS_SDM));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_SEPP,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NSEPP_TELESCOPIC));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NSEPP_TELESCOPIC,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NSEPP_TELESCOPIC));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NSEPP_TELESCOPIC,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NSEPP_TELESCOPIC));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_SOR_AF,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NSORAF_SOR));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NSORAF_SOR,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NSORAF_SOR));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NSORAF_SOR,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NSORAF_SOR));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_SPAF,
        ogs_sbi_service_type_to_nf_type(
            OGS_SBI_SERVICE_TYPE_NSPAF_SECURED_PACKET));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NSPAF_SECURED_PACKET,
        ogs_sbi_service_type_to_name(
            OGS_SBI_SERVICE_TYPE_NSPAF_SECURED_PACKET));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NSPAF_SECURED_PACKET,
        ogs_sbi_service_type_from_name(
            OGS_SBI_SERVICE_NAME_NSPAF_SECURED_PACKET));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_UDSF,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NUDSF_DR));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NUDSF_DR,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NUDSF_DR));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NUDSF_DR,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NUDSF_DR));
    ABTS_INT_EQUAL(tc, OpenAPI_nf_type_NSSAAF,
        ogs_sbi_service_type_to_nf_type(OGS_SBI_SERVICE_TYPE_NNSSAAF_NSSAA));
    ABTS_STR_EQUAL(tc, OGS_SBI_SERVICE_NAME_NNSSAAF_NSSAA,
        ogs_sbi_service_type_to_name(OGS_SBI_SERVICE_TYPE_NNSSAAF_NSSAA));
    ABTS_INT_EQUAL(tc, OGS_SBI_SERVICE_TYPE_NNSSAAF_NSSAA,
        ogs_sbi_service_type_from_name(OGS_SBI_SERVICE_NAME_NNSSAAF_NSSAA));
}

abts_suite *test_sbi_message(abts_suite *suite)
{
    suite = ADD_SUITE(suite)

    abts_run_test(suite, sbi_message_test1, NULL);
    abts_run_test(suite, sbi_message_test2, NULL);
    abts_run_test(suite, sbi_message_test3, NULL);
    abts_run_test(suite, sbi_message_test4, NULL);
    abts_run_test(suite, sbi_message_test5, NULL);
    abts_run_test(suite, sbi_message_test6, NULL);
    abts_run_test(suite, sbi_message_test7, NULL);

    return suite;
}
