Improve zlib error messages and update test suite to fit

OTP-14527

5 files changed, 274 insertions, 230 deletions

diff --git a/erts/doc/src/zlib.xml b/erts/doc/src/zlib.xml
index 9c3e97d814..f5cc1b1e64 100644
--- a/erts/doc/src/zlib.xml
+++ b/erts/doc/src/zlib.xml
@@ -65,13 +65,17 @@ list_to_binary([Compressed|Last])</pre>
       <tag><c>badarg</c></tag>
       <item>Bad argument.
       </item>
+      <tag><c>not_initialized</c></tag>
+      <item>The stream hasn't been initialized, eg. if
+      <seealso marker="#inflateInit/1"><c>inflateInit/1</c></seealso> wasn't
+      called prior to a call to
+      <seealso marker="#inflate/2"><c>inflate/2</c></seealso>.
+      </item>
       <tag><c>data_error</c></tag>
       <item>The data contains errors.
       </item>
       <tag><c>stream_error</c></tag>
       <item>Inconsistent stream state.</item>
-      <tag><c>einval</c></tag>
-      <item>Bad value or wrong function called.</item>
       <tag><c>{need_dictionary,Adler32}</c></tag>
       <item>See <seealso marker="#inflate/2"><c>inflate/2</c></seealso>.
       </item>
diff --git a/erts/emulator/nifs/common/zlib_nif.c b/erts/emulator/nifs/common/zlib_nif.c
index cffb3f3f63..b7f3adaffe 100644
--- a/erts/emulator/nifs/common/zlib_nif.c
+++ b/erts/emulator/nifs/common/zlib_nif.c
@@ -48,13 +48,22 @@ static void unload(ErlNifEnv *env, void* priv_data);
 
 static ErlNifResourceType *rtype_zlib;
 
+static ERL_NIF_TERM am_not_on_controlling_process;
+
+static ERL_NIF_TERM am_not_initialized;
+static ERL_NIF_TERM am_already_initialized;
+
 static ERL_NIF_TERM am_ok;
 static ERL_NIF_TERM am_error;
+
 static ERL_NIF_TERM am_continue;
 static ERL_NIF_TERM am_finished;
-static ERL_NIF_TERM am_empty;
+
 static ERL_NIF_TERM am_not_supported;
 static ERL_NIF_TERM am_need_dictionary;
+
+static ERL_NIF_TERM am_empty;
+
 static ERL_NIF_TERM am_stream_end;
 static ERL_NIF_TERM am_stream_error;
 static ERL_NIF_TERM am_data_error;
@@ -173,13 +182,23 @@ static void gc_zlib(ErlNifEnv *env, void* data);
 
 static int load(ErlNifEnv *env, void** priv_data, ERL_NIF_TERM load_info)
 {
+    am_not_on_controlling_process =
+        enif_make_atom(env, "not_on_controlling_process");
+
+    am_not_initialized = enif_make_atom(env, "not_initialized");
+    am_already_initialized = enif_make_atom(env, "already_initialized");
+
     am_ok = enif_make_atom(env, "ok");
     am_error = enif_make_atom(env, "error");
-    am_empty = enif_make_atom(env, "empty");
+
     am_continue = enif_make_atom(env, "continue");
     am_finished = enif_make_atom(env, "finished");
-    am_need_dictionary = enif_make_atom(env, "need_dictionary");
+
     am_not_supported = enif_make_atom(env, "not_supported");
+    am_need_dictionary = enif_make_atom(env, "need_dictionary");
+
+    am_empty = enif_make_atom(env, "empty");
+
     am_stream_end = enif_make_atom(env, "stream_end");
     am_stream_error = enif_make_atom(env, "stream_error");
     am_data_error = enif_make_atom(env, "data_error");
@@ -235,14 +254,11 @@ static ERL_NIF_TERM zlib_return(ErlNifEnv *env, int code) {
         break;
     case Z_ERRNO:
         reason = enif_make_int(env, errno);
-        //enif_make_tuple2(env, enif_make_int(env, err), reason);
         break;
     case Z_STREAM_ERROR:
-        //reason = am_stream_error;
         reason = enif_raise_exception(env, am_stream_error);
         break;
     case Z_DATA_ERROR:
-        //reason = am_data_error;
         reason = enif_raise_exception(env, am_data_error);
         break;
     case Z_MEM_ERROR:
@@ -281,6 +297,19 @@ static void gc_zlib(ErlNifEnv *env, void* data) {
     }
 }
 
+static int get_zlib_data(ErlNifEnv *env, ERL_NIF_TERM opaque, zlib_data_t **d) {
+    return enif_get_resource(env, opaque, rtype_zlib, (void **)d);
+}
+
+static int zlib_process_check(ErlNifEnv *env, zlib_data_t *d) {
+    ErlNifPid current_process;
+
+    enif_self(env, &current_process);
+
+    return enif_is_identical(enif_make_pid(env, &current_process),
+        enif_make_pid(env, &d->controlling_process));
+}
+
 static void zlib_reset_input(zlib_data_t *d) {
     enif_ioq_destroy(d->input_queue);
     d->input_queue = enif_ioq_create(ERL_NIF_IOQ_NORMAL);
@@ -292,19 +321,6 @@ static void zlib_reset_input(zlib_data_t *d) {
     }
 }
 
-static int get_zlib_data(ErlNifEnv* env, ERL_NIF_TERM opaque, zlib_data_t **d) {
-    ErlNifPid current_process;
-
-    if(!enif_get_resource(env, opaque, rtype_zlib, (void **)d)) {
-        return 0;
-    }
-
-    enif_self(env, &current_process);
-
-    return enif_is_identical(enif_make_pid(env, &current_process),
-        enif_make_pid(env, &(*d)->controlling_process));
-}
-
 static int zlib_flush_queue(int (*codec)(z_stream*, int), ErlNifEnv *env,
         zlib_data_t *d, size_t input_limit, ErlNifBinary *output_buffer, int flush,
         size_t *bytes_produced, size_t *bytes_consumed, size_t *bytes_remaining) {
@@ -438,6 +454,8 @@ static ERL_NIF_TERM zlib_getStash(ErlNifEnv *env, int argc, const ERL_NIF_TERM a
 
     if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
         return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
     }
 
     if(d->stash_env == NULL) {
@@ -452,10 +470,10 @@ static ERL_NIF_TERM zlib_clearStash(ErlNifEnv *env, int argc, const ERL_NIF_TERM
 
     if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->stash_env == NULL) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->stash_env == NULL) {
+        return enif_raise_exception(env, am_error);
     }
 
     enif_free_env(d->stash_env);
@@ -470,10 +488,10 @@ static ERL_NIF_TERM zlib_setStash(ErlNifEnv *env, int argc, const ERL_NIF_TERM a
 
     if(argc != 2 || !get_zlib_data(env, argv[0], &d)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->stash_env != NULL) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->stash_env != NULL) {
+        return enif_raise_exception(env, am_error);
     }
 
     d->stash_env = enif_alloc_env();
@@ -526,10 +544,10 @@ static ERL_NIF_TERM zlib_close(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv
     /* strictly speaking not needed since the gc will handle this */
     if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state == ST_CLOSED) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state == ST_CLOSED) {
+        return enif_raise_exception(env, am_not_initialized);
     }
 
     gc_zlib(env, d);
@@ -546,10 +564,10 @@ static ERL_NIF_TERM zlib_deflateInit(ErlNifEnv *env, int argc, const ERL_NIF_TER
     if(argc != 2 || !get_zlib_data(env, argv[0], &d) ||
                     !enif_get_int(env, argv[1], &level)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state != ST_NONE) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_NONE) {
+        return enif_raise_exception(env, am_already_initialized);
     }
 
     res = deflateInit(&d->s, level);
@@ -586,10 +604,10 @@ static ERL_NIF_TERM zlib_deflateInit2(ErlNifEnv *env, int argc, const ERL_NIF_TE
                  || !enif_get_int(env, argv[4], &memLevel)
                  || !enif_get_int(env, argv[5], &strategy)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state != ST_NONE) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_NONE) {
+        return enif_raise_exception(env, am_already_initialized);
     }
 
     res = deflateInit2(&d->s, level, method, windowBits, memLevel, strategy);
@@ -618,10 +636,10 @@ static ERL_NIF_TERM zlib_deflateSetDictionary(ErlNifEnv *env, int argc, const ER
     if(argc != 2 || !get_zlib_data(env, argv[0], &d)
                  || !enif_inspect_iolist_as_binary(env, argv[1], &bin)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state != ST_DEFLATE) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_DEFLATE) {
+        return enif_raise_exception(env, am_not_initialized);
     }
 
     if((res = deflateSetDictionary(&d->s, bin.data, bin.size)) == Z_OK) {
@@ -645,10 +663,10 @@ static ERL_NIF_TERM zlib_deflateReset(ErlNifEnv *env, int argc, const ERL_NIF_TE
 
     if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state != ST_DEFLATE) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_DEFLATE) {
+        return enif_raise_exception(env, am_not_initialized);
     }
 
     res = deflateReset(&d->s);
@@ -667,10 +685,10 @@ static ERL_NIF_TERM zlib_deflateEnd(ErlNifEnv *env, int argc, const ERL_NIF_TERM
 
     if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state != ST_DEFLATE) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_DEFLATE) {
+        return enif_raise_exception(env, am_not_initialized);
     }
 
     res = deflateEnd(&d->s);
@@ -693,10 +711,10 @@ static ERL_NIF_TERM zlib_deflateParams(ErlNifEnv *env, int argc, const ERL_NIF_T
                  || !enif_get_int(env, argv[1], &level)
                  || !enif_get_int(env, argv[2], &strategy)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state != ST_DEFLATE) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_DEFLATE) {
+        return enif_raise_exception(env, am_not_initialized);
     }
 
     /* deflateParams will flush everything currently in the stream, corrupting
@@ -718,10 +736,10 @@ static ERL_NIF_TERM zlib_deflate(ErlNifEnv *env, int argc, const ERL_NIF_TERM ar
                  || !enif_get_int(env, argv[2], &output_chunk_size)
                  || !enif_get_int(env, argv[3], &flush)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state != ST_DEFLATE) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_DEFLATE) {
+        return enif_raise_exception(env, am_not_initialized);
     }
 
     return zlib_codec(&deflate, env, d, input_chunk_size, output_chunk_size, flush);
@@ -735,10 +753,10 @@ static ERL_NIF_TERM zlib_inflateInit(ErlNifEnv *env, int argc, const ERL_NIF_TER
 
     if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state != ST_NONE) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_NONE) {
+        return enif_raise_exception(env, am_already_initialized);
     }
 
     res = inflateInit(&d->s);
@@ -765,10 +783,10 @@ static ERL_NIF_TERM zlib_inflateInit2(ErlNifEnv *env, int argc, const ERL_NIF_TE
     if(argc != 2 || !get_zlib_data(env, argv[0], &d)
                  || !enif_get_int(env, argv[1], &windowBits)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state != ST_NONE) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_NONE) {
+        return enif_raise_exception(env, am_already_initialized);
     }
 
     res = inflateInit2(&d->s, windowBits);
@@ -797,10 +815,10 @@ static ERL_NIF_TERM zlib_inflateSetDictionary(ErlNifEnv *env, int argc, const ER
     if(argc != 2 || !get_zlib_data(env, argv[0], &d)
                  || !enif_inspect_iolist_as_binary(env, argv[1], &bin)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state != ST_INFLATE) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_INFLATE) {
+        return enif_raise_exception(env, am_not_initialized);
     }
 
     res = inflateSetDictionary(&d->s, bin.data, bin.size);
@@ -827,55 +845,51 @@ static int zlib_supports_inflateGetDictionary(void) {
 
     return supportsGetDictionary;
 }
+#endif
 
 static ERL_NIF_TERM zlib_inflateGetDictionary(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
     zlib_data_t *d;
-    ErlNifBinary obin;
-    uInt len;
-    int res;
 
     if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
         return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_INFLATE) {
+        return enif_raise_exception(env, am_not_initialized);
     }
 
-    if(d->state != ST_INFLATE) {
-        return enif_make_badarg(env);
-    }
+#ifdef HAVE_ZLIB_INFLATEGETDICTIONARY
+    if(zlib_supports_inflateGetDictionary()) {
+        ErlNifBinary obin;
+        uInt len;
+        int res;
 
-    if(!zlib_supports_inflateGetDictionary()) {
-        return enif_make_badarg(env);
-    }
+        enif_alloc_binary(INFL_DICT_SZ, &obin);
+        len = 0;
 
-    enif_alloc_binary(INFL_DICT_SZ, &obin);
+        if((res = inflateGetDictionary(&d->s, obin.data, &len)) < 0) {
+            enif_release_binary(&obin);
+            return zlib_return(env, res);
+        }
 
-    len = 0;
-    if((res = inflateGetDictionary(&d->s, obin.data, &len)) < 0) {
-        enif_release_binary(&obin);
-        return zlib_return(env, res);
+        enif_realloc_binary(&obin, (size_t)len);
+        return enif_make_binary(env, &obin);
     }
+#endif
 
-    enif_realloc_binary(&obin, (size_t)len);
-    return enif_make_binary(env, &obin);
-}
-
-#else /* !HAVE_ZLIB_INFLATEGETDICTIONARY */
-
-static ERL_NIF_TERM zlib_inflateGetDictionary(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
-    return enif_make_badarg(env);
+    return enif_raise_exception(env, am_not_supported);
 }
 
-#endif
-
 static ERL_NIF_TERM zlib_inflateReset(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
     zlib_data_t *d;
     int res;
 
     if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state != ST_INFLATE) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_INFLATE) {
+        return enif_raise_exception(env, am_not_initialized);
     }
 
     res = inflateReset(&d->s);
@@ -894,10 +908,10 @@ static ERL_NIF_TERM zlib_inflateEnd(ErlNifEnv *env, int argc, const ERL_NIF_TERM
 
     if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state != ST_INFLATE) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_INFLATE) {
+        return enif_raise_exception(env, am_not_initialized);
     }
 
     res = inflateEnd(&d->s);
@@ -922,10 +936,10 @@ static ERL_NIF_TERM zlib_inflate(ErlNifEnv *env, int argc, const ERL_NIF_TERM ar
                  || !enif_get_int(env, argv[2], &output_chunk_size)
                  || !enif_get_int(env, argv[3], &flush)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state != ST_INFLATE) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_INFLATE) {
+        return enif_raise_exception(env, am_not_initialized);
     }
 
     return zlib_codec(&inflate, env, d, input_chunk_size, output_chunk_size, flush);
@@ -936,6 +950,8 @@ static ERL_NIF_TERM zlib_crc32(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv
 
     if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
         return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
     }
 
     if(d->state == ST_DEFLATE) {
@@ -944,7 +960,7 @@ static ERL_NIF_TERM zlib_crc32(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv
         return enif_make_ulong(env, d->output_crc);
     }
 
-    return enif_make_badarg(env);
+    return enif_raise_exception(env, am_not_initialized);
 }
 
 static ERL_NIF_TERM zlib_getBufSize(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
@@ -952,6 +968,8 @@ static ERL_NIF_TERM zlib_getBufSize(ErlNifEnv *env, int argc, const ERL_NIF_TERM
 
     if(argc != 1 || !get_zlib_data(env, argv[0], &d)) {
         return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
     }
 
     return enif_make_int(env, d->inflateChunk_buffer_size);
@@ -960,8 +978,13 @@ static ERL_NIF_TERM zlib_getBufSize(ErlNifEnv *env, int argc, const ERL_NIF_TERM
 static ERL_NIF_TERM zlib_setBufSize(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
     zlib_data_t *d;
 
-    if(argc != 2 || !get_zlib_data(env, argv[0], &d)
-                 || !enif_get_int(env, argv[1], &d->inflateChunk_buffer_size)) {
+    if(argc != 2 || !get_zlib_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    }
+
+    if(!enif_get_int(env, argv[1], &d->inflateChunk_buffer_size)) {
         return enif_make_badarg(env);
     }
 
@@ -976,17 +999,15 @@ static ERL_NIF_TERM zlib_enqueue_input(ErlNifEnv *env, int argc, const ERL_NIF_T
 
     if(argc != 2 || !get_zlib_data(env, argv[0], &d)) {
         return enif_make_badarg(env);
-    }
-
-    if(d->state != ST_DEFLATE && d->state != ST_INFLATE) {
-        return enif_make_badarg(env);
+    } else if(!zlib_process_check(env, d)) {
+        return enif_raise_exception(env, am_not_on_controlling_process);
+    } else if(d->state != ST_DEFLATE && d->state != ST_INFLATE) {
+        return enif_raise_exception(env, am_not_initialized);
     }
 
     if(!enif_inspect_iovec(env, 256, argv[1], &tail, &iovec)) {
         return enif_make_badarg(env);
-    }
-
-    if(!enif_ioq_enqv(d->input_queue, iovec, 0)) {
+    } else if(!enif_ioq_enqv(d->input_queue, iovec, 0)) {
         return enif_make_badarg(env);
     }
 
diff --git a/erts/preloaded/ebin/zlib.beam b/erts/preloaded/ebin/zlib.beam
index 173020b00d..267b5cb0a8 100644
--- a/erts/preloaded/ebin/zlib.beam
+++ b/erts/preloaded/ebin/zlib.beam
diff --git a/erts/preloaded/src/zlib.erl b/erts/preloaded/src/zlib.erl
index 2731dddcb5..dca5a42779 100644
--- a/erts/preloaded/src/zlib.erl
+++ b/erts/preloaded/src/zlib.erl
@@ -634,34 +634,34 @@ arg_flush(none)   -> ?Z_NO_FLUSH;
 arg_flush(sync)   -> ?Z_SYNC_FLUSH;
 arg_flush(full)   -> ?Z_FULL_FLUSH;
 arg_flush(finish) -> ?Z_FINISH;
-arg_flush(_) -> erlang:error(badarg).
+arg_flush(_) -> erlang:error(bad_flush_mode).
 
 arg_level(none)             -> ?Z_NO_COMPRESSION;
 arg_level(best_speed)       -> ?Z_BEST_SPEED;
 arg_level(best_compression) -> ?Z_BEST_COMPRESSION;
 arg_level(default)          -> ?Z_DEFAULT_COMPRESSION;
 arg_level(Level) when is_integer(Level), Level >= 0, Level =< 9 -> Level;
-arg_level(_) -> erlang:error(badarg).
+arg_level(_) -> erlang:error(bad_compression_level).
 
 arg_strategy(filtered) ->     ?Z_FILTERED;
 arg_strategy(huffman_only) -> ?Z_HUFFMAN_ONLY;
 arg_strategy(rle) -> ?Z_RLE;
 arg_strategy(default) ->      ?Z_DEFAULT_STRATEGY;
-arg_strategy(_) -> erlang:error(badarg).
+arg_strategy(_) -> erlang:error(bad_compression_strategy).
 
 arg_method(deflated) -> ?Z_DEFLATED;
-arg_method(_) -> erlang:error(badarg).
+arg_method(_) -> erlang:error(bad_compression_method).
 
 -spec arg_bitsz(zwindowbits()) -> zwindowbits().
 arg_bitsz(Bits) when is_integer(Bits) andalso
                      ((8 =< Bits andalso Bits < 48) orelse
                       (-15 =< Bits andalso Bits =< -8)) ->
     Bits;
-arg_bitsz(_) -> erlang:error(badarg).
+arg_bitsz(_) -> erlang:error(bad_windowbits).
 
 -spec arg_mem(zmemlevel()) -> zmemlevel().
 arg_mem(Level) when is_integer(Level), 1 =< Level, Level =< 9 -> Level;
-arg_mem(_) -> erlang:error(badarg).
+arg_mem(_) -> erlang:error(bad_memlevel).
 
 -spec enqueue_input(Z, IOData) -> ok when
       Z :: zstream(),
@@ -669,6 +669,8 @@ arg_mem(_) -> erlang:error(badarg).
 enqueue_input(Z, IOData) ->
     enqueue_input_1(Z, erlang:iolist_to_iovec(IOData)).
 
+enqueue_input_1(_Z, []) ->
+    ok;
 enqueue_input_1(Z, IOVec) ->
     case enqueue_nif(Z, IOVec) of
         {continue, Remainder} -> enqueue_input_1(Z, Remainder);
diff --git a/lib/kernel/test/zlib_SUITE.erl b/lib/kernel/test/zlib_SUITE.erl
index efbbc805a0..6a91523ea1 100644
--- a/lib/kernel/test/zlib_SUITE.erl
+++ b/lib/kernel/test/zlib_SUITE.erl
@@ -44,8 +44,7 @@
 		end
 	end()).
 
--define(BARG, {'EXIT',{badarg,[{_,_,_,_}|_]}}).
--define(DATA_ERROR, {'EXIT',{data_error,[{zlib,_,_,_}|_]}}).
+-define(EXIT(Reason), {'EXIT',{Reason,[{_,_,_,_}|_]}}).
 
 init_per_testcase(_Func, Config) ->
     Config.
@@ -120,7 +119,7 @@ api_open_close(Config) when is_list(Config) ->
     Fd2 = zlib:open(),
     ?m(false,Fd1 == Fd2),
     ?m(ok,zlib:close(Fd1)),
-    ?m(?BARG, zlib:close(Fd1)),
+    ?m(?EXIT(not_initialized), zlib:close(Fd1)),
     ?m(ok,zlib:close(Fd2)),
 
     %% Make sure that we don't get any EXIT messages if trap_exit is enabled.
@@ -135,9 +134,11 @@ api_open_close(Config) when is_list(Config) ->
 %% Test deflateInit/2 and /6.
 api_deflateInit(Config) when is_list(Config) ->
     Z1 = zlib:open(),
-    ?m(?BARG, zlib:deflateInit(gurka, none)),
-    ?m(?BARG, zlib:deflateInit(gurka, gurka)),
-    ?m(?BARG, zlib:deflateInit(Z1, gurka)),
+
+    ?m(?EXIT(badarg), zlib:deflateInit(gurka, none)),
+
+    ?m(?EXIT(bad_compression_level), zlib:deflateInit(gurka, gurka)),
+    ?m(?EXIT(bad_compression_level), zlib:deflateInit(Z1, gurka)),
     Levels = [none, default, best_speed, best_compression] ++ lists:seq(0,9),
     lists:foreach(fun(Level) ->
 			  Z = zlib:open(),
@@ -145,20 +146,30 @@ api_deflateInit(Config) when is_list(Config) ->
 			  ?m(ok,zlib:close(Z))
 		  end, Levels),
     %% /6
-    ?m(?BARG, zlib:deflateInit(Z1,gurka,deflated,-15,8,default)),
-
-    ?m(?BARG, zlib:deflateInit(Z1,default,undefined,-15,8,default)),
-
-    ?m(?BARG, zlib:deflateInit(Z1,default,deflated,48,8,default)),
-    ?m(?BARG, zlib:deflateInit(Z1,default,deflated,-20,8,default)),
-    ?m(?BARG, zlib:deflateInit(Z1,default,deflated,-7,8,default)),
-    ?m(?BARG, zlib:deflateInit(Z1,default,deflated,7,8,default)),
-
-    ?m(?BARG, zlib:deflateInit(Z1,default,deflated,-15,0,default)),
-    ?m(?BARG, zlib:deflateInit(Z1,default,deflated,-15,10,default)),    
-
-    ?m(?BARG, zlib:deflateInit(Z1,default,deflated,-15,8,0)),
-    ?m(?BARG, zlib:deflateInit(Z1,default,deflated,-15,8,undefined)),
+    ?m(?EXIT(bad_compression_level),
+        zlib:deflateInit(Z1,gurka,deflated,-15,8,default)),
+
+    ?m(?EXIT(bad_compression_method),
+        zlib:deflateInit(Z1,default,undefined,-15,8,default)),
+
+    ?m(?EXIT(bad_compression_strategy),
+        zlib:deflateInit(Z1,default,deflated,-15,8,0)),
+    ?m(?EXIT(bad_compression_strategy),
+        zlib:deflateInit(Z1,default,deflated,-15,8,undefined)),
+
+    ?m(?EXIT(bad_windowbits),
+        zlib:deflateInit(Z1,default,deflated,48,8,default)),
+    ?m(?EXIT(bad_windowbits),
+        zlib:deflateInit(Z1,default,deflated,-20,8,default)),
+    ?m(?EXIT(bad_windowbits),
+        zlib:deflateInit(Z1,default,deflated,-7,8,default)),
+    ?m(?EXIT(bad_windowbits),
+        zlib:deflateInit(Z1,default,deflated,7,8,default)),
+
+    ?m(?EXIT(bad_memlevel),
+        zlib:deflateInit(Z1,default,deflated,-15,0,default)),
+    ?m(?EXIT(bad_memlevel),
+        zlib:deflateInit(Z1,default,deflated,-15,10,default)),
 
     lists:foreach(fun(Level) ->
 			  Z = zlib:open(),
@@ -190,7 +201,11 @@ api_deflateInit(Config) when is_list(Config) ->
 			  ?m(ok,zlib:close(Z))
 		  end, Strategies),
     ?m(ok, zlib:deflateInit(Z1,default,deflated,-15,8,default)),
-    ?m({'EXIT',_}, zlib:deflateInit(Z1,none,deflated,-15,8,default)), %% ?? 
+
+    %% Let it crash for any reason; we don't care about the order in which the
+    %% parameters are checked.
+    ?m(?EXIT(_), zlib:deflateInit(Z1,none,deflated,-15,8,default)),
+
     ?m(ok, zlib:close(Z1)).
 
 %% Test deflateSetDictionary.
@@ -199,10 +214,10 @@ api_deflateSetDictionary(Config) when is_list(Config) ->
     ?m(ok, zlib:deflateInit(Z1, default)),
     ?m(Id when is_integer(Id), zlib:deflateSetDictionary(Z1, <<1,1,2,3,4,5,1>>)),
     ?m(Id when is_integer(Id), zlib:deflateSetDictionary(Z1, [1,1,2,3,4,5,1])),
-    ?m(?BARG, zlib:deflateSetDictionary(Z1, gurka)),
-    ?m(?BARG, zlib:deflateSetDictionary(Z1, 128)),
+    ?m(?EXIT(badarg), zlib:deflateSetDictionary(Z1, gurka)),
+    ?m(?EXIT(badarg), zlib:deflateSetDictionary(Z1, 128)),
     ?m(_, zlib:deflate(Z1, <<1,1,1,1,1,1,1,1,1>>, none)),
-    ?m({'EXIT',{stream_error,_}},zlib:deflateSetDictionary(Z1,<<1,1,2,3,4,5,1>>)),
+    ?m(?EXIT(stream_error), zlib:deflateSetDictionary(Z1,<<1,1,2,3,4,5,1>>)),
     ?m(ok, zlib:close(Z1)).
 
 %% Test deflateReset.
@@ -238,11 +253,13 @@ api_deflate(Config) when is_list(Config) ->
     ?m(B when is_list(B), zlib:deflate(Z1, <<1,1,1,1,1,1,1,1,1>>, full)),
     ?m(B when is_list(B), zlib:deflate(Z1, <<>>, finish)),
 
-    ?m(?BARG, zlib:deflate(gurka, <<1,1,1,1,1,1,1,1,1>>, full)),
-    ?m(?BARG, zlib:deflate(Z1, <<1,1,1,1,1,1,1,1,1>>, asdj)),
-    ?m(?BARG, zlib:deflate(Z1, <<1,1,1,1,1,1,1,1,1>>, 198)),
+    ?m(?EXIT(badarg), zlib:deflate(gurka, <<1,1,1,1,1,1,1,1,1>>, full)),
+
+    ?m(?EXIT(bad_flush_mode), zlib:deflate(Z1, <<1,1,1,1,1,1,1,1,1>>, asdj)),
+    ?m(?EXIT(bad_flush_mode), zlib:deflate(Z1, <<1,1,1,1,1,1,1,1,1>>, 198)),
+
     %% Causes problems ERROR REPORT
-    ?m(?BARG, zlib:deflate(Z1, [asdj,asd], none)),
+    ?m(?EXIT(badarg), zlib:deflate(Z1, [asdj,asd], none)),
 
     ?m(ok, zlib:close(Z1)).
 
@@ -251,11 +268,11 @@ api_deflateEnd(Config) when is_list(Config) ->
     Z1 = zlib:open(),
     ?m(ok, zlib:deflateInit(Z1, default)),
     ?m(ok, zlib:deflateEnd(Z1)),
-    ?m(?BARG, zlib:deflateEnd(Z1)),
-    ?m(?BARG, zlib:deflateEnd(gurka)),
+    ?m(?EXIT(not_initialized), zlib:deflateEnd(Z1)),
+    ?m(?EXIT(badarg), zlib:deflateEnd(gurka)),
     ?m(ok, zlib:deflateInit(Z1, default)),
     ?m(B when is_list(B), zlib:deflate(Z1, <<"Kilroy was here">>)),
-    ?m({'EXIT', {data_error,_}}, zlib:deflateEnd(Z1)),
+    ?m(?EXIT(data_error), zlib:deflateEnd(Z1)),
     ?m(ok, zlib:deflateInit(Z1, default)),
     ?m(B when is_list(B), zlib:deflate(Z1, <<"Kilroy was here">>)),
     ?m(B when is_list(B), zlib:deflate(Z1, <<"Kilroy was here">>, finish)),
@@ -266,9 +283,9 @@ api_deflateEnd(Config) when is_list(Config) ->
 %% Test inflateInit /1 and /2.
 api_inflateInit(Config) when is_list(Config) ->
     Z1 = zlib:open(),
-    ?m(?BARG, zlib:inflateInit(gurka)),
+    ?m(?EXIT(badarg), zlib:inflateInit(gurka)),
     ?m(ok, zlib:inflateInit(Z1)),
-    ?m(?BARG, zlib:inflateInit(Z1, 15)),
+    ?m(?EXIT(already_initialized), zlib:inflateInit(Z1, 15)),
     lists:foreach(fun(Wbits) ->
 			  Z11 = zlib:open(),
 			  ?m(ok, zlib:inflateInit(Z11,Wbits)),
@@ -277,22 +294,22 @@ api_inflateInit(Config) when is_list(Config) ->
 			  ?m(ok,zlib:close(Z11)),
 			  ?m(ok,zlib:close(Z12))
 		  end, lists:seq(8,15)),
-    ?m(?BARG, zlib:inflateInit(gurka, -15)),
-    ?m(?BARG, zlib:inflateInit(Z1, 7)),
-    ?m(?BARG, zlib:inflateInit(Z1, -7)),
-    ?m(?BARG, zlib:inflateInit(Z1, 48)),
-    ?m(?BARG, zlib:inflateInit(Z1, -16)),
+    ?m(?EXIT(badarg), zlib:inflateInit(gurka, -15)),
+    ?m(?EXIT(already_initialized), zlib:inflateInit(Z1, 7)),
+    ?m(?EXIT(already_initialized), zlib:inflateInit(Z1, -7)),
+    ?m(?EXIT(already_initialized), zlib:inflateInit(Z1, 48)),
+    ?m(?EXIT(already_initialized), zlib:inflateInit(Z1, -16)),
     ?m(ok, zlib:close(Z1)).
 
 %% Test inflateSetDictionary.
 api_inflateSetDictionary(Config) when is_list(Config) ->
     Z1 = zlib:open(),
     ?m(ok, zlib:inflateInit(Z1)),
-    ?m(?BARG, zlib:inflateSetDictionary(gurka,<<1,1,1,1,1>>)),
-    ?m(?BARG, zlib:inflateSetDictionary(Z1,102)),
-    ?m(?BARG, zlib:inflateSetDictionary(Z1,gurka)),
+    ?m(?EXIT(badarg), zlib:inflateSetDictionary(gurka,<<1,1,1,1,1>>)),
+    ?m(?EXIT(badarg), zlib:inflateSetDictionary(Z1,102)),
+    ?m(?EXIT(badarg), zlib:inflateSetDictionary(Z1,gurka)),
     Dict = <<1,1,1,1,1>>,
-    ?m({'EXIT',{stream_error,_}}, zlib:inflateSetDictionary(Z1,Dict)),
+    ?m(?EXIT(stream_error), zlib:inflateSetDictionary(Z1,Dict)),
     ?m(ok, zlib:close(Z1)).
 
 %% Test inflateGetDictionary.
@@ -301,7 +318,7 @@ api_inflateGetDictionary(Config) when is_list(Config) ->
     zlib:inflateInit(Z1),
     IsOperationSupported =
         case catch zlib:inflateGetDictionary(Z1) of
-            ?BARG -> false;
+            ?EXIT(not_supported) -> false;
             _ -> true
         end,
     zlib:close(Z1),
@@ -323,19 +340,19 @@ api_inflateGetDictionary_if_supported(true) ->
     Z2 = zlib:open(),
     ?m(ok, zlib:inflateInit(Z2)),
     ?m(<<>>, iolist_to_binary(zlib:inflateGetDictionary(Z2))),
-    ?m({'EXIT',{stream_error,_}}, zlib:inflateSetDictionary(Z2, Dict)),
-    ?m({'EXIT',{{need_dictionary,Checksum},_}}, zlib:inflate(Z2, Compressed)),
+    ?m(?EXIT(stream_error), zlib:inflateSetDictionary(Z2, Dict)),
+    ?m(?EXIT({need_dictionary,Checksum}), zlib:inflate(Z2, Compressed)),
     ?m(ok, zlib:inflateSetDictionary(Z2, Dict)),
     ?m(Dict, iolist_to_binary(zlib:inflateGetDictionary(Z2))),
     Payload = iolist_to_binary(zlib:inflate(Z2, [])),
     ?m(ok, zlib:close(Z2)),
-    ?m(?BARG, zlib:inflateSetDictionary(Z2, Dict)),
+    ?m(?EXIT(not_initialized), zlib:inflateSetDictionary(Z2, Dict)),
 
     %% ... And do the same for inflate/3
     Z3 = zlib:open(),
     ?m(ok, zlib:inflateInit(Z3)),
     ?m(<<>>, iolist_to_binary(zlib:inflateGetDictionary(Z3))),
-    ?m({'EXIT',{stream_error,_}}, zlib:inflateSetDictionary(Z3, Dict)),
+    ?m(?EXIT(stream_error), zlib:inflateSetDictionary(Z3, Dict)),
 
     {need_dictionary, Checksum, _Output = []} =
         zlib:inflate(Z3, Compressed, [{exception_on_need_dict, false}]),
@@ -347,7 +364,7 @@ api_inflateGetDictionary_if_supported(true) ->
         zlib:inflate(Z3, [], [{exception_on_need_dict, false}])),
 
     ?m(ok, zlib:close(Z3)),
-    ?m(?BARG, zlib:inflateSetDictionary(Z3, Dict)),
+    ?m(?EXIT(not_initialized), zlib:inflateSetDictionary(Z3, Dict)),
 
     ok.
 
@@ -363,7 +380,7 @@ clobber(N, Bin) when is_binary(Bin) ->
 api_inflateReset(Config) when is_list(Config) ->
     Z1 = zlib:open(),
     ?m(ok, zlib:inflateInit(Z1)),
-    ?m(?BARG, zlib:inflateReset(gurka)),
+    ?m(?EXIT(badarg), zlib:inflateReset(gurka)),
     ?m(ok, zlib:inflateReset(Z1)),
     ?m(ok, zlib:close(Z1)).
 
@@ -378,12 +395,12 @@ api_inflate2(Config) when is_list(Config) ->
     ?m(ok, zlib:inflateEnd(Z1)),
     ?m(ok, zlib:inflateInit(Z1)),
     ?m(Data, zlib:inflate(Z1, Compressed)),
-    ?m(?BARG, zlib:inflate(gurka, Compressed)),
-    ?m(?BARG, zlib:inflate(Z1, 4384)),
-    ?m(?BARG, zlib:inflate(Z1, [atom_list])),
+    ?m(?EXIT(badarg), zlib:inflate(gurka, Compressed)),
+    ?m(?EXIT(badarg), zlib:inflate(Z1, 4384)),
+    ?m(?EXIT(badarg), zlib:inflate(Z1, [atom_list])),
     ?m(ok, zlib:inflateEnd(Z1)),
     ?m(ok, zlib:inflateInit(Z1)),
-    ?m({'EXIT',{data_error,_}}, zlib:inflate(Z1, <<2,1,2,1,2>>)), 
+    ?m(?EXIT(data_error), zlib:inflate(Z1, <<2,1,2,1,2>>)),
     ?m(ok, zlib:close(Z1)).
 
 %% Test inflate/3; same as inflate/2 but with the default options inverted.
@@ -398,12 +415,12 @@ api_inflate3(Config) when is_list(Config) ->
     ?m(ok, zlib:inflateEnd(Z1)),
     ?m(ok, zlib:inflateInit(Z1)),
     ?m(Data, zlib:inflate(Z1, Compressed, Options)),
-    ?m(?BARG, zlib:inflate(gurka, Compressed, Options)),
-    ?m(?BARG, zlib:inflate(Z1, 4384, Options)),
-    ?m(?BARG, zlib:inflate(Z1, [atom_list], Options)),
+    ?m(?EXIT(badarg), zlib:inflate(gurka, Compressed, Options)),
+    ?m(?EXIT(badarg), zlib:inflate(Z1, 4384, Options)),
+    ?m(?EXIT(badarg), zlib:inflate(Z1, [atom_list], Options)),
     ?m(ok, zlib:inflateEnd(Z1)),
     ?m(ok, zlib:inflateInit(Z1)),
-    ?m({'EXIT',{data_error,_}}, zlib:inflate(Z1, <<2,1,2,1,2>>, Options)),
+    ?m(?EXIT(data_error), zlib:inflate(Z1, <<2,1,2,1,2>>, Options)),
     ?m(ok, zlib:close(Z1)).
 
 %% Test inflateChunk.
@@ -447,10 +464,10 @@ api_inflateChunk(Config) when is_list(Config) ->
     ?m(ok, zlib:inflateEnd(Z1)),
     ?m(ok, zlib:inflateInit(Z1)),
 
-    ?m(?BARG, zlib:inflateChunk(gurka, Compressed)),
-    ?m(?BARG, zlib:inflateChunk(Z1, 4384)),
+    ?m(?EXIT(badarg), zlib:inflateChunk(gurka, Compressed)),
+    ?m(?EXIT(badarg), zlib:inflateChunk(Z1, 4384)),
 
-    ?m({'EXIT',{data_error,_}}, zlib:inflateEnd(Z1)),
+    ?m(?EXIT(data_error), zlib:inflateEnd(Z1)),
 
     ?m(ok, zlib:close(Z1)).
 
@@ -493,22 +510,22 @@ api_safeInflate(Config) when is_list(Config) ->
 
     SafeInflateLoop(zlib:safeInflate(Z1, Compressed), []),
 
-    ?m({'EXIT',{data_error,_}}, zlib:safeInflate(Z1, Compressed)),
+    ?m(?EXIT(data_error), zlib:safeInflate(Z1, Compressed)),
 
     ?m(ok, zlib:inflateReset(Z1)),
-    ?m(?BARG, zlib:safeInflate(gurka, Compressed)),
-    ?m(?BARG, zlib:safeInflate(Z1, 4384)),
-    ?m({'EXIT',{data_error,_}}, zlib:inflateEnd(Z1)),
+    ?m(?EXIT(badarg), zlib:safeInflate(gurka, Compressed)),
+    ?m(?EXIT(badarg), zlib:safeInflate(Z1, 4384)),
+    ?m(?EXIT(data_error), zlib:inflateEnd(Z1)),
     ?m(ok, zlib:close(Z1)).
 
 %% Test inflateEnd.
 api_inflateEnd(Config) when is_list(Config) ->
     Z1 = zlib:open(),
-    ?m(?BARG, zlib:inflateEnd(Z1)), 
+    ?m(?EXIT(not_initialized), zlib:inflateEnd(Z1)),
     ?m(ok, zlib:inflateInit(Z1)),
-    ?m(?BARG, zlib:inflateEnd(gurka)),
-    ?m({'EXIT',{data_error,_}}, zlib:inflateEnd(Z1)),
-    ?m(?BARG, zlib:inflateEnd(Z1)), 
+    ?m(?EXIT(badarg), zlib:inflateEnd(gurka)),
+    ?m(?EXIT(data_error), zlib:inflateEnd(Z1)),
+    ?m(?EXIT(not_initialized), zlib:inflateEnd(Z1)),
     ?m(ok, zlib:inflateInit(Z1)),
     ?m(B when is_list(B), zlib:inflate(Z1, zlib:compress("abc"))),
     ?m(ok, zlib:inflateEnd(Z1)),
@@ -528,15 +545,15 @@ api_crc32(Config) when is_list(Config) ->
     ?m(CRC2 when is_integer(CRC2), zlib:crc32(Z1,Compressed)),
     CRC2 = ?m(CRC2 when is_integer(CRC2), zlib:crc32(Z1,0,Compressed)),
     ?m(CRC3 when CRC2 /= CRC3, zlib:crc32(Z1,234,Compressed)),
-    ?m(?BARG, zlib:crc32(gurka)),
-    ?m(?BARG, zlib:crc32(Z1, not_a_binary)),
-    ?m(?BARG, zlib:crc32(gurka, <<1,1,2,4,4>>)),
-    ?m(?BARG, zlib:crc32(Z1, 2298929, not_a_binary)),
-    ?m(?BARG, zlib:crc32(Z1, not_an_int, <<123,123,123,35,231>>)),
-    ?m(?BARG, zlib:crc32_combine(Z1, not_an_int, 123123, 123)),
-    ?m(?BARG, zlib:crc32_combine(Z1, noint, 123123, 123)),
-    ?m(?BARG, zlib:crc32_combine(Z1, 123123, noint, 123)),
-    ?m(?BARG, zlib:crc32_combine(Z1, 123123, 123, noint)),
+    ?m(?EXIT(badarg), zlib:crc32(gurka)),
+    ?m(?EXIT(badarg), zlib:crc32(Z1, not_a_binary)),
+    ?m(?EXIT(badarg), zlib:crc32(gurka, <<1,1,2,4,4>>)),
+    ?m(?EXIT(badarg), zlib:crc32(Z1, 2298929, not_a_binary)),
+    ?m(?EXIT(badarg), zlib:crc32(Z1, not_an_int, <<123,123,123,35,231>>)),
+    ?m(?EXIT(badarg), zlib:crc32_combine(Z1, not_an_int, 123123, 123)),
+    ?m(?EXIT(badarg), zlib:crc32_combine(Z1, noint, 123123, 123)),
+    ?m(?EXIT(badarg), zlib:crc32_combine(Z1, 123123, noint, 123)),
+    ?m(?EXIT(badarg), zlib:crc32_combine(Z1, 123123, 123, noint)),
     ?m(ok, zlib:deflateEnd(Z1)),
     ?m(ok, zlib:close(Z1)).    
 
@@ -553,41 +570,41 @@ api_adler32(Config) when is_list(Config) ->
     ADLER2 = ?m(ADLER2 when is_integer(ADLER2), zlib:adler32(Z1,Compressed)),
     ?m(ADLER2 when is_integer(ADLER2), zlib:adler32(Z1,1,Compressed)),
     ?m(ADLER3 when ADLER2 /= ADLER3, zlib:adler32(Z1,234,Compressed)),
-    ?m(?BARG, zlib:adler32(Z1, not_a_binary)),
-    ?m(?BARG, zlib:adler32(gurka, <<1,1,2,4,4>>)),
-    ?m(?BARG, zlib:adler32(Z1, 2298929, not_a_binary)),
-    ?m(?BARG, zlib:adler32(Z1, not_an_int, <<123,123,123,35,231>>)),
-    ?m(?BARG, zlib:adler32_combine(Z1, noint, 123123, 123)),
-    ?m(?BARG, zlib:adler32_combine(Z1, 123123, noint, 123)),
-    ?m(?BARG, zlib:adler32_combine(Z1, 123123, 123, noint)),
+    ?m(?EXIT(badarg), zlib:adler32(Z1, not_a_binary)),
+    ?m(?EXIT(badarg), zlib:adler32(gurka, <<1,1,2,4,4>>)),
+    ?m(?EXIT(badarg), zlib:adler32(Z1, 2298929, not_a_binary)),
+    ?m(?EXIT(badarg), zlib:adler32(Z1, not_an_int, <<123,123,123,35,231>>)),
+    ?m(?EXIT(badarg), zlib:adler32_combine(Z1, noint, 123123, 123)),
+    ?m(?EXIT(badarg), zlib:adler32_combine(Z1, 123123, noint, 123)),
+    ?m(?EXIT(badarg), zlib:adler32_combine(Z1, 123123, 123, noint)),
     ?m(ok, zlib:deflateEnd(Z1)),
     ?m(ok, zlib:close(Z1)).    
 
 %% Test compress.
 api_un_compress(Config) when is_list(Config) ->
-    ?m(?BARG,zlib:compress(not_a_binary)),
+    ?m(?EXIT(badarg),zlib:compress(not_a_binary)),
     Bin = <<1,11,1,23,45>>,
     Comp = zlib:compress(Bin),
-    ?m(?BARG,zlib:uncompress(not_a_binary)),
-    ?m({'EXIT',{data_error,_}}, zlib:uncompress(<<171,171,171,171,171>>)),
-    ?m({'EXIT',{data_error,_}}, zlib:uncompress(<<>>)),
-    ?m({'EXIT',{data_error,_}}, zlib:uncompress(<<120>>)),
-    ?m({'EXIT',{data_error,_}}, zlib:uncompress(<<120,156>>)),
-    ?m({'EXIT',{data_error,_}}, zlib:uncompress(<<120,156,3>>)),
-    ?m({'EXIT',{data_error,_}}, zlib:uncompress(<<120,156,3,0>>)),
-    ?m({'EXIT',{data_error,_}}, zlib:uncompress(<<0,156,3,0,0,0,0,1>>)),
+    ?m(?EXIT(badarg),zlib:uncompress(not_a_binary)),
+    ?m(?EXIT(data_error), zlib:uncompress(<<171,171,171,171,171>>)),
+    ?m(?EXIT(data_error), zlib:uncompress(<<>>)),
+    ?m(?EXIT(data_error), zlib:uncompress(<<120>>)),
+    ?m(?EXIT(data_error), zlib:uncompress(<<120,156>>)),
+    ?m(?EXIT(data_error), zlib:uncompress(<<120,156,3>>)),
+    ?m(?EXIT(data_error), zlib:uncompress(<<120,156,3,0>>)),
+    ?m(?EXIT(data_error), zlib:uncompress(<<0,156,3,0,0,0,0,1>>)),
     ?m(Bin, zlib:uncompress(binary_to_list(Comp))),
     ?m(Bin, zlib:uncompress(Comp)).
 
 %% Test zip.
 api_un_zip(Config) when is_list(Config) ->
-    ?m(?BARG,zlib:zip(not_a_binary)),
+    ?m(?EXIT(badarg),zlib:zip(not_a_binary)),
     Bin = <<1,11,1,23,45>>,
     Comp = zlib:zip(Bin),
     ?m(Comp, zlib:zip(binary_to_list(Bin))),
-    ?m(?BARG,zlib:unzip(not_a_binary)),
-    ?m({'EXIT',{data_error,_}}, zlib:unzip(<<171,171,171,171,171>>)),
-    ?m({'EXIT',{data_error,_}}, zlib:unzip(<<>>)),
+    ?m(?EXIT(badarg),zlib:unzip(not_a_binary)),
+    ?m(?EXIT(data_error), zlib:unzip(<<171,171,171,171,171>>)),
+    ?m(?EXIT(data_error), zlib:unzip(<<>>)),
     ?m(Bin, zlib:unzip(Comp)),
     ?m(Bin, zlib:unzip(binary_to_list(Comp))),
 
@@ -598,21 +615,21 @@ api_un_zip(Config) when is_list(Config) ->
 
 %% Test gunzip.
 api_g_un_zip(Config) when is_list(Config) ->
-    ?m(?BARG,zlib:gzip(not_a_binary)),
+    ?m(?EXIT(badarg),zlib:gzip(not_a_binary)),
     Bin = <<1,11,1,23,45>>,
     Comp = zlib:gzip(Bin),
     ?m(Comp, zlib:gzip(binary_to_list(Bin))),
-    ?m(?BARG, zlib:gunzip(not_a_binary)),
-    ?m(?DATA_ERROR, zlib:gunzip(<<171,171,171,171,171>>)),
-    ?m(?DATA_ERROR, zlib:gunzip(<<>>)),
+    ?m(?EXIT(badarg), zlib:gunzip(not_a_binary)),
+    ?m(?EXIT(data_error), zlib:gunzip(<<171,171,171,171,171>>)),
+    ?m(?EXIT(data_error), zlib:gunzip(<<>>)),
     ?m(Bin, zlib:gunzip(Comp)),
     ?m(Bin, zlib:gunzip(binary_to_list(Comp))),
 
     %% Bad CRC; bad length.
     BadCrc = bad_crc_data(),
-    ?m({'EXIT',{data_error,_}},(catch zlib:gunzip(BadCrc))),
+    ?m(?EXIT(data_error),(catch zlib:gunzip(BadCrc))),
     BadLen = bad_len_data(),
-    ?m({'EXIT',{data_error,_}},(catch zlib:gunzip(BadLen))),
+    ?m(?EXIT(data_error),(catch zlib:gunzip(BadLen))),
     ok.
 
 bad_crc_data() ->
@@ -916,7 +933,7 @@ dictionary_usage({run}) ->
     Z2 = zlib:open(),
     ?m(ok, zlib:inflateInit(Z2)),
 
-    {'EXIT',{{need_dictionary,DictID},_}} = (catch zlib:inflate(Z2, Compressed)),
+    ?EXIT({need_dictionary, DictID}) = (catch zlib:inflate(Z2, Compressed)),
 
     ?m(ok, zlib:inflateSetDictionary(Z2, Dict)),
     ?m(ok, zlib:inflateSetDictionary(Z2, binary_to_list(Dict))),
@@ -940,7 +957,7 @@ only_allow_owner(Config) when is_list(Config) ->
 
     {Pid, Ref} = spawn_monitor(
         fun() ->
-            ?m(?BARG, zlib:inflateReset(Z))
+            ?m(?EXIT(not_on_controlling_process), zlib:inflateReset(Z))
         end),
 
     receive