#include <threads.h>
#include <string.h>

extern mtx_t lock1;
extern mtx_t lock2;
extern thrd_t thread1;
extern thrd_t thread2;

/* CodeSonar factory settings include the following configuration rules.
 * OPAQUE_TYPE_NONCOPYABLE_REGEXES += ^(cnd_t|mtx_t)$
 * OPAQUE_TYPE_COPYABLE_REGEXES += ^(thrd_t|tss_t)$
 *
 * - Values of type mtx_t are treated as opaque and uncopyable.
 * - Values of type thread_t are treated as opaque but copyable.
 */

int same_thread(void){
    return thread1 == thread2;             /* 'Encapsulation Violation' warning issued here
                                            * - thread_t treated as opaque, so cannot be compared with ==
                                            * - resolve by using thrd_equal() instead
                                            */
}

void copy_opaques(void){
    lock1 = lock2;                         /* 'Encapsulation Violation' warning issued here
                                            *  - mtx_t is not copyable */
    thread1 = thread2;                                 /* ok: thrd_t is copyable */
}


extern void my_voidptr_fn(void *v);                    /* a user function without a CodeSonar library model */

void * my_thread_fn(mtx_t m,               /* 'Encapsulation Violation' warning issued here
                                            * - the actual parameter is implicitly copied at call time, but mtx_t is not copyable.
                                            * There are two options to resolve this.
                                            * - Define a CodeSonar library model for my_thread_fn.
                                            * - Adjust my_thread_fn so that the first parameter is mtx_t* rather than mtx_t.
                                            */
                 mtx_t *mptr,                          /* ok: mtx_t* rather than mtx_t */
                 thrd_t t                              /* ok: thrd_t is copyable */
                 ){
    if (!mptr) {return NULL;}
    my_voidptr_fn(mptr);                              /* ok: my_voidptr_fn() expects void* argument rather than mtx_t*,
                                                       * but is not a library function
                                                       */
    mtx_lock(mptr);                                   /* ok: mtx_lock() is a library function and expects a mtx_t* */
    mtx_unlock(mptr);                                 /* ok: mtx_unlock() is a library function and expects a mtx_t* */

    return memset(mptr, 0, sizeof(mtx_t)); /* 'Encapsulation Violation' warning issued here
                                            * - memset() expects void* first argument rather than mtx_t*, and is a library function
                                            */
}