/* SPDX-License-Identifier: BSD-2-Clause */
/*******************************************************************************
 * Copyright 2018, Fraunhofer SIT sponsored by Infineon Technologies AG
 * All rights reserved.
 ******************************************************************************/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdarg.h>
#include <inttypes.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <json-c/json_util.h>
#include <json-c/json_tokener.h>

#include <setjmp.h>
#include <cmocka.h>

#include "tss2_fapi.h"
#include "tpm_json_serialize.h"
#include "tpm_json_deserialize.h"
#include "ifapi_json_serialize.h"
#include "ifapi_json_deserialize.h"
#include "fapi_policy.h"

#include "util/aux_util.h"

#define LOGMODULE tests
#include "util/log.h"

/* 3 copies from ifapi_helpers.c */
static void
cleanup_policy_element(TPMT_POLICYELEMENT *policy)
{
        switch (policy->type) {
        case POLICYSECRET:
            SAFE_FREE(policy->element.PolicySecret.objectPath);
            break;
        case POLICYAUTHORIZE:
            SAFE_FREE(policy->element.PolicyAuthorize.keyPath);
            SAFE_FREE(policy->element.PolicyAuthorize.keyPEM);
            break;
        case POLICYAUTHORIZENV:
            SAFE_FREE( policy->element.PolicyAuthorizeNv.nvPath);
            SAFE_FREE( policy->element.PolicyAuthorizeNv.policy_buffer);
            break;
        case POLICYSIGNED:
            SAFE_FREE(policy->element.PolicySigned.keyPath);
            SAFE_FREE(policy->element.PolicySigned.keyPEM);
            break;
        case POLICYPCR:
            SAFE_FREE(policy->element.PolicyPCR.pcrs);
            break;
        case POLICYNV:
            SAFE_FREE(policy->element.PolicyNV.nvPath);
            break;
        case POLICYDUPLICATIONSELECT:
            SAFE_FREE(policy->element.PolicyDuplicationSelect.newParentPath);
            break;
        }
}

static void cleanup_policy_elements(TPML_POLICYELEMENTS *policy)
{
    size_t i, j;
    if (policy != NULL) {
        for (i = 0; i < policy->count; i++) {
            if (policy->elements[i].type ==  POLICYOR) {
                /* Policy with sub policies */
                TPML_POLICYBRANCHES *branches = policy->elements[i].element.PolicyOr.branches;
                for (j = 0; j < branches->count; j++) {
                    SAFE_FREE(branches->authorizations[j].name);
                    SAFE_FREE(branches->authorizations[j].description);
                    cleanup_policy_elements(branches->authorizations[j].policy);
                }
                SAFE_FREE(branches);
            } else {
                cleanup_policy_element(&policy->elements[i]);
            }
        }
        SAFE_FREE(policy);
    }
}

/** Free memory allocated during deserialization of policy.
 *
 * The object will not be freed (might be declared on the stack).
 *
 * @param[in]  object The policy to be cleaned up.
 *
 */
static void ifapi_cleanup_policy(TPMS_POLICY *policy)
{
    if (policy) {
       SAFE_FREE(policy->description);
       SAFE_FREE(policy->policyAuthorizations);
       cleanup_policy_elements(policy->policy);
    }
}

/* 6 copies of cleanup functions from ifapi_keystore.c */

void
cleanup_ifapi_duplicate(IFAPI_DUPLICATE * duplicate) {
    if (duplicate != NULL) {
        SAFE_FREE(duplicate->certificate);
    }
}

void
cleanup_ifapi_hierarchy(IFAPI_HIERARCHY * hierarchy) {
    if (hierarchy != NULL) {
        SAFE_FREE(hierarchy->description);
    }
}

void
cleanup_ifapi_ext_pub_key(IFAPI_EXT_PUB_KEY * key) {
    if (key != NULL) {
        SAFE_FREE(key->pem_ext_public);
        SAFE_FREE(key->certificate);
    }
}

void
cleanup_ifapi_key(IFAPI_KEY * key) {
    if (key != NULL) {
        SAFE_FREE(key->policyInstance);
        SAFE_FREE(key->serialization.buffer);
        SAFE_FREE(key->private.buffer);
        SAFE_FREE(key->description);
        SAFE_FREE(key->certificate);
        SAFE_FREE(key->appData.buffer);
    }
}

void
cleanup_ifapi_nv(IFAPI_NV * nv) {
    if (nv != NULL) {
        SAFE_FREE(nv->serialization.buffer);
        SAFE_FREE(nv->appData.buffer);
        SAFE_FREE(nv->policyInstance);
        SAFE_FREE(nv->description);
        SAFE_FREE(nv->event_log);
    }
}

void
cleanup_ifapi_object(
    IFAPI_OBJECT * object)
{
    if (object != NULL) {
        if (object->objectType != IFAPI_OBJ_NONE) {
            if (object->objectType == IFAPI_KEY_OBJ) {
                cleanup_ifapi_key(&object->misc.key);
            } else if (object->objectType == IFAPI_NV_OBJ) {
                cleanup_ifapi_nv(&object->misc.nv);
            } else if (object->objectType == IFAPI_DUPLICATE_OBJ) {
                cleanup_ifapi_duplicate(&object->misc.key_tree);
            } else if (object->objectType == IFAPI_EXT_PUB_KEY_OBJ) {
                cleanup_ifapi_ext_pub_key(&object->misc.ext_pub_key);
            } else if (object->objectType == IFAPI_HIERARCHY_OBJ) {
                cleanup_ifapi_hierarchy(&object->misc.hierarchy);
            }

            ifapi_cleanup_policy(object->policy);
            SAFE_FREE(object->rel_path);
            SAFE_FREE(object->policy);
            object->objectType = IFAPI_OBJ_NONE;
        }
    }
}

char * normalize(const char *string) {
    char *string2 = malloc(strlen(string)+1);
    int i;
    int j = 0;
    for(i = 0; string[i] != '\0'; i++) {
        if ((string[i] != '\n' && string[i] != ' ')) {
            string2[j] = string[i];
            j += 1;
        }
    }
    string2[j] = '\0';
	return string2;
}

#define CHECK_ERROR(TYPE, SRC, RC) \
        { \
            TYPE out; \
            TSS2_RC rc; \
            json_object *jso = json_tokener_parse((SRC)); \
            assert_non_null(jso); \
            rc = ifapi_json_ ## TYPE ## _deserialize (jso, &out); \
            assert_int_equal (rc, RC); \
            json_object_put(jso); \
        }

#define CHECK_ERROR_CLEANUP(TYPE, SRC, RC)     \
        { \
            TYPE out; \
            TSS2_RC rc; \
            json_object *jso = json_tokener_parse((SRC)); \
            memset(&out, 0, sizeof(TYPE));                \
            assert_non_null(jso); \
            rc = ifapi_json_ ## TYPE ## _deserialize (jso, &out); \
            assert_int_equal (rc, RC); \
            json_object_put(jso); \
            cleanup_ifapi_object(&out); \
        }


#define CHECK_JSON2(TYPE, SRC, DST, PSERIALIZE)  \
        { \
            TYPE out; \
            TSS2_RC rc; \
            json_object *jso = json_tokener_parse((SRC)); \
            if (!jso) fprintf(stderr, "JSON parsing failed\n"); \
            assert_non_null(jso); \
            rc = ifapi_json_ ## TYPE ## _deserialize (jso, &out); \
            if (rc) fprintf(stderr, "Deserialization failed\n"); \
            assert_int_equal (rc, TSS2_RC_SUCCESS); \
            json_object_put(jso); \
            jso = NULL; \
            rc = ifapi_json_ ## TYPE ## _serialize (PSERIALIZE, &jso); \
            assert_int_equal (rc, TSS2_RC_SUCCESS); \
            assert_non_null(jso); \
            const char *jso_string = json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY); \
            assert_non_null(jso_string); \
            char *string1 = normalize(jso_string); \
            char *string2 =  normalize(DST); \
            assert_string_equal(string1, string2); \
            json_object_put(jso); \
            free(string1); \
            free(string2); \
        }

#define CHECK_JSON(TYPE, SRC, DST)  \
    CHECK_JSON2(TYPE, SRC, DST, &out)

#define CHECK_JSON_SIMPLE(TYPE, SRC, DST)  \
    CHECK_JSON2(TYPE, SRC, DST, out)

#define CHECK_JSON_TO_BIN(TYPE, SRC, DST) \
        { \
            TYPE out; \
            TSS2_RC rc; \
            TYPE expected = DST; \
            json_object *jso = json_tokener_parse((SRC)); \
            assert_non_null(jso); \
            rc = ifapi_json_ ## TYPE ## _deserialize (jso, &out); \
            assert_int_equal (rc, TSS2_RC_SUCCESS); \
            json_object_put(jso); \
            assert_true(out == expected);       \
        }

#define CHECK_BIN2(TYPE, BIN, PSERIALIZE)                  \
    TYPE BIN ## 2; \
    { \
        char *jso_string1, *jso_string2; \
        json_object *jso = NULL; \
        TSS2_RC rc = ifapi_json_ ## TYPE ## _serialize (PSERIALIZE, &jso); \
        jso_string1 = strdup(json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY)); \
        assert_int_equal (rc, TSS2_RC_SUCCESS); \
        rc = ifapi_json_ ## TYPE ## _deserialize (jso, &BIN ## 2); \
        assert_int_equal (rc, TSS2_RC_SUCCESS); \
        json_object_put(jso); \
        jso = NULL; \
        rc = ifapi_json_ ## TYPE ## _serialize (PSERIALIZE ## 2, &jso); \
        jso_string2 = strdup(json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY)); \
        assert_int_equal (rc, TSS2_RC_SUCCESS); \
        if (strcmp(jso_string1, jso_string2)) { \
            fprintf(stderr,"\n jso: %s\n", jso_string1); \
            fprintf(stderr,"\n jso: %s\n", jso_string2); \
        } \
        assert_string_equal(jso_string1, jso_string2); \
        json_object_put(jso); \
        free(jso_string1); \
        free(jso_string2); \
    }

#define CHECK_BIN(TYPE, BIN) \
    CHECK_BIN2(TYPE, BIN, &BIN)

#define CHECK_BIN_SIMPLE(TYPE, BIN) \
    CHECK_BIN2(TYPE, BIN, BIN)

static void
check_bin(void **state)
{
    TPM2B_PUBLIC inPublicAES = {
        .size = 0,
        .publicArea = {
            .type = TPM2_ALG_SYMCIPHER,
            .nameAlg = TPM2_ALG_SHA256,
            .objectAttributes = (TPMA_OBJECT_USERWITHAUTH |
                                 TPMA_OBJECT_SIGN_ENCRYPT |
                                 TPMA_OBJECT_DECRYPT),

            .authPolicy = {
                 .size = 0,
             },
            .parameters.symDetail = {
                 .sym = {
                     .algorithm = TPM2_ALG_AES,
                     .keyBits = {.aes = 128},
                     .mode = {.aes = TPM2_ALG_CFB}}
             },
            .unique.sym = {
                 .size = 0,
                 .buffer = {}
             }
        }
    };

    CHECK_BIN(TPM2B_PUBLIC, inPublicAES);

    TPM2B_PUBLIC inPublicECC = {
            .size = 0,
            .publicArea = {
                .type = TPM2_ALG_ECC,
                .nameAlg = TPM2_ALG_SHA1,
                .objectAttributes = (
                             TPMA_OBJECT_USERWITHAUTH |
                             TPMA_OBJECT_RESTRICTED |
                             TPMA_OBJECT_SIGN_ENCRYPT |
                             TPMA_OBJECT_FIXEDTPM |
                             TPMA_OBJECT_FIXEDPARENT |
                             TPMA_OBJECT_SENSITIVEDATAORIGIN
                             ),
                .authPolicy = {
                         .size = 0,
                     },

                .parameters.eccDetail = {
                     .symmetric = {
                         .algorithm = TPM2_ALG_NULL,
                         .keyBits.aes = 128,
                         .mode.aes = TPM2_ALG_ECB,
                     },
                     .scheme = {
                          .scheme = TPM2_ALG_ECDAA,
                          .details = { .ecdaa = { .hashAlg = TPM2_ALG_SHA256 }},
                      },
                     .curveID = TPM2_ECC_BN_P256,
                     .kdf = { .scheme = TPM2_ALG_NULL, .details = {} }
                 },
                /*
                  .parameters.asymDetail.symmetric.algorithm = TPM2_ALG_NULL,
                */
                .unique.ecc = {
                     .x = { .size = 0, .buffer = {} } ,
                     .y = { .size = 0, .buffer = {} } ,
                 },
            },
        };

    CHECK_BIN(TPM2B_PUBLIC, inPublicECC);

    TPM2B_PUBLIC inPublicECC_MGF1 = inPublicECC;

    inPublicECC_MGF1.publicArea.parameters.eccDetail.kdf.scheme = TPM2_ALG_MGF1;
    inPublicECC_MGF1.publicArea.parameters.eccDetail.kdf.details.mgf1.hashAlg = TPM2_ALG_SHA256;
    CHECK_BIN(TPM2B_PUBLIC, inPublicECC_MGF1);

    TPM2B_PUBLIC inPublicECC_KDF12 = inPublicECC;

    inPublicECC_KDF12.publicArea.parameters.eccDetail.kdf.scheme = TPM2_ALG_KDF1_SP800_56A;
    inPublicECC_KDF12.publicArea.parameters.eccDetail.kdf.details.kdf1_sp800_56a.hashAlg = TPM2_ALG_SHA256;
    CHECK_BIN(TPM2B_PUBLIC, inPublicECC_KDF12);

    TPM2B_PUBLIC inPublicECC_KDF13 = inPublicECC;

    inPublicECC_KDF13.publicArea.parameters.eccDetail.kdf.scheme = TPM2_ALG_KDF1_SP800_108;
    inPublicECC_KDF13.publicArea.parameters.eccDetail.kdf.details.kdf1_sp800_108.hashAlg = TPM2_ALG_SHA256;
    CHECK_BIN(TPM2B_PUBLIC, inPublicECC_KDF13);

    TPM2B_PUBLIC inPublicRSA2 = {
        .size = 0,
        .publicArea = {
            .type = TPM2_ALG_RSA,
            .nameAlg = TPM2_ALG_SHA1,
            .objectAttributes = (TPMA_OBJECT_USERWITHAUTH |
                                 TPMA_OBJECT_SIGN_ENCRYPT  |
                                 TPMA_OBJECT_FIXEDTPM |
                                 TPMA_OBJECT_FIXEDPARENT |
                                 TPMA_OBJECT_SENSITIVEDATAORIGIN),
            .authPolicy = {
                 .size = 0,
             },
            .parameters.rsaDetail = {
                 .symmetric = {
                     .algorithm = TPM2_ALG_NULL,
                     .keyBits.aes = 128,
                     .mode.aes = TPM2_ALG_CFB},
                 .scheme = {
                      .scheme = TPM2_ALG_RSAPSS,
                      .details = {
                          .rsapss = { .hashAlg = TPM2_ALG_SHA1 }
                      }
                  },
                 .keyBits = 2048,
                 .exponent = 0,
             },
            .unique.rsa = {
                 .size = 0,
                 .buffer = {},
             },
        },
    };

    TPMS_SIGNATURE_ECC ecc_signature = {
        .hash = TPM2_ALG_SHA1,
        .signatureR = {
            .size =  32,
            .buffer = {
                0x25, 0xdb, 0x1f, 0x8b, 0xbc, 0xfa, 0xbc, 0x31,
                0xf8, 0x17, 0x6a, 0xcb, 0xb2, 0xf8, 0x40, 0xa3,
                0xb6, 0xa5, 0xd3, 0x40, 0x65, 0x9d, 0x37, 0xee,
                0xd9, 0xfd, 0x52, 0x47, 0xf5, 0x14, 0xd5, 0x98
            },
        },
        .signatureS = {
            .size = 32,
            .buffer = {
                0xed, 0x62, 0x3e, 0x3d, 0xd2, 0x09, 0x08, 0xcf,
                0x58, 0x3c, 0x81, 0x4b, 0xbf, 0x65, 0x7e, 0x08,
                0xab, 0x9f, 0x40, 0xff, 0xea, 0x51, 0xda, 0x21,
                0x29, 0x8c, 0xe2, 0x4d, 0xeb, 0x34, 0x4c, 0xcc
            }
        }
    };

    CHECK_BIN(TPMS_SIGNATURE_ECC, ecc_signature);

    CHECK_BIN(TPM2B_PUBLIC, inPublicRSA2);

    TPMT_SIG_SCHEME ecc_scheme_ecdsa = { .scheme = TPM2_ALG_ECDSA, .details.ecdsa = TPM2_ALG_SHA1 };

    CHECK_BIN(TPMT_SIG_SCHEME, ecc_scheme_ecdsa);

    TPMT_SIG_SCHEME ecc_scheme_ecdaa = { .scheme = TPM2_ALG_ECDAA, .details.ecdaa = TPM2_ALG_SHA1 };

    CHECK_BIN(TPMT_SIG_SCHEME, ecc_scheme_ecdaa);

    TPMT_SIG_SCHEME rsa_scheme_rsapss = { .scheme = TPM2_ALG_RSAPSS, .details.rsapss = TPM2_ALG_SHA1 };

    CHECK_BIN(TPMT_SIG_SCHEME, rsa_scheme_rsapss);

    TPMT_SIG_SCHEME rsa_scheme_rsassa = { .scheme = TPM2_ALG_RSASSA, .details.rsassa = TPM2_ALG_SHA1 };

    CHECK_BIN(TPMT_SIG_SCHEME, rsa_scheme_rsassa);

    TPMT_SIG_SCHEME sm2_scheme = { .scheme = TPM2_ALG_SM2, .details.sm2 = TPM2_ALG_SHA1 };

    CHECK_BIN(TPMT_SIG_SCHEME, sm2_scheme);

    TPMT_SIG_SCHEME hmac_scheme = { .scheme = TPM2_ALG_HMAC, .details.hmac = TPM2_ALG_SHA1 };

    CHECK_BIN(TPMT_SIG_SCHEME, hmac_scheme);

    TPMT_SIG_SCHEME ecschnorr_scheme = { .scheme = TPM2_ALG_ECSCHNORR, .details.ecschnorr = TPM2_ALG_SHA1 };

    CHECK_BIN(TPMT_SIG_SCHEME, ecschnorr_scheme);

    TPMT_SIG_SCHEME rsa_scheme = { .scheme = TPM2_ALG_NULL };

    CHECK_BIN(TPMT_SIG_SCHEME, rsa_scheme);

    TPMA_NV testNV = 0xffffff0f ;

    CHECK_BIN_SIMPLE(TPMA_NV, testNV);

    TPML_PCR_SELECTION pcr_selection = {
        .count = 3,
        .pcrSelections = {
         {
            .hash = TPM2_ALG_SHA1,
            .sizeofSelect = 3,
            .pcrSelect = { 01, 00, 03 }},
        {
            .hash = TPM2_ALG_SHA256,
            .sizeofSelect = 3,
            .pcrSelect = { 01 ,00 ,03 }},
        {
            .hash = TPM2_ALG_SHA384,
            .sizeofSelect = 3,
            .pcrSelect = { 02, 00, 02 }}
        }
    };

    CHECK_BIN(TPML_PCR_SELECTION, pcr_selection);

    IFAPI_IMA_EVENT imaEvent = {
        .eventData = {
            .size = 0,
            .buffer = { 0 }
        },
        .eventName = "Event"
    };

    CHECK_BIN(IFAPI_IMA_EVENT, imaEvent);
    free(imaEvent2.eventName);
}

static void
check_policy_bin(void **state)
{
    TPMS_PCRVALUE pcr_value;
    TPML_PCRVALUES *pcr_value_list;
    TPML_POLICYBRANCHES *or_branch_list;
    TPMS_POLICYPCR pcr_policy;
    TPMT_POLICYELEMENT policy_element0;
    TPMT_POLICYELEMENT policy_element1;
    TPMT_POLICYELEMENT policy_element_or;
    TPML_POLICYELEMENTS *policy_elements_or;
    TPML_POLICYELEMENTS *policy_elements0;
    TPML_POLICYELEMENTS *policy_elements1;
    TPMS_POLICY policy;
    TPMS_POLICYBRANCH branch0;
    TPMS_POLICYBRANCH branch1;

    pcr_value.pcr = 16;
    pcr_value.hashAlg = TPM2_ALG_SHA1;
    memset(&pcr_value.digest, 0, sizeof(TPMU_HA));
    memset(&pcr_policy, 0, sizeof(TPMS_POLICYPCR));
    pcr_value_list = calloc(1, sizeof(TPML_PCRVALUES) + sizeof(TPMS_PCRVALUE));
    if (pcr_value_list == NULL) {
        LOG_ERROR("%s", "Out of memory.");
        return;
    }
    pcr_value_list->count = 1;
    pcr_value_list->pcrs[0] = pcr_value;
    pcr_policy.pcrs = pcr_value_list;
    memset(&policy_element0, 0, sizeof(TPMT_POLICYELEMENT));
    policy_element0.element.PolicyPCR = pcr_policy;
    policy_element0.type = POLICYPCR;
    memset(&policy_element1, 0, sizeof(TPMT_POLICYELEMENT));
    policy_element1.element.PolicyPCR = pcr_policy;
    policy_element1.type = POLICYPCR;
    policy_elements0 = calloc(1, sizeof(TPML_POLICYELEMENTS) + sizeof(TPMT_POLICYELEMENT));
    if (policy_elements0 == NULL) {
        LOG_ERROR("%s", "Out of memory.");
        if (pcr_policy.pcrs){
            free(pcr_policy.pcrs);
        }
        return;
    }
    policy_elements0->count = 1;
    policy_elements0->elements[0] = policy_element0;
    policy.policy = policy_elements0;
    policy.description = "hareness description";
    policy.policyAuthorizations = NULL;
    memset(&policy.policyDigests, 0, sizeof(TPML_DIGEST_VALUES));

    //CHECK_BIN(TPMS_POLICY, policy);
    {
        char *jso_string1, *jso_string2;
        json_object *jso = NULL;
        TSS2_RC rc = ifapi_json_TPMS_POLICY_serialize (&policy, &jso);
        jso_string1 = strdup(json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY));
        assert_int_equal (rc, TSS2_RC_SUCCESS);
        rc = ifapi_json_TPMS_POLICY_deserialize (jso, &policy);
        assert_int_equal (rc, TSS2_RC_SUCCESS);
        json_object_put(jso);
        jso = NULL;
        rc = ifapi_json_TPMS_POLICY_serialize (&policy, &jso);
        jso_string2 = strdup(json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY));
        assert_int_equal (rc, TSS2_RC_SUCCESS);
        if (strcmp(jso_string1, jso_string2)) {
            fprintf(stderr,"\n jso: %s\n", jso_string1);
            fprintf(stderr,"\n jso: %s\n", jso_string2);
        }
        assert_string_equal(jso_string1, jso_string2);
        json_object_put(jso);
        free(jso_string1);
        free(jso_string2);
    }
    ifapi_cleanup_policy(&policy);

    or_branch_list = calloc(2, sizeof(TPML_POLICYBRANCHES) + (2 * sizeof(TPMS_POLICYBRANCH)));
    if (or_branch_list == NULL) {
        LOG_ERROR("%s", "Out of memory.");
        return;
    }
    or_branch_list->count = 2;

    policy_elements1 = calloc(1, sizeof(TPML_POLICYELEMENTS) + sizeof(TPMT_POLICYELEMENT));
    if (policy_elements1 == NULL) {
        LOG_ERROR("%s", "Out of memory.");
        if (or_branch_list){
            free(or_branch_list);
        }
        return;
    }
    policy_elements1->count = 1;
    policy_elements1->elements[0] = policy_element1;

    memset(&branch0, 0, sizeof(TPMS_POLICYBRANCH));
    memset(&branch1, 0, sizeof(TPMS_POLICYBRANCH));
    branch0.policy = policy_elements0;
    branch0.name = "branch0";
    branch0.description = "description branch 0";
    branch1.policy = policy_elements1;
    branch1.name = "branch1";
    branch1.description = "description branch 1";
    memcpy(&or_branch_list->authorizations[0], &branch0, sizeof(TPMS_POLICYBRANCH));
    memcpy(&or_branch_list->authorizations[1], &branch1, sizeof(TPMS_POLICYBRANCH));
    //or_policy.pcrs = pcr_branch_list;

    policy_elements_or = calloc(1, sizeof(TPML_POLICYELEMENTS) + sizeof(TPMT_POLICYELEMENT));
    if (policy_elements_or == NULL) {
        LOG_ERROR("%s", "Out of memory.");
        if (or_branch_list) {
            free(or_branch_list);
        }
        return;
    }
    policy_elements_or->count = 1;

    memset(&policy_element_or, 0, sizeof(TPMT_POLICYELEMENT));
    policy_element_or.element.PolicyOr.branches = or_branch_list;
    policy_element_or.type = POLICYOR;
    policy_elements_or->elements[0] = policy_element_or;
    policy.policy =  policy_elements_or;

    //CHECK_BIN(TPMS_POLICY, policy);
    {
        char *jso_string1, *jso_string2;
        json_object *jso = NULL;
        TSS2_RC rc = ifapi_json_TPMS_POLICY_serialize (&policy, &jso);
        jso_string1 = strdup(json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY));
        assert_int_equal (rc, TSS2_RC_SUCCESS);
        rc = ifapi_json_TPMS_POLICY_deserialize (jso, &policy);
        assert_int_equal (rc, TSS2_RC_SUCCESS);
        json_object_put(jso);
        jso = NULL;
        rc = ifapi_json_TPMS_POLICY_serialize (&policy, &jso);
        jso_string2 = strdup(json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY));
        assert_int_equal (rc, TSS2_RC_SUCCESS);
        if (strcmp(jso_string1, jso_string2)) {
            fprintf(stderr,"\n jso: %s\n", jso_string1);
            fprintf(stderr,"\n jso: %s\n", jso_string2);
        }
        assert_string_equal(jso_string1, jso_string2);
        json_object_put(jso);
        free(jso_string1);
        free(jso_string2);
    }
    ifapi_cleanup_policy(&policy);

    free(policy_elements_or);
    free(policy_elements0);
    free(policy_elements1);
    free(or_branch_list);
    free(pcr_value_list);
}

static void
check_json_to_bin(void **state)
{
    CHECK_JSON_TO_BIN(UINT64, "22147483647", 22147483647);
    CHECK_JSON_TO_BIN(UINT64, "\"0xffffffff\"", 0xffffffff);
    CHECK_JSON_TO_BIN(UINT64, "\"0xfffffffff\"", 0xfffffffff);
    CHECK_JSON_TO_BIN(UINT32,  "\"0xFfffffff\"", 0xffffffff);
    CHECK_JSON_TO_BIN(UINT16, "\"0xffff\"", 0xffff);
}

static void
check_json_structs(void **state)
{
    const char *test_json_TPMS_POLICYTEMPLATE =
        "{\n"
        "  \"templateHash\": \"0011223344556677889900112233445566778899\"\n"
        "}";
    CHECK_JSON(TPMS_POLICYTEMPLATE, test_json_TPMS_POLICYTEMPLATE, test_json_TPMS_POLICYTEMPLATE);

    const char *test_json_TPM2B_PUBLIC_expected =
        "{\n"
        "  \"size\":0,\n"
        "  \"publicArea\":{\n"
        "    \"type\":\"ECC\",\n"
        "    \"nameAlg\":\"SHA1\",\n"
        "\"objectAttributes\":{"
        "      \"fixedTPM\":1,"
        "      \"stClear\":0,"
        "      \"fixedParent\":1,"
        "      \"sensitiveDataOrigin\":1,"
        "      \"userWithAuth\":1,"
        "      \"adminWithPolicy\":0,"
        "      \"noDA\":0,"
        "      \"encryptedDuplication\":0,"
        "      \"restricted\":1,"
        "      \"decrypt\":0,"
        "      \"sign\":1"
        "    },"
        "    \"authPolicy\":\"\",\n"
        "    \"parameters\":{\n"
        "      \"symmetric\":{\n"
        "        \"algorithm\":\"NULL\"\n"
        "      },\n"
        "      \"scheme\":{\n"
        "        \"scheme\":\"ECDAA\",\n"
        "        \"details\":{\n"
        "          \"hashAlg\":\"SHA256\",\n"
        "          \"count\":0\n"
        "        }\n"
        "      },\n"
        "      \"curveID\":\"BN_P256\",\n"
        "      \"kdf\":{\n"
        "        \"scheme\":\"NULL\"\n"
        "      }\n"
        "    },\n"
        "    \"unique\":{\n"
        "      \"x\": \"\",\n"
        "      \"y\": \"\"\n"
        "    }\n"
        "  }\n"
        "}";

    const char *test_json_TPM2B_PUBLIC_src=
        "{"
        "  \"size\":0,"
        "  \"publicArea\":{"
        "    \"type\":\"ECC\","
        "    \"nameAlg\":\"SHA1\","
        "    \"objectAttributes\":["
        "      \"fixedTPM\","
        "      \"fixedParent\","
        "      \"sensitiveDataOrigin\","
        "      \"userWithAuth\","
        "      \"restricted\","
        "      \"sign\""
        "    ],"
        "    \"authPolicy\":\"\","
        "    \"parameters\":{"
        "      \"symmetric\":{"
        "        \"algorithm\":\"NULL\""
        "      },"
        "      \"scheme\":{"
        "        \"scheme\":\"ECDAA\","
        "        \"details\":{"
        "          \"hashAlg\":\"SHA256\","
        "          \"count\":0"
        "        }"
        "      },"
        "      \"curveID\":\"ECC_BN_P256\","
        "      \"kdf\":{"
        "        \"scheme\":\"NULL\""
        "      }"
        "    },"
        "    \"unique\":{"
        "      \"x\": \"\",\n"
        "      \"y\": \"\"\n"
        "    }"
        "  }"
        "}"
        "";
    const char *test_json_TPM2B_PUBLIC_dwnc_src =
        "{"
        "  \"size\":0,"
        "  \"publicArea\":{"
        "    \"type\":\"ecc\","
        "    \"nameAlg\":\"sha1\","
        "    \"objectAttributes\":["
        "      \"fixedTPM\","
        "      \"fixedParent\","
        "      \"sensitiveDataOrigin\","
        "      \"userWithAuth\","
        "      \"restricted\","
        "      \"sign\""
        "    ],"
        "    \"authPolicy\":\"\","
        "    \"parameters\":{"
        "      \"symmetric\":{"
        "        \"algorithm\":\"null\""
        "      },"
        "      \"scheme\":{"
        "        \"scheme\":\"ecdaa\","
        "        \"details\":{"
        "          \"hashAlg\":\"sha256\","
        "          \"count\":0"
        "        }"
        "      },"
        "      \"curveID\":\"ecc_BN_P256\","
        "      \"kdf\":{"
        "        \"scheme\":\"null\""
        "      }"
        "    },"
        "    \"unique\":{"
        "      \"x\": \"\",\n"
        "      \"y\": \"\"\n"
        "      }"
        "    }"
        "  }"
        "}"
        "";

    CHECK_JSON(TPM2B_PUBLIC, test_json_TPM2B_PUBLIC_src, test_json_TPM2B_PUBLIC_expected);
    CHECK_JSON(TPM2B_PUBLIC, test_json_TPM2B_PUBLIC_dwnc_src, test_json_TPM2B_PUBLIC_expected);

    const char *test_json_TPMS_ATTEST_certify_src =
        "{\n"
        "    \"magic\": \"0xff544347\",\n"
        "    \"type\": \"ST_ATTEST_CERTIFY\",\n"
        "    \"qualifiedSigner\": \"0x00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
        "    \"extraData\": \"0x00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
        "    \"clockInfo\": {\n"
        "        \"clock\": 123,\n"
        "        \"resetCount\": 23,\n"
        "        \"restartCount\": 1,\n"
        "        \"safe\": \"yes\"\n"
        "    },\n"
        "    \"firmwareVersion\": 783,\n"
        "    \"attested\": {\n"
        "        \"name\": \"0x00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
        "        \"qualifiedName\": \"0x00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
        "    }\n"
        "}";
    const char *test_json_TPMS_ATTEST_certify_expt =
        "{\n"
        "    \"magic\": \"VALUE\",\n"
        "    \"type\": \"ATTEST_CERTIFY\",\n"
        "    \"qualifiedSigner\": \"00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
        "    \"extraData\": \"00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
        "    \"clockInfo\": {\n"
        "        \"clock\": 123,\n"
        "        \"resetCount\": 23,\n"
        "        \"restartCount\": 1,\n"
        "        \"safe\": \"YES\"\n"
        "    },\n"
        "    \"firmwareVersion\": 783,\n"
        "    \"attested\": {\n"
        "        \"name\": \"00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
        "        \"qualifiedName\": \"00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
        "    }\n"
        "}";
    CHECK_JSON(TPMS_ATTEST, test_json_TPMS_ATTEST_certify_src, test_json_TPMS_ATTEST_certify_expt);

    const char *test_json_TPMS_ATTEST_sessionaudit_src =
        "{\n"
        "    \"magic\": \"0xff544347\",\n"
        "    \"type\": \"ST_ATTEST_SESSION_AUDIT\",\n"
        "    \"qualifiedSigner\": \"0x00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
        "    \"extraData\": \"0x00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
        "    \"clockInfo\": {\n"
        "        \"clock\": [12345,0],\n"
        "        \"resetCount\": 23,\n"
        "        \"restartCount\": 1,\n"
        "        \"safe\": \"yes\"\n"
        "    },\n"
        "    \"firmwareVersion\": [783783,0],\n"
        "    \"attested\": {\n"
        "        \"exclusiveSession\": \"yes\",\n"
        "        \"sessionDigest\": \"0x00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
        "    }\n"
        "}";
    const char *test_json_TPMS_ATTEST_sessionaudit_expt =
        "{\n"
        "    \"magic\": \"VALUE\",\n"
        "    \"type\": \"ATTEST_SESSION_AUDIT\",\n"
        "    \"qualifiedSigner\": \"00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
        "    \"extraData\": \"00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
        "    \"clockInfo\": {\n"
        "        \"clock\": 53021371269120,\n"
        "        \"resetCount\": 23,\n"
        "        \"restartCount\": 1,\n"
        "        \"safe\": \"YES\"\n"
        "    },\n"
        "    \"firmwareVersion\": [783783,0],\n"
        "    \"attested\": {\n"
        "        \"exclusiveSession\": \"YES\",\n"
        "        \"sessionDigest\": \"00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
        "    }\n"
        "}";
    CHECK_JSON(TPMS_ATTEST, test_json_TPMS_ATTEST_sessionaudit_src, test_json_TPMS_ATTEST_sessionaudit_expt);

    const char *test_json_TPMS_ATTEST_certifycreation_src =
        "{\n"
        "    \"magic\": \"0xff544347\",\n"
        "    \"type\": \"ST_ATTEST_CREATION\",\n"
        "    \"qualifiedSigner\": \"0x00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
        "    \"extraData\": \"0x00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
        "    \"clockInfo\": {\n"
        "        \"clock\": 123,\n"
        "        \"resetCount\": 23,\n"
        "        \"restartCount\": 1,\n"
        "        \"safe\": \"yes\"\n"
        "    },\n"
        "    \"firmwareVersion\": [0,783],\n"
        "    \"attested\": {\n"
        "        \"objectName\": \"0x00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
        "        \"creationHash\": \"0x00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
        "    }\n"
        "}";
    const char *test_json_TPMS_ATTEST_certifycreation_expt =
        "{\n"
        "    \"magic\": \"VALUE\",\n"
        "    \"type\": \"ATTEST_CREATION\",\n"
        "    \"qualifiedSigner\": \"00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
        "    \"extraData\": \"00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
        "    \"clockInfo\": {\n"
        "        \"clock\": 123,\n"
        "        \"resetCount\": 23,\n"
        "        \"restartCount\": 1,\n"
        "        \"safe\": \"YES\"\n"
        "    },\n"
        "    \"firmwareVersion\": 783,\n"
        "    \"attested\": {\n"
        "        \"objectName\": \"00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
        "        \"creationHash\": \"00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
        "    }\n"
        "}";
    CHECK_JSON(TPMS_ATTEST, test_json_TPMS_ATTEST_certifycreation_src, test_json_TPMS_ATTEST_certifycreation_expt);

    const char *test_json_TPMS_ATTEST_commandaudit_src =
        "{\n"
        "    \"magic\": \"0xff544347\",\n"
        "    \"type\": \"ST_ATTEST_COMMAND_AUDIT\",\n"
        "    \"qualifiedSigner\": \"0x00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
        "    \"extraData\": \"0x00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
        "    \"clockInfo\": {\n"
        "        \"clock\": 123,\n"
        "        \"resetCount\": 23,\n"
        "        \"restartCount\": 1,\n"
        "        \"safe\": \"yes\"\n"
        "    },\n"
        "    \"firmwareVersion\": 783,\n"
        "    \"attested\": {\n"
        "        \"auditCounter\": 456,\n"
        "        \"digestAlg\": \"sha1\",\n"
        "        \"auditDigest\": \"0x00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
        "        \"commandDigest\": \"0x00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
        "    }\n"
        "}";
    const char *test_json_TPMS_ATTEST_commandaudit_expt =
        "{\n"
        "    \"magic\": \"VALUE\",\n"
        "    \"type\": \"ATTEST_COMMAND_AUDIT\",\n"
        "    \"qualifiedSigner\": \"00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
        "    \"extraData\": \"00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
        "    \"clockInfo\": {\n"
        "        \"clock\": 123,\n"
        "        \"resetCount\": 23,\n"
        "        \"restartCount\": 1,\n"
        "        \"safe\": \"YES\"\n"
        "    },\n"
        "    \"firmwareVersion\": 783,\n"
        "    \"attested\": {\n"
        "        \"auditCounter\": 456,\n"
        "        \"digestAlg\": \"SHA1\",\n"
        "        \"auditDigest\": \"00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
        "        \"commandDigest\": \"00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
        "    }\n"
        "}";
    CHECK_JSON(TPMS_ATTEST, test_json_TPMS_ATTEST_commandaudit_src, test_json_TPMS_ATTEST_commandaudit_expt);

    const char *test_json_TPMS_ATTEST_time_src =
        "{\n"
        "    \"magic\": \"0xff544347\",\n"
        "    \"type\": \"ST_ATTEST_TIME\",\n"
        "    \"qualifiedSigner\": \"0x00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
        "    \"extraData\": \"0x00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
        "    \"clockInfo\": {\n"
        "        \"clock\": 123,\n"
        "        \"resetCount\": 23,\n"
        "        \"restartCount\": 1,\n"
        "        \"safe\": \"yes\"\n"
        "    },\n"
        "    \"firmwareVersion\": 783,\n"
        "    \"attested\": {\n"
        "        \"time\": {\n"
        "            \"time\": 234,\n"
        "            \"clockInfo\": {\n"
        "                \"clock\": 123,\n"
        "                \"resetCount\": 23,\n"
        "                \"restartCount\": 1,\n"
        "                \"safe\": \"yes\"\n"
        "            }\n"
        "        },\n"
        "        \"firmwareVersion\": 783\n"
        "    }\n"
        "}";
    const char *test_json_TPMS_ATTEST_time_expt =
        "{\n"
        "    \"magic\": \"VALUE\",\n"
        "    \"type\": \"ATTEST_TIME\",\n"
        "    \"qualifiedSigner\": \"00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
        "    \"extraData\": \"00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
        "    \"clockInfo\": {\n"
        "        \"clock\": 123,\n"
        "        \"resetCount\": 23,\n"
        "        \"restartCount\": 1,\n"
        "        \"safe\": \"YES\"\n"
        "    },\n"
        "    \"firmwareVersion\": 783,\n"
        "    \"attested\": {\n"
        "        \"time\": {\n"
        "            \"time\": 234,\n"
        "            \"clockInfo\": {\n"
        "                \"clock\": 123,\n"
        "                \"resetCount\": 23,\n"
        "                \"restartCount\": 1,\n"
        "                \"safe\": \"YES\"\n"
        "            }\n"
        "        },\n"
        "        \"firmwareVersion\": 783\n"
        "    }\n"
        "}";
    CHECK_JSON(TPMS_ATTEST, test_json_TPMS_ATTEST_time_src, test_json_TPMS_ATTEST_time_expt);

    const char *test_json_TPMS_ATTEST_certifynv_src =
        "{\n"
        "    \"magic\": \"0xff544347\",\n"
        "    \"type\": \"ST_ATTEST_NV\",\n"
        "    \"qualifiedSigner\": \"0x00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
        "    \"extraData\": \"0x00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
        "    \"clockInfo\": {\n"
        "        \"clock\": 123,\n"
        "        \"resetCount\": 23,\n"
        "        \"restartCount\": 1,\n"
        "        \"safe\": \"yes\"\n"
        "    },\n"
        "    \"firmwareVersion\": 783,\n"
        "    \"attested\": {\n"
        "        \"indexName\": \"0x00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
        "        \"offset\": 10,\n"
        "        \"nvContents\": \"0x00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
        "    }\n"
        "}";
    const char *test_json_TPMS_ATTEST_certifynv_expt =
        "{\n"
        "    \"magic\": \"VALUE\",\n"
        "    \"type\": \"ATTEST_NV\",\n"
        "    \"qualifiedSigner\": \"00010203040506070809a0a1a2a3a4a5a6a7a8a9\",\n"
        "    \"extraData\": \"00010203040506070809b0b1b2b3b4b5b6b7b8b9\",\n"
        "    \"clockInfo\": {\n"
        "        \"clock\": 123,\n"
        "        \"resetCount\": 23,\n"
        "        \"restartCount\": 1,\n"
        "        \"safe\": \"YES\"\n"
        "    },\n"
        "    \"firmwareVersion\": 783,\n"
        "    \"attested\": {\n"
        "        \"indexName\": \"00010203040506070809c0c1c2c3c4c5c6c7c8c9\",\n"
        "        \"offset\": 10,\n"
        "        \"nvContents\": \"00010203040506070809d0d1d2d3d4d5d6d7d8d9\"\n"
        "    }\n"
        "}";
    CHECK_JSON(TPMS_ATTEST, test_json_TPMS_ATTEST_certifynv_src, test_json_TPMS_ATTEST_certifynv_expt);

    const char *test_json_TPMT_KEYEDHASH_SCHEME_hmac_src =
        "{\n"
        "    \"scheme\": \"HMAC\",\n"
        "    \"details\": {\n"
        "        \"hashAlg\": \"SHA256\"\n"
        "    }\n"
        "}";
    const char *test_json_TPMT_KEYEDHASH_SCHEME_hmac_expt =
        "{\n"
        "    \"scheme\": \"HMAC\",\n"
        "    \"details\": {\n"
        "        \"hashAlg\": \"SHA256\"\n"
        "    }\n"
        "}";
    CHECK_JSON(TPMT_KEYEDHASH_SCHEME, test_json_TPMT_KEYEDHASH_SCHEME_hmac_src, test_json_TPMT_KEYEDHASH_SCHEME_hmac_expt);

    const char *test_json_TPMT_KEYEDHASH_SCHEME_xor_src =
        "{\n"
        "    \"scheme\": \"XOR\",\n"
        "    \"details\": {\n"
        "        \"hashAlg\": \"SHA256\",\n"
        "        \"kdf\": \"MGF1\"\n"
        "    }\n"
        "}";
    const char *test_json_TPMT_KEYEDHASH_SCHEME_xor_expt =
        "{\n"
        "    \"scheme\": \"XOR\",\n"
        "    \"details\": {\n"
        "        \"hashAlg\": \"SHA256\",\n"
        "        \"kdf\": \"MGF1\"\n"
        "    }\n"
        "}";
    CHECK_JSON(TPMT_KEYEDHASH_SCHEME, test_json_TPMT_KEYEDHASH_SCHEME_xor_src, test_json_TPMT_KEYEDHASH_SCHEME_xor_expt);

}

static void
check_json_constants(void **state)
{
    CHECK_JSON_SIMPLE(TPMI_ALG_HASH, "\"sha1\"", "\"SHA1\"");
    CHECK_JSON_SIMPLE(TPMI_ALG_HASH, "\"0x04\"", "\"SHA1\"");
    CHECK_JSON_SIMPLE(TPMI_ALG_HASH, "4", "\"SHA1\"");
}

static void
check_json_numbers(void **state)
{
    CHECK_JSON_SIMPLE(UINT16, "10", "10");
    CHECK_JSON_SIMPLE(UINT16, "\"0x0a\"", "10");
    CHECK_JSON_SIMPLE(UINT64, "10000000000000000","[2328306,1874919424]");
}

static void
check_json_bits(void **state)
{
    CHECK_JSON_SIMPLE(TPMA_NV, "{\"PPWRITE\":1,\"OWNERWRITE\":1}",
                      "{\"PPWRITE\":1,\"OWNERWRITE\":1,\"AUTHWRITE\":0,\"POLICYWRITE\":0,\"POLICY_DELETE\":0,"
                      "\"WRITELOCKED\":0,\"WRITEALL\":0,\"WRITEDEFINE\":0,\"WRITE_STCLEAR\":0,\"GLOBALLOCK\":0,\"PPREAD\":0,"
                      "\"OWNERREAD\":0,\"AUTHREAD\":0,\"POLICYREAD\":0,\"NO_DA\":0,\"ORDERLY\":0,\"CLEAR_STCLEAR\":0,"
                      "\"READLOCKED\":0,\"WRITTEN\":0,\"PLATFORMCREATE\":0,\"READ_STCLEAR\":0,\"TPM2_NT\":\"ORDINARY\"}");
    CHECK_JSON_SIMPLE(TPMA_LOCALITY, "3", "{\"ZERO\":1,\"ONE\":1,\"TWO\":0,\"THREE\":0,\"FOUR\":0,\"Extended\":0}");
    CHECK_JSON_SIMPLE(TPMA_LOCALITY,
                      "[ \"ZERO\", \"ONE\" ]",
                      "{\"ZERO\":1,\"ONE\":1,\"TWO\":0,\"THREE\":0,\"FOUR\":0,\"Extended\":0}");
    CHECK_JSON_SIMPLE(TPMA_NV, "\"0xffffff0f\"",
                      "{\"PPWRITE\":1,\"OWNERWRITE\":1,\"AUTHWRITE\":1,\"POLICYWRITE\":1,\"POLICY_DELETE\":1,"
                      "\"WRITELOCKED\":1,\"WRITEALL\":1,\"WRITEDEFINE\":1,\"WRITE_STCLEAR\":1,\"GLOBALLOCK\":1,\"PPREAD\":1,"
                      "\"OWNERREAD\":1,\"AUTHREAD\":1,\"POLICYREAD\":1,\"NO_DA\":1,\"ORDERLY\":1,\"CLEAR_STCLEAR\":1,"
                      "\"READLOCKED\":1,\"WRITTEN\":1,\"PLATFORMCREATE\":1,\"READ_STCLEAR\":1,\"TPM2_NT\":\"ORDINARY\"}");
    CHECK_JSON_SIMPLE(TPMA_LOCALITY, "3", "{\"ZERO\":1,\"ONE\":1,\"TWO\":0,\"THREE\":0,\"FOUR\":0,\"Extended\":0}");
    CHECK_JSON_SIMPLE(TPMA_LOCALITY,
                      "{\"ZERO\":1,\"ONE\":1,\"TWO\":0,\"THREE\":0,\"FOUR\":0,\"Extended\":0}",
                      "{\"ZERO\":1,\"ONE\":1,\"TWO\":0,\"THREE\":0,\"FOUR\":0,\"Extended\":0}");
    CHECK_JSON_SIMPLE(TPMA_OBJECT,
                      "{\"fixedTPM\":1,\"stClear\":1,\"fixedParent\":0,\"sensitiveDataOrigin\":0,\"userWithAuth\":0,"
                      "\"adminWithPolicy\":0,\"noDA\":0,\"encryptedDuplication\":0,\"restricted\":0,\"decrypt\":0,\"sign\":0}",
                      "{\"fixedTPM\":1,\"stClear\":1,\"fixedParent\":0,\"sensitiveDataOrigin\":0,\"userWithAuth\":0,"
                      "\"adminWithPolicy\":0,\"noDA\":0,\"encryptedDuplication\":0,\"restricted\":0,\"decrypt\":0,\"sign\":0}");
    CHECK_JSON_SIMPLE(TPMA_OBJECT,
                      "\"0\"",
                      "{\"fixedTPM\":0,\"stClear\":0,\"fixedParent\":0,\"sensitiveDataOrigin\":0,\"userWithAuth\":0,"
                      "\"adminWithPolicy\":0,\"noDA\":0,\"encryptedDuplication\":0,\"restricted\":0,\"decrypt\":0,\"sign\":0}");

    const char *test_json_TPMA_NV_expected =\
                    "{"
                    "  \"PPWRITE\":0,"
                    "  \"OWNERWRITE\":1,"
                    "  \"AUTHWRITE\":1,"
                    "  \"POLICYWRITE\":1,"
                    "  \"POLICY_DELETE\":1,"
                    "  \"WRITELOCKED\":0,"
                    "  \"WRITEALL\":0,"
                    "  \"WRITEDEFINE\":0,"
                    "  \"WRITE_STCLEAR\":0,"
                    "  \"GLOBALLOCK\":0,"
                    "  \"PPREAD\":0,"
                    "  \"OWNERREAD\":1,"
                    "  \"AUTHREAD\":1,"
                    "  \"POLICYREAD\":1,"
                    "  \"NO_DA\":0,"
                    "  \"ORDERLY\":1,"
                    "  \"CLEAR_STCLEAR\":1,"
                    "  \"READLOCKED\":1,"
                    "  \"WRITTEN\":1,"
                    "  \"PLATFORMCREATE\":0,"
                    "  \"READ_STCLEAR\":0,"
                    "  \"TPM2_NT\":\"COUNTER\""
                    "}";

    const char *test_json_TPMA_NV_src_array =\
                    "["
                    "  \"nv_ownerwrite\","
                    "  \"nv_authwrite\","
                    "  \"nv_policywrite\","
                    "  \"nv_policy_delete\","
                    "  \"nv_ownerread\","
                    "  \"nv_authread\","
                    "  \"nv_policyread\","
                    "  \"nv_orderly\","
                    "  \"nv_clear_stclear\","
                    "  \"nv_readlocked\","
                    "  \"nv_written\","
                    "  {"
                    "    \"TPM2_NT\": \"NT_COUNTER\""
                    "  }"
                    "]";

    const char *test_json_TPMA_NV_src_struct =  \
                    "{"
                    "  \"TPMA_NV_OWNERWRITE\":\"YES\","
                    "  \"TPMA_NV_AUTHWRITE\":\"yes\","
                    "  \"TPMA_NV_POLICYWRITE\":\"TPM2_YES\","
                    "  \"TPMA_NV_POLICY_DELETE\":\"tpm2_yes\","
                    "  \"TPMA_NV_OWNERREAD\":\"SET\","
                    "  \"TPMA_NV_AUTHREAD\":\"set\","
                    "  \"TPMA_NV_POLICYREAD\":1,"
                    "  \"TPMA_NV_ORDERLY\":1,"
                    "  \"TPMA_NV_CLEAR_STCLEAR\":1,"
                    "  \"TPMA_NV_READLOCKED\":1,"
                    "  \"TPMA_NV_WRITTEN\":1,"
                    "  \"TPM2_NT\":1"
                    "  }";

    const char *test_json_TPMA_NV_expected2 =    \
                    "{"
                    "  \"PPWRITE\":1,"
                    "  \"OWNERWRITE\":0,"
                    "  \"AUTHWRITE\":0,"
                    "  \"POLICYWRITE\":0,"
                    "  \"POLICY_DELETE\":0,"
                    "  \"WRITELOCKED\":0,"
                    "  \"WRITEALL\":0,"
                    "  \"WRITEDEFINE\":0,"
                    "  \"WRITE_STCLEAR\":0,"
                    "  \"GLOBALLOCK\":0,"
                    "  \"PPREAD\":0,"
                    "  \"OWNERREAD\":0,"
                    "  \"AUTHREAD\":0,"
                    "  \"POLICYREAD\":0,"
                    "  \"NO_DA\":0,"
                    "  \"ORDERLY\":0,"
                    "  \"CLEAR_STCLEAR\":0,"
                    "  \"READLOCKED\":0,"
                    "  \"WRITTEN\":0,"
                    "  \"PLATFORMCREATE\":0,"
                    "  \"READ_STCLEAR\":0,"
                    "  \"TPM2_NT\":\"ORDINARY\""
                    "}";

    CHECK_JSON_SIMPLE(TPMA_NV, test_json_TPMA_NV_src_array, test_json_TPMA_NV_expected);
    CHECK_JSON_SIMPLE(TPMA_NV, test_json_TPMA_NV_src_struct, test_json_TPMA_NV_expected);
    CHECK_JSON_SIMPLE(TPMA_NV, "1", test_json_TPMA_NV_expected2);
}

static void
check_json_policy(void **state)
{
     const char *test_json_policy_nv_src =       \
        "{"
        "  \"description\":\"Description pol_nv\","
        "  \"policyDigests\":["
        "  ],"
        "  \"policyAuthorizations\":["
        "  ],"
        "    \"policy\":["
        "        {"
        "            \"type\": \"POLICYNV\","
        "                   \"nvPath\": \"myNV\","
        "                   \"operandB\": \"01030304\""
        "      }"
        "  ]"
        "}";

       const char *test_json_policy_nv_expected =       \
        "{"
        "  \"description\":\"Description pol_nv\","
        "  \"policyDigests\":["
        "  ],"
        "  \"policyAuthorizations\":["
        "  ],"
        "    \"policy\":["
        "        {"
        "            \"type\": \"POLICYNV\","
        "                   \"nvPath\": \"myNV\","
        "                   \"operandB\": \"01030304\""
        "     }"
        "  ]"
        "}";


//    CHECK_JSON(TPMS_POLICY, test_json_policy_nv_src, test_json_policy_nv_expected);
        {
            TPMS_POLICY out;
            TSS2_RC rc;
            json_object *jso = json_tokener_parse(test_json_policy_nv_src);
            if (!jso) fprintf(stderr, "JSON parsing failed\n");
            assert_non_null(jso);
            rc = ifapi_json_TPMS_POLICY_deserialize (jso, &out);
            if (rc) fprintf(stderr, "Deserialization failed\n");
            assert_int_equal (rc, TSS2_RC_SUCCESS);
            json_object_put(jso);
            jso = NULL;
            rc = ifapi_json_TPMS_POLICY_serialize (&out, &jso);
            assert_int_equal (rc, TSS2_RC_SUCCESS);
            assert_non_null(jso);
            const char *jso_string = json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY);
            assert_non_null(jso_string);
            char *string1 = normalize(jso_string);
            char *string2 =  normalize(test_json_policy_nv_expected);
            assert_string_equal(string1, string2);
            json_object_put(jso);
            ifapi_cleanup_policy(&out);
            free(string1);
            free(string2);
        }

    const char *test_json_policy_or_src =       \
        "{"
        "  \"description\":\"hareness description\","
        "  \"policyDigests\":["
        "    {"
        "      \"hashAlg\":\"SHA256\","
        "      \"digest\":\"59215cb6c21a60e26b2cc479334a021113611903795507c1227659e2aef23d16\""
        "    }"
        "  ],"
        "  \"policy\":["
        "    {"
        "      \"type\":\"POLICYOR\","
        "      \"policyDigests\":["
        "        {"
        "          \"hashAlg\":\"SHA256\","
        "          \"digest\":\"59215cb6c21a60e26b2cc479334a021113611903795507c1227659e2aef23d16\""
        "        }"
        "      ],"
        "        \"branches\":["
        "          {"
        "            \"name\":\"branch1\","
        "            \"description\":\"description branch 1\","
        "            \"policy\":["
        "              {"
        "                \"type\":\"POLICYPCR\","
        "                \"policyDigests\":["
        "                  {"
        "                    \"hashAlg\":\"SHA256\","
        "                    \"digest\":\"17d552f8e39ad882f6b3c09ae139af59616bf6a63f4093d6d20e9e1b9f7cdb6e\""
        "                  }"
        "                ],"
        "                  \"pcrs\":["
        "                    {"
        "                      \"pcr\":16,"
        "                      \"hashAlg\":\"SHA1\","
        "                      \"digest\":\"0000000000000000000000000000000000000000\""
        "                    }"
        "                  ]"
        "              }"
        "            ],"
        "            \"policyDigests\":["
        "              {"
        "                \"hashAlg\":\"SHA256\","
        "                \"digest\":\"17d552f8e39ad882f6b3c09ae139af59616bf6a63f4093d6d20e9e1b9f7cdb6e\""
        "              }"
        "            ]"
        "          },"
        "          {"
        "            \"name\":\"branch1\","
        "            \"description\":\"description branch 1\","
        "            \"policy\":["
        "              {"
        "                \"type\":\"POLICYPCR\","
        "                \"policyDigests\":["
        "                  {"
        "                    \"hashAlg\":\"SHA256\","
        "                    \"digest\":\"17d552f8e39ad882f6b3c09ae139af59616bf6a63f4093d6d20e9e1b9f7cdb6e\""
        "                  }"
        "                ],"
        "                  \"pcrs\":["
        "                    {"
        "                      \"pcr\":16,"
        "                      \"hashAlg\":\"SHA1\","
        "                      \"digest\":\"0000000000000000000000000000000000000000\""
        "                    }"
        "                  ]"
        "              }"
        "            ],"
        "            \"policyDigests\":["
        "              {"
        "                \"hashAlg\":\"SHA256\","
        "                \"digest\":\"17d552f8e39ad882f6b3c09ae139af59616bf6a63f4093d6d20e9e1b9f7cdb6e\""
        "              }"
        "            ]"
        "          }"
        "        ]"
        "    }"
        "  ]"
        "}";

    char *test_json_policy_or_expected = strdup(test_json_policy_or_src);
    if (test_json_policy_or_expected == NULL){
        LOG_ERROR("%s", "Out of memory.");
        return;
    }
//    CHECK_JSON(TPMS_POLICY, test_json_policy_or_src, test_json_policy_or_expected);
        {
            TPMS_POLICY out;
            TSS2_RC rc;
            json_object *jso = json_tokener_parse(test_json_policy_or_src);
            if (!jso) fprintf(stderr, "JSON parsing failed\n");
            assert_non_null(jso);
            rc = ifapi_json_TPMS_POLICY_deserialize (jso, &out);
            if (rc) fprintf(stderr, "Deserialization failed\n");
            assert_int_equal (rc, TSS2_RC_SUCCESS);
            json_object_put(jso);
            jso = NULL;
            rc = ifapi_json_TPMS_POLICY_serialize (&out, &jso);
            assert_int_equal (rc, TSS2_RC_SUCCESS);
            assert_non_null(jso);
            const char *jso_string = json_object_to_json_string_ext(jso, JSON_C_TO_STRING_PRETTY);
            assert_non_null(jso_string);
            char *string1 = normalize(jso_string);
            char *string2 =  normalize(test_json_policy_or_expected);
            assert_string_equal(string1, string2);
            json_object_put(jso);
            ifapi_cleanup_policy(&out);
            free(string1);
            free(string2);
        }
    free(test_json_policy_or_expected);
}


static void
check_json_tpm2bs(void **state)
{
    CHECK_JSON(TPM2B_DIGEST, "\"0x0102\"", "\"0102\"");
    CHECK_JSON(TPM2B_DIGEST, "\"0102\"", "\"0102\"");
    CHECK_JSON(TPM2B_DIGEST, "\"caffee\"", "\"caffee\"");
}

static void
check_error(void **state)
{
   /* Value is > then max value for UINT */
    CHECK_ERROR(UINT16, "\"0x10000\"", TSS2_FAPI_RC_BAD_VALUE);
    CHECK_ERROR(UINT32, "\"0x100000000\"", TSS2_FAPI_RC_BAD_VALUE);

    /* Digest/list is too large*/
    CHECK_ERROR(TPM2B_DIGEST, "\"0x0102222222222222222222222222222222222222222222222222222"
                "22222222222222222222222222222222222222222222222222222222222222222222222222222\"",
                TSS2_FAPI_RC_BAD_VALUE);

    /* Illegal values */
    CHECK_ERROR(TPMI_ALG_HASH, "\"SHA9999\"", TSS2_FAPI_RC_BAD_VALUE);
    CHECK_ERROR(TPM2B_DIGEST, "\"xxxx\"", TSS2_FAPI_RC_BAD_VALUE);
    CHECK_ERROR(TPM2B_DIGEST, "\"0x010x\"", TSS2_FAPI_RC_BAD_VALUE);

    /*
     * Illegal keys
     */
    const char *test_json_key_err1 =
        /* Without persistent handle */
        "{"
        "  \"objectType\":1,"
        "  \"system\":\"YES\","
        "}";
    CHECK_ERROR_CLEANUP(IFAPI_OBJECT, test_json_key_err1, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_key_err2 =
        /* Without public */
        "{"
        "  \"objectType\":1,"
        "  \"system\":\"YES\","
        "  \"persistent_handle\":0,"
        "}";
    CHECK_ERROR_CLEANUP(IFAPI_OBJECT, test_json_key_err2, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_key_err3 =
        /* Without serialization */
        "{"
        "  \"objectType\":1,"
        "  \"system\":\"YES\","
        "  \"with_auth\":\"NO\","
        "  \"persistent_handle\":0,"
        "  \"public\":{"
        "    \"size\":122,"
        "    \"publicArea\":{"
        "      \"type\":\"ECC\","
        "      \"nameAlg\":\"SHA256\","
        "      \"objectAttributes\":1,"
        "      \"authPolicy\":\"837197674484b3f81a90cc8d46a5d724fd52d76e06520b64f2a1da1b331469aa\","
        "      \"parameters\":{"
        "        \"symmetric\":{"
        "          \"algorithm\":\"AES\","
        "          \"keyBits\":128,"
        "          \"mode\":\"CFB\""
        "        },"
        "        \"scheme\":{"
        "          \"scheme\":\"NULL\""
        "        },"
        "        \"curveID\":\"NIST_P256\","
        "        \"kdf\":{"
        "          \"scheme\":\"NULL\""
        "        }"
        "      },"
        "      \"unique\":{"
        "        \"x\":\"78d926c582566a70eedffcda4fe147e1b24fe624305441167fac483a3079b2e7\","
        "        \"y\":\"8bdc62992c3382e29687114ea0a9e1ac69f91283ae1d018b6d37859731617c3a\""
        "      }"
        "    }"
        "  },"
        "}";
    CHECK_ERROR_CLEANUP(IFAPI_OBJECT, test_json_key_err3, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_key_err4 =
        /* Without PolicyInstance */
        "{"
        "  \"objectType\":1,"
        "  \"system\":\"YES\","
        "  \"with_auth\":\"NO\","
        "  \"persistent_handle\":0,"
        "  \"public\":{"
        "    \"size\":122,"
        "    \"publicArea\":{"
        "      \"type\":\"ECC\","
        "      \"nameAlg\":\"SHA256\","
        "      \"objectAttributes\":{"
        "        \"fixedTPM\":1,"
        "        \"stClear\":0,"
        "        \"fixedParent\":1,"
        "        \"sensitiveDataOrigin\":1,"
        "        \"userWithAuth\":0,"
        "        \"adminWithPolicy\":1,"
        "        \"noDA\":0,"
        "        \"encryptedDuplication\":0,"
        "        \"restricted\":1,"
        "        \"decrypt\":1,"
        "        \"sign\":0"
        "      },"
        "      \"authPolicy\":\"837197674484b3f81a90cc8d46a5d724fd52d76e06520b64f2a1da1b331469aa\","
        "      \"parameters\":{"
        "        \"symmetric\":{"
        "          \"algorithm\":\"AES\","
        "          \"keyBits\":128,"
        "          \"mode\":\"CFB\""
        "        },"
        "        \"scheme\":{"
        "          \"scheme\":\"NULL\""
        "        },"
        "        \"curveID\":\"NIST_P256\","
        "        \"kdf\":{"
        "          \"scheme\":\"NULL\""
        "        }"
        "      },"
        "      \"unique\":{"
        "        \"x\":\"78d926c582566a70eedffcda4fe147e1b24fe624305441167fac483a3079b2e7\","
        "        \"y\":\"8bdc62992c3382e29687114ea0a9e1ac69f91283ae1d018b6d37859731617c3a\""
        "      }"
        "    }"
        "  },"
        "  \"serialization\":\"\","
        "}";
    CHECK_ERROR_CLEANUP(IFAPI_OBJECT, test_json_key_err4, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_key_err5 =
        /* Without certificate */
        "{"
        "  \"objectType\":1,"
        "  \"system\":\"YES\","
        "  \"with_auth\":\"NO\","
        "  \"persistent_handle\":0,"
        "  \"public\":{"
        "    \"size\":122,"
        "    \"publicArea\":{"
        "      \"type\":\"ECC\","
        "      \"nameAlg\":\"SHA256\","
        "      \"objectAttributes\":{"
        "        \"fixedTPM\":1,"
        "        \"stClear\":0,"
        "        \"fixedParent\":1,"
        "        \"sensitiveDataOrigin\":1,"
        "        \"userWithAuth\":0,"
        "        \"adminWithPolicy\":1,"
        "        \"noDA\":0,"
        "        \"encryptedDuplication\":0,"
        "        \"restricted\":1,"
        "        \"decrypt\":1,"
        "        \"sign\":0"
        "      },"
        "      \"authPolicy\":\"837197674484b3f81a90cc8d46a5d724fd52d76e06520b64f2a1da1b331469aa\","
        "      \"parameters\":{"
        "        \"symmetric\":{"
        "          \"algorithm\":\"AES\","
        "          \"keyBits\":128,"
        "          \"mode\":\"CFB\""
        "        },"
        "        \"scheme\":{"
        "          \"scheme\":\"NULL\""
        "        },"
        "        \"curveID\":\"NIST_P256\","
        "        \"kdf\":{"
        "          \"scheme\":\"NULL\""
        "        }"
        "      },"
        "      \"unique\":{"
        "        \"x\":\"78d926c582566a70eedffcda4fe147e1b24fe624305441167fac483a3079b2e7\","
        "        \"y\":\"8bdc62992c3382e29687114ea0a9e1ac69f91283ae1d018b6d37859731617c3a\""
        "      }"
        "    }"
        "  },"
        "  \"serialization\":\"\","
        "  \"policyInstance\":\"\","
        "  \"description\":\"\","
        "}";
    CHECK_ERROR_CLEANUP(IFAPI_OBJECT, test_json_key_err5, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_key_err6 =
        /* Without description */
        "{"
        "  \"objectType\":1,"
        "  \"system\":\"YES\","
        "  \"with_auth\":\"NO\","
        "  \"persistent_handle\":0,"
        "  \"public\":{"
        "    \"size\":122,"
        "    \"publicArea\":{"
        "      \"type\":\"ECC\","
        "      \"nameAlg\":\"SHA256\","
        "      \"objectAttributes\":{"
        "        \"fixedTPM\":1,"
        "        \"stClear\":0,"
        "        \"fixedParent\":1,"
        "        \"sensitiveDataOrigin\":1,"
        "        \"userWithAuth\":0,"
        "        \"adminWithPolicy\":1,"
        "        \"noDA\":0,"
        "        \"encryptedDuplication\":0,"
        "        \"restricted\":1,"
        "        \"decrypt\":1,"
        "        \"sign\":0"
        "      },"
        "      \"authPolicy\":\"837197674484b3f81a90cc8d46a5d724fd52d76e06520b64f2a1da1b331469aa\","
        "      \"parameters\":{"
        "        \"symmetric\":{"
        "          \"algorithm\":\"AES\","
        "          \"keyBits\":128,"
        "          \"mode\":\"CFB\""
        "        },"
        "        \"scheme\":{"
        "          \"scheme\":\"NULL\""
        "        },"
        "        \"curveID\":\"NIST_P256\","
        "        \"kdf\":{"
        "          \"scheme\":\"NULL\""
        "        }"
        "      },"
        "      \"unique\":{"
        "        \"x\":\"78d926c582566a70eedffcda4fe147e1b24fe624305441167fac483a3079b2e7\","
        "        \"y\":\"8bdc62992c3382e29687114ea0a9e1ac69f91283ae1d018b6d37859731617c3a\""
        "      }"
        "    }"
        "  },"
        "  \"serialization\":\"\","
        "  \"policyInstance\":\"\","
        "  \"certificate\":\"\","
        "}";
    CHECK_ERROR_CLEANUP(IFAPI_OBJECT, test_json_key_err6, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_key_err7 =
        /* Without signing scheme */
         "{"
         "  \"objectType\":1,"
         "  \"system\":\"YES\","
         "  \"public\":{"
        "    \"size\":122,"
        "    \"publicArea\":{"
        "      \"type\":\"ECC\","
        "      \"nameAlg\":\"SHA256\","
        "      \"objectAttributes\":{"
        "        \"fixedTPM\":1,"
        "        \"stClear\":0,"
        "        \"fixedParent\":1,"
        "        \"sensitiveDataOrigin\":1,"
        "        \"userWithAuth\":0,"
        "        \"adminWithPolicy\":1,"
        "        \"noDA\":0,"
        "        \"encryptedDuplication\":0,"
        "        \"restricted\":1,"
        "        \"decrypt\":1,"
        "        \"sign\":0"
        "      },"
        "      \"authPolicy\":\"837197674484b3f81a90cc8d46a5d724fd52d76e06520b64f2a1da1b331469aa\","
        "      \"parameters\":{"
        "        \"symmetric\":{"
        "          \"algorithm\":\"AES\","
        "          \"keyBits\":128,"
        "          \"mode\":\"CFB\""
        "        },"
        "        \"scheme\":{"
        "          \"scheme\":\"NULL\""
        "        },"
        "        \"curveID\":\"NIST_P256\","
        "        \"kdf\":{"
        "          \"scheme\":\"NULL\""
        "        }"
        "      },"
        "      \"unique\":{"
        "        \"x\":\"78d926c582566a70eedffcda4fe147e1b24fe624305441167fac483a3079b2e7\","
        "        \"y\":\"8bdc62992c3382e29687114ea0a9e1ac69f91283ae1d018b6d37859731617c3a\""
        "      }"
        "    }"
        "  },"
         "  \"with_auth\":\"NO\","
         "  \"persistent_handle\":0,"
          "  \"serialization\":\"\","
         "  \"policyInstance\":\"\","
         "  \"certificate\":\"\","
         "  \"description\":\"\","
         "}";
    CHECK_ERROR_CLEANUP(IFAPI_OBJECT, test_json_key_err7, TSS2_FAPI_RC_BAD_VALUE);

      const char *test_json_key_err8 =
        /* Without name */
         "{"
         "  \"objectType\":1,"
         "  \"system\":\"YES\","
         "  \"public\":{"
        "    \"size\":122,"
        "    \"publicArea\":{"
        "      \"type\":\"ECC\","
        "      \"nameAlg\":\"SHA256\","
        "      \"objectAttributes\":{"
        "        \"fixedTPM\":1,"
        "        \"stClear\":0,"
        "        \"fixedParent\":1,"
        "        \"sensitiveDataOrigin\":1,"
        "        \"userWithAuth\":0,"
        "        \"adminWithPolicy\":1,"
        "        \"noDA\":0,"
        "        \"encryptedDuplication\":0,"
        "        \"restricted\":1,"
        "        \"decrypt\":1,"
        "        \"sign\":0"
        "      },"
        "      \"authPolicy\":\"837197674484b3f81a90cc8d46a5d724fd52d76e06520b64f2a1da1b331469aa\","
        "      \"parameters\":{"
        "        \"symmetric\":{"
        "          \"algorithm\":\"AES\","
        "          \"keyBits\":128,"
        "          \"mode\":\"CFB\""
        "        },"
        "        \"scheme\":{"
        "          \"scheme\":\"NULL\""
        "        },"
        "        \"curveID\":\"NIST_P256\","
        "        \"kdf\":{"
        "          \"scheme\":\"NULL\""
        "        }"
        "      },"
        "      \"unique\":{"
        "        \"x\":\"78d926c582566a70eedffcda4fe147e1b24fe624305441167fac483a3079b2e7\","
        "        \"y\":\"8bdc62992c3382e29687114ea0a9e1ac69f91283ae1d018b6d37859731617c3a\""
        "      }"
        "    }"
        "  },"
         "  \"with_auth\":\"NO\","
         "  \"persistent_handle\":0,"
          "  \"serialization\":\"\","
         "  \"policyInstance\":\"\","
         "  \"certificate\":\"\","
         "  \"description\":\"\","
          "  \"signing_scheme\":{"
          "    \"scheme\":\"ECDSA\","
          "    \"details\":{"
          "      \"hashAlg\":\"SHA256\""
          "    }"
          "  },"
         "}";
    CHECK_ERROR_CLEANUP(IFAPI_OBJECT, test_json_key_err8, TSS2_FAPI_RC_BAD_VALUE);


    const char *test_json_nv_err1 =
        "{"
        "  \"objectType\":2,"
        "  \"system\":\"NO\","
        "  \"with_auth\":\"NO\","
        "  \"nv_object\":true,"
        "  \"hierarchy\":257,"
        "  \"policyInstance\":\"\","
        "  \"description\":\"\","
        "}";

    CHECK_ERROR_CLEANUP(IFAPI_OBJECT, test_json_nv_err1, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_nv_err2 =
        "{"
        "  \"objectType\":2,"
        "  \"system\":\"NO\","
        "  \"with_auth\":\"NO\","
        "  \"nv_object\":true,"
        "  \"public\":{"
        "    \"size\":0,"
        "    \"nvPublic\":{"
        "      \"nvIndex\":25165824,"
        "      \"nameAlg\":\"SHA256\","
        "      \"attributes\":{"
        "        \"PPWRITE\":0,"
        "        \"OWNERWRITE\":0,"
        "        \"AUTHWRITE\":0,"
        "        \"POLICYWRITE\":1,"
        "        \"POLICY_DELETE\":0,"
        "        \"WRITELOCKED\":0,"
        "        \"WRITEALL\":0,"
        "        \"WRITEDEFINE\":0,"
        "        \"WRITE_STCLEAR\":1,"
        "        \"GLOBALLOCK\":0,"
        "        \"PPREAD\":0,"
        "        \"OWNERREAD\":0,"
        "        \"AUTHREAD\":0,"
        "        \"POLICYREAD\":1,"
        "        \"NO_DA\":1,"
        "        \"ORDERLY\":0,"
        "        \"CLEAR_STCLEAR\":0,"
        "        \"READLOCKED\":0,"
        "        \"WRITTEN\":0,"
        "        \"PLATFORMCREATE\":0,"
        "        \"READ_STCLEAR\":1,"
        "        \"TPM2_NT\":\"ORDINARY\""
        "      },"
        "      \"authPolicy\":\"0000000000000000000000000000000000000000000000000000000000000000\","
        "      \"dataSize\":1200"
        "    }"
        "  },"
        "  \"serialization\":\"018000000022000b59323f518181d5e607ade494f3ecaf7ba552ddc57fde379b3cf8ca82c009257c00000002002e01800000000b820840080020000000000000000000000000000000000000000000000000000000000000000004b0\","
        "  \"policyInstance\":\"\","
        "  \"description\":\"\","
        "}";

    CHECK_ERROR_CLEANUP(IFAPI_OBJECT, test_json_nv_err2, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_nv_err3 =
        "{"
        "  \"objectType\":2,"
        "  \"system\":\"NO\","
        "  \"with_auth\":\"NO\","
        "  \"nv_object\":true,"
        "  \"public\":{"
        "    \"size\":0,"
        "    \"nvPublic\":{"
        "      \"nvIndex\":25165824,"
        "      \"nameAlg\":\"SHA256\","
        "      \"attributes\":{"
        "        \"PPWRITE\":0,"
        "        \"OWNERWRITE\":0,"
        "        \"AUTHWRITE\":0,"
        "        \"POLICYWRITE\":1,"
        "        \"POLICY_DELETE\":0,"
        "        \"WRITELOCKED\":0,"
        "        \"WRITEALL\":0,"
        "        \"WRITEDEFINE\":0,"
        "        \"WRITE_STCLEAR\":1,"
        "        \"GLOBALLOCK\":0,"
        "        \"PPREAD\":0,"
        "        \"OWNERREAD\":0,"
        "        \"AUTHREAD\":0,"
        "        \"POLICYREAD\":1,"
        "        \"NO_DA\":1,"
        "        \"ORDERLY\":0,"
        "        \"CLEAR_STCLEAR\":0,"
        "        \"READLOCKED\":0,"
        "        \"WRITTEN\":0,"
        "        \"PLATFORMCREATE\":0,"
        "        \"READ_STCLEAR\":1,"
        "        \"TPM2_NT\":\"ORDINARY\""
        "      },"
        "      \"authPolicy\":\"0000000000000000000000000000000000000000000000000000000000000000\","
        "      \"dataSize\":1200"
        "    }"
        "  },"
        "  \"serialization\":\"018000000022000b59323f518181d5e607ade494f3ecaf7ba552ddc57fde379b3cf8ca82c009257c00000002002e01800000000b820840080020000000000000000000000000000000000000000000000000000000000000000004b0\","
        "  \"hierarchy\":257,"
        "  \"description\":\"\","
        "}";
    CHECK_ERROR_CLEANUP(IFAPI_OBJECT, test_json_nv_err3, TSS2_FAPI_RC_BAD_VALUE);
    const char *test_json_nv_err4 =
        "{"
        "  \"objectType\":2,"
        "  \"system\":\"NO\","
        "  \"nv_object\":true,"
        "  \"public\":{"
        "    \"size\":0,"
        "    \"nvPublic\":{"
        "      \"nvIndex\":25165824,"
        "      \"nameAlg\":\"SHA256\","
        "      \"attributes\":{"
        "        \"PPWRITE\":0,"
        "        \"OWNERWRITE\":0,"
        "        \"AUTHWRITE\":0,"
        "        \"POLICYWRITE\":1,"
        "        \"POLICY_DELETE\":0,"
        "        \"WRITELOCKED\":0,"
        "        \"WRITEALL\":0,"
        "        \"WRITEDEFINE\":0,"
        "        \"WRITE_STCLEAR\":1,"
        "        \"GLOBALLOCK\":0,"
        "        \"PPREAD\":0,"
        "        \"OWNERREAD\":0,"
        "        \"AUTHREAD\":0,"
        "        \"POLICYREAD\":1,"
        "        \"NO_DA\":1,"
        "        \"ORDERLY\":0,"
        "        \"CLEAR_STCLEAR\":0,"
        "        \"READLOCKED\":0,"
        "        \"WRITTEN\":0,"
        "        \"PLATFORMCREATE\":0,"
        "        \"READ_STCLEAR\":1,"
        "        \"TPM2_NT\":\"ORDINARY\""
        "      },"
        "      \"authPolicy\":\"0000000000000000000000000000000000000000000000000000000000000000\","
        "      \"dataSize\":1200"
        "    }"
        "  },"
        "  \"serialization\":\"018000000022000b59323f518181d5e607ade494f3ecaf7ba552ddc57fde379b3cf8ca82c009257c00000002002e01800000000b820840080020000000000000000000000000000000000000000000000000000000000000000004b0\","
        "  \"hierarchy\":257,"
        "  \"policyInstance\":\"\","
        "}";
    CHECK_ERROR_CLEANUP(IFAPI_OBJECT, test_json_nv_err4, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_nv_err5 =
        "{"
        "  \"objectType\":2,"
        "  \"system\":\"NO\","
        "  \"with_auth\":\"NO\","
        "  \"nv_object\":true,"
        "  \"public\":{"
        "    \"size\":0,"
        "    \"nvPublic\":{"
        "      \"nvIndex\":25165824,"
        "      \"nameAlg\":\"SHA256\","
        "      \"attributes\":{"
        "        \"PPWRITE\":0,"
        "        \"OWNERWRITE\":0,"
        "        \"AUTHWRITE\":0,"
        "        \"POLICYWRITE\":1,"
        "        \"POLICY_DELETE\":0,"
        "        \"WRITELOCKED\":0,"
        "        \"WRITEALL\":0,"
        "        \"WRITEDEFINE\":0,"
        "        \"WRITE_STCLEAR\":1,"
        "        \"GLOBALLOCK\":0,"
        "        \"PPREAD\":0,"
        "        \"OWNERREAD\":0,"
        "        \"AUTHREAD\":0,"
        "        \"POLICYREAD\":1,"
        "        \"NO_DA\":1,"
        "        \"ORDERLY\":0,"
        "        \"CLEAR_STCLEAR\":0,"
        "        \"READLOCKED\":0,"
        "        \"WRITTEN\":0,"
        "        \"PLATFORMCREATE\":0,"
        "        \"READ_STCLEAR\":1,"
        "        \"TPM2_NT\":\"ORDINARY\""
        "      },"
        "      \"authPolicy\":\"0000000000000000000000000000000000000000000000000000000000000000\","
        "      \"dataSize\":1200"
        "    }"
        "  },"
        "  \"serialization\":\"018000000022000b59323f518181d5e607ade494f3ecaf7ba552ddc57fde379b3cf8ca82c009257c00000002002e01800000000b820840080020000000000000000000000000000000000000000000000000000000000000000004b0\","
        "  \"hierarchy\":257,"
        "  \"description\":\"\","
        "}";
    CHECK_ERROR_CLEANUP(IFAPI_OBJECT, test_json_nv_err5, TSS2_FAPI_RC_BAD_VALUE);

        const char *test_json_attest_err1 =
        "{"
        "    \"magic\":\"VALUE\","
        "    \"type\":\"ATTEST_QUOTE\","
        "    \"qualifiedSigner\":\"000b5adea4e8b49b3f76db36b9442a29e515263e28bbd9e9263843675bb3cf750202\","
        "    \"extraData\":\"6768033e216468247bd031a0a2d9876d79818f8f\","
        "    \"clockInfo\":{"
        "    \"clock\":8048,"
        "    \"resetCount\":639972755,"
        "    \"restartCount\":158941495,"
        "    \"safe\":\"YES\" }"
        "}";
    CHECK_ERROR(TPMS_ATTEST, test_json_attest_err1, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_attest_err2 =
        "{"
        "    \"magic\":\"VALUE\","
        "    \"type\":\"ATTEST_QUOTE\","
        "    \"qualifiedSigner\":\"000b5adea4e8b49b3f76db36b9442a29e515263e28bbd9e9263843675bb3cf750202\","
        "    \"extraData\":\"6768033e216468247bd031a0a2d9876d79818f8f\""
        "}";
    CHECK_ERROR(TPMS_ATTEST, test_json_attest_err2, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_attest_err3 =
        "{"
        "    \"magic\":\"VALUE\","
        "    \"type\":\"ATTEST_QUOTE\","
        "    \"qualifiedSigner\":\"000b5adea4e8b49b3f76db36b9442a29e515263e28bbd9e9263843675bb3cf750202\","
        "}";
    CHECK_ERROR(TPMS_ATTEST, test_json_attest_err3, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_attest_err4 =
        "{"
        "    \"magic\":\"VALUE\","
        "    \"type\":\"ATTEST_QUOTE\","
        "}";
    CHECK_ERROR(TPMS_ATTEST, test_json_attest_err4, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_attest_err5 =
        "{"
        "    \"magic\":\"VALUE\","
        "}";
    CHECK_ERROR(TPMS_ATTEST, test_json_attest_err5, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_attest_err6 =
        "{"
        "}";
    CHECK_ERROR(TPMS_ATTEST, test_json_attest_err6, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_clock_err1 =
        "{"
        "      \"clock\":8048,"
        "      \"resetCount\":639972755,"
        "      \"restartCount\":158941495,"
        "}";

    CHECK_ERROR(TPMS_CLOCK_INFO, test_json_clock_err1, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_clock_err2 =
        "{"
        "      \"clock\":8048,"
        "      \"resetCount\":639972755,"
        "}";

    CHECK_ERROR(TPMS_CLOCK_INFO, test_json_clock_err2, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_clock_err3 =
        "{"
        "      \"clock\":8048,"
        "}";

    CHECK_ERROR(TPMS_CLOCK_INFO, test_json_clock_err3, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_clock_err4 =
        "{"
        "}";

    CHECK_ERROR(TPMS_CLOCK_INFO, test_json_clock_err4, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_command_audit_err1 =
        "{"
        "      \"auditCounter\":8048,"
        "      \"digestAlg\":\"sha1\","
        "      \"auditDigest\":\"0102\","
        "}";

    CHECK_ERROR(TPMS_COMMAND_AUDIT_INFO, test_json_command_audit_err1, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_command_audit_err2 =
        "{"
        "      \"auditCounter\":8048,"
        "      \"digestAlg\":\"sha1\","
        "}";

    CHECK_ERROR(TPMS_COMMAND_AUDIT_INFO, test_json_command_audit_err2, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_command_audit_err3 =
        "{"
        "      \"auditCounter\":8048,"
        "}";

    CHECK_ERROR(TPMS_COMMAND_AUDIT_INFO, test_json_command_audit_err3, TSS2_FAPI_RC_BAD_VALUE);
      const char *test_json_command_audit_err4 =
        "{"
        "}";

    CHECK_ERROR(TPMS_COMMAND_AUDIT_INFO, test_json_command_audit_err4, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_tk_creation_err1 =
        "{"
        "      \"tag\":\"NULL\","
        "      \"hierarchy\":\"OWNER\","
        "}";

    CHECK_ERROR(TPMT_TK_CREATION, test_json_tk_creation_err1, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_tk_creation_err2 =
        "{"
        "      \"tag\":\"NULL\","
        "}";

    CHECK_ERROR(TPMT_TK_CREATION, test_json_tk_creation_err2, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_tk_creation_err3 =
        "{"
        "}";

    CHECK_ERROR(TPMT_TK_CREATION, test_json_tk_creation_err3, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_nv_certify_info_err1 =
        "{"
        "      \"indexName\":\"0102\","
        "      \"offset\":0,"
        "}";

    CHECK_ERROR(TPMS_NV_CERTIFY_INFO, test_json_nv_certify_info_err1, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_nv_certify_info_err2 =
        "{"
        "      \"indexName\":\"0102\","
        "}";

    CHECK_ERROR(TPMS_NV_CERTIFY_INFO, test_json_nv_certify_info_err2, TSS2_FAPI_RC_BAD_VALUE);
    const char *test_json_nv_certify_info_err3 =
        "{"
        "}";

    CHECK_ERROR(TPMS_NV_CERTIFY_INFO, test_json_nv_certify_info_err3, TSS2_FAPI_RC_BAD_VALUE);


    const char *test_json_signature_ecc_err1 =
        "{"
        "      \"hash\":\"sha1\","
        "      \"signatureR\":\"0102\","
        "}";

    CHECK_ERROR(TPMS_SIGNATURE_ECC, test_json_signature_ecc_err1, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_signature_ecc_err2 =
        "{"
        "      \"hash\":\"sha1\","
        "}";

    CHECK_ERROR(TPMS_SIGNATURE_ECC, test_json_signature_ecc_err2, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_signature_ecc_err4 =
        "{"
        "}";

    CHECK_ERROR(TPMS_SIGNATURE_ECC, test_json_signature_ecc_err4, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_signature_err1 =
        "{"
        "      \"sigAlg\":\"HMAC\","
        "      \"signature\":\"0102\","
        "}";

    CHECK_ERROR(TPMT_SIGNATURE, test_json_signature_err1, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_signature_err2 =
        "{"
        "      \"sigAlg\":\"ECDSA\","
        "      \"signature\":\"0102\","
        "}";

    CHECK_ERROR(TPMT_SIGNATURE, test_json_signature_err2, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_signature_err3 =
        "{"
        "      \"sigAlg\":\"ECDAA\","
        "      \"signature\":\"0102\","
        "}";

    CHECK_ERROR(TPMT_SIGNATURE, test_json_signature_err3, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_signature_err4 =
        "{"
        "      \"sigAlg\":\"SM2\","
        "      \"signature\":\"0102\","
        "}";

    CHECK_ERROR(TPMT_SIGNATURE, test_json_signature_err4, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_signature_err5 =
        "{"
        "      \"sigAlg\":\"ECSCHNORR\","
        "      \"signature\":\"0102\","
        "}";

    CHECK_ERROR(TPMT_SIGNATURE, test_json_signature_err5, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_signature_err6 =
        "{"
        "      \"sigAlg\":\"RSASSA\","
        "      \"signature\":\"0102\","
        "}";

    CHECK_ERROR(TPMT_SIGNATURE, test_json_signature_err6, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_signature_err7 =
        "{"
        "}";

    CHECK_ERROR(TPMT_SIGNATURE, test_json_signature_err7, TSS2_FAPI_RC_BAD_VALUE);

    const char *test_json_signature_err8 =
        "{"
        "      \"sigAlg\":\"RSASSA\","
        "}";

    CHECK_ERROR(TPMT_SIGNATURE, test_json_signature_err8, TSS2_FAPI_RC_BAD_VALUE);
}

static void
check_tpmjson_tofromtxt(void **state)
{
    const char *testcase_alg_id[] = { "\"TPM_ALG_ID_SHA1\"", "\"TPM2_ALG_ID_SHA1\"",
                                      "\"ALG_ID_SHA1\"", "\"SHA1\"", "\"ALG_SHA1\"",
                                      "\"tpm2_alg_id_sha1\"", "\"sha1\"", "\"0x0004\"" };
    const char *expected_ald_id = { "\"SHA1\"" };
    for (size_t i = 0; i < sizeof(testcase_alg_id) / sizeof(testcase_alg_id[0]); i++) {
        CHECK_JSON_SIMPLE(TPM2_ALG_ID, testcase_alg_id[i], expected_ald_id);
    }

    const char *testcase_ecc_curve[] = { "\"TPM2_ECC_NIST_P256\"", "\"ECC_NIST_P256\"",
                                         "\"NIST_P256\"", "\"0x0003\"", "\"nist_p256\"" };
    const char *expected_ecc_curve = { "\"NIST_P256\"" };
    for (size_t i = 0; i < sizeof(testcase_ecc_curve) / sizeof(testcase_ecc_curve[0]); i++) {
        CHECK_JSON_SIMPLE(TPM2_ECC_CURVE, testcase_ecc_curve[i], expected_ecc_curve);
    }

    const char *testcase_cc[] = { "\"TPM2_CC_Startup\"", "\"CC_Startup\"",
                                  "\"Startup\"", "\"0x00000144\"" };
    const char *expected_cc = { "\"Startup\"" };
    for (size_t i = 0; i < sizeof(testcase_cc) / sizeof(testcase_cc[0]); i++) {
        CHECK_JSON_SIMPLE(TPM2_CC, testcase_cc[i], expected_cc);
    }

    const char *testcase_eo[] = { "\"TPM2_EO_EQ\"", "\"EO_EQ\"",
                                  "\"EQ\"", "\"0x0000\"" };
    const char *expected_eo = { "\"EQ\"" };
    for (size_t i = 0; i < sizeof(testcase_eo) / sizeof(testcase_eo[0]); i++) {
        CHECK_JSON_SIMPLE(TPM2_EO, testcase_eo[i], expected_eo);
    }

    const char *testcase_st[] = { "\"TPM2_ST_NO_SESSIONS\"", "\"ST_NO_SESSIONS\"",
                                  "\"no_SESSIONS\"", "\"0x8001\"" };
    const char *expected_st = { "\"NO_SESSIONS\"" };
    for (size_t i = 0; i < sizeof(testcase_st) / sizeof(testcase_st[0]); i++) {
        CHECK_JSON_SIMPLE(TPM2_ST, testcase_st[i], expected_st);
    }

    const char *testcase_pt_pcr[] = { "\"TPM2_PT_PCR_EXTEND_L0\"", "\"PT_PCR_EXTEND_L0\"",
                                  "\"PCR_EXTEND_L0\"", "\"EXTEND_L0\"" };
    const char *expected_pt_pcr = { "\"EXTEND_L0\"" };
    for (size_t i = 0; i < sizeof(testcase_pt_pcr) / sizeof(testcase_pt_pcr[0]); i++) {
        CHECK_JSON_SIMPLE(TPM2_PT_PCR, testcase_pt_pcr[i], expected_pt_pcr);
    }

    const char *testcase_alg_public[] = { "\"TPM2_ALG_RSA\"", "\"ALG_RSA\"",
                                          "\"RSA\"", "\"0x0001\"" };
    const char *expected_alg_public = { "\"RSA\"" };
    for (size_t i = 0; i < sizeof(testcase_alg_public) / sizeof(testcase_alg_public[0]); i++) {
        CHECK_JSON_SIMPLE(TPMI_ALG_PUBLIC, testcase_alg_public[i], expected_alg_public);
    }
}

int
main(int argc, char *argv[])
{
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(check_tpmjson_tofromtxt),
        cmocka_unit_test(check_json_structs),
        cmocka_unit_test(check_json_constants),
        cmocka_unit_test(check_json_numbers),
        cmocka_unit_test(check_json_bits),
        cmocka_unit_test(check_json_tpm2bs),
        cmocka_unit_test(check_json_to_bin),
        cmocka_unit_test(check_bin),
        cmocka_unit_test(check_policy_bin),
        cmocka_unit_test(check_error),
        cmocka_unit_test(check_json_policy),
    };
    return cmocka_run_group_tests(tests, NULL, NULL);
}