test/threadstest.c:87: error: MEMORY_LEAK
  memory dynamically allocated by call to `CRYPTO_THREAD_lock_new()` at line 85, column 27 is not reachable after line 87, column 10.
Showing all 36 steps of the trace


test/threadstest.c:83:1: start of procedure test_lock()
81.   #endif
82.   
83. > static int test_lock(void)
84.   {
85.       CRYPTO_RWLOCK *lock = CRYPTO_THREAD_lock_new();

test/threadstest.c:85:5: 
83.   static int test_lock(void)
84.   {
85. >     CRYPTO_RWLOCK *lock = CRYPTO_THREAD_lock_new();
86.   
87.       if (!TEST_true(CRYPTO_THREAD_read_lock(lock))

crypto/threads_pthread.c:19:1: start of procedure CRYPTO_THREAD_lock_new()
  17.   # endif
  18.   
  19. > CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void)
  20.   {
  21.   # ifdef USE_RWLOCK

crypto/threads_pthread.c:22:5: 
  20.   {
  21.   # ifdef USE_RWLOCK
  22. >     CRYPTO_RWLOCK *lock = OPENSSL_zalloc(sizeof(pthread_rwlock_t));
  23.       if (lock == NULL)
  24.           return NULL;

crypto/mem.c:197:1: start of procedure CRYPTO_zalloc()
    195.   }
    196.   
    197. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
    198.   {
    199.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:199:5: 
    197.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
    198.   {
    199. >     void *ret = CRYPTO_malloc(num, file, line);
    200.   
    201.       FAILTEST();

crypto/mem.c:169:1: start of procedure CRYPTO_malloc()
      167.   #endif
      168.   
      169. > void *CRYPTO_malloc(size_t num, const char *file, int line)
      170.   {
      171.       void *ret = NULL;

crypto/mem.c:171:5: 
      169.   void *CRYPTO_malloc(size_t num, const char *file, int line)
      170.   {
      171. >     void *ret = NULL;
      172.   
      173.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)

crypto/mem.c:173:9: Taking false branch
      171.       void *ret = NULL;
      172.   
      173.       if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)
                     ^
      174.           return malloc_impl(num, file, line);
      175.   

crypto/mem.c:176:9: Taking false branch
      174.           return malloc_impl(num, file, line);
      175.   
      176.       if (num == 0)
                     ^
      177.           return NULL;
      178.   

crypto/mem.c:180:5: 
      178.   
      179.       FAILTEST();
      180. >     allow_customize = 0;
      181.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
      182.       if (call_malloc_debug) {

crypto/mem.c:190:5: 
      188.       }
      189.   #else
      190. >     (void)(file); (void)(line);
      191.       ret = malloc(num);
      192.   #endif

crypto/mem.c:190:19: 
      188.       }
      189.   #else
      190. >     (void)(file); (void)(line);
      191.       ret = malloc(num);
      192.   #endif

crypto/mem.c:191:5: 
      189.   #else
      190.       (void)(file); (void)(line);
      191. >     ret = malloc(num);
      192.   #endif
      193.   

crypto/mem.c:194:5: 
      192.   #endif
      193.   
      194. >     return ret;
      195.   }
      196.   

crypto/mem.c:195:1: return from a call to CRYPTO_malloc
      193.   
      194.       return ret;
      195. > }
      196.   
      197.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:202:9: Taking true branch
    200.   
    201.       FAILTEST();
    202.       if (ret != NULL)
                   ^
    203.           memset(ret, 0, num);
    204.       return ret;

crypto/mem.c:203:9: 
    201.       FAILTEST();
    202.       if (ret != NULL)
    203. >         memset(ret, 0, num);
    204.       return ret;
    205.   }

crypto/mem.c:204:5: 
    202.       if (ret != NULL)
    203.           memset(ret, 0, num);
    204. >     return ret;
    205.   }
    206.   

crypto/mem.c:205:1: return from a call to CRYPTO_zalloc
    203.           memset(ret, 0, num);
    204.       return ret;
    205. > }
    206.   
    207.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/threads_pthread.c:23:9: Taking false branch
  21.   # ifdef USE_RWLOCK
  22.       CRYPTO_RWLOCK *lock = OPENSSL_zalloc(sizeof(pthread_rwlock_t));
  23.       if (lock == NULL)
                ^
  24.           return NULL;
  25.   

crypto/threads_pthread.c:26:9: Taking false branch
  24.           return NULL;
  25.   
  26.       if (pthread_rwlock_init(lock, NULL) != 0) {
                ^
  27.           OPENSSL_free(lock);
  28.           return NULL;

crypto/threads_pthread.c:48:5: 
  46.   # endif
  47.   
  48. >     return lock;
  49.   }
  50.   

crypto/threads_pthread.c:49:1: return from a call to CRYPTO_THREAD_lock_new
  47.   
  48.       return lock;
  49. > }
  50.   
  51.   int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock)

test/threadstest.c:87:10: 
85.       CRYPTO_RWLOCK *lock = CRYPTO_THREAD_lock_new();
86.   
87. >     if (!TEST_true(CRYPTO_THREAD_read_lock(lock))
88.           || !TEST_true(CRYPTO_THREAD_unlock(lock)))
89.           return 0;

crypto/threads_pthread.c:51:1: start of procedure CRYPTO_THREAD_read_lock()
  49.   }
  50.   
  51. > int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock)
  52.   {
  53.   # ifdef USE_RWLOCK

crypto/threads_pthread.c:54:9: Taking true branch
  52.   {
  53.   # ifdef USE_RWLOCK
  54.       if (pthread_rwlock_rdlock(lock) != 0)
                ^
  55.           return 0;
  56.   # else

crypto/threads_pthread.c:55:9: 
  53.   # ifdef USE_RWLOCK
  54.       if (pthread_rwlock_rdlock(lock) != 0)
  55. >         return 0;
  56.   # else
  57.       if (pthread_mutex_lock(lock) != 0)

crypto/threads_pthread.c:62:1: return from a call to CRYPTO_THREAD_read_lock
  60.   
  61.       return 1;
  62. > }
  63.   
  64.   int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock)

test/threadstest.c:87:10: Condition is false
85.       CRYPTO_RWLOCK *lock = CRYPTO_THREAD_lock_new();
86.   
87.       if (!TEST_true(CRYPTO_THREAD_read_lock(lock))
               ^
88.           || !TEST_true(CRYPTO_THREAD_unlock(lock)))
89.           return 0;

test/testutil/tests.c:235:1: start of procedure test_true()
  233.   }
  234.   
  235. > int test_true(const char *file, int line, const char *s, int b)
  236.   {
  237.       if (b)

test/testutil/tests.c:237:9: Taking false branch
  235.   int test_true(const char *file, int line, const char *s, int b)
  236.   {
  237.       if (b)
                 ^
  238.           return 1;
  239.       test_fail_message(NULL, file, line, "bool", s, "true", "==", "false");

test/testutil/tests.c:239:5: Skipping test_fail_message(): empty list of specs
  237.       if (b)
  238.           return 1;
  239.       test_fail_message(NULL, file, line, "bool", s, "true", "==", "false");
             ^
  240.       return 0;
  241.   }

test/testutil/tests.c:240:5: 
  238.           return 1;
  239.       test_fail_message(NULL, file, line, "bool", s, "true", "==", "false");
  240. >     return 0;
  241.   }
  242.   

test/testutil/tests.c:241:1: return from a call to test_true
  239.       test_fail_message(NULL, file, line, "bool", s, "true", "==", "false");
  240.       return 0;
  241. > }
  242.   
  243.   int test_false(const char *file, int line, const char *s, int b)

test/threadstest.c:87:10: Taking true branch
85.       CRYPTO_RWLOCK *lock = CRYPTO_THREAD_lock_new();
86.   
87.       if (!TEST_true(CRYPTO_THREAD_read_lock(lock))
               ^
88.           || !TEST_true(CRYPTO_THREAD_unlock(lock)))
89.           return 0;
