Rename OSSL_SERIALIZER / OSSL_DESERIALIZER to OSSL_ENCODE / OSSL_DECODE

Fixes #12455

Reviewed-by: Paul Dale <paul.dale@oracle.com>
(Merged from https://github.com/openssl/openssl/pull/12660)

4 files changed, 151 insertions, 151 deletions

diff --git a/test/build.info b/test/build.info
index 3ad16b51b1..134a473195 100644
--- a/test/build.info
+++ b/test/build.info
@@ -780,10 +780,10 @@ IF[{- !$disabled{tests} -}]
   INCLUDE[hexstr_test]=.. ../include ../apps/include
   DEPEND[hexstr_test]=../libcrypto.a libtestutil.a
 
-  PROGRAMS{noinst}=serdes_test
-  SOURCE[serdes_test]=serdes_test.c
-  INCLUDE[serdes_test]=.. ../include ../apps/include
-  DEPEND[serdes_test]=../libcrypto.a libtestutil.a
+  PROGRAMS{noinst}=endecode_test
+  SOURCE[endecode_test]=endecode_test.c
+  INCLUDE[endecode_test]=.. ../include ../apps/include
+  DEPEND[endecode_test]=../libcrypto.a libtestutil.a
 
   PROGRAMS{noinst}=namemap_internal_test
   SOURCE[namemap_internal_test]=namemap_internal_test.c
diff --git a/test/serdes_test.c b/test/endecode_test.c
index f4afe53eac..5f3fa3d220 100644
--- a/test/serdes_test.c
+++ b/test/endecode_test.c
@@ -13,8 +13,8 @@
 #include <openssl/rsa.h>
 #include <openssl/x509.h>
 #include <openssl/params.h>
-#include <openssl/serializer.h>
-#include <openssl/deserializer.h>
+#include <openssl/encoder.h>
+#include <openssl/decoder.h>
 
 #include "internal/pem.h"        /* For PVK and "blob" PEM headers */
 #include "internal/cryptlib.h"   /* ossl_assert */
@@ -26,7 +26,7 @@
  * provider side EVP_PKEYs (which don't necessarily have an ameth)
  *
  * In the mean time, we use separate "downgraded" EVP_PKEYs to test
- * serializing/deserializing with "traditional" keys.
+ * encoding/decoding with "traditional" keys.
  */
 
 static EVP_PKEY *make_template(const char *type, OSSL_PARAM *genparams)
@@ -85,36 +85,36 @@ static EVP_PKEY *make_key(const char *type, EVP_PKEY *template,
  * (TEST_strn2_eq(), for example).
  */
 
-typedef int (serializer)(void **serialized, long *serialized_len,
+typedef int (encoder)(void **encoded, long *encoded_len,
                          void *object, const char *pass, const char *pcipher,
-                         const char *ser_propq);
-typedef int (deserializer)(void **object,
-                           void *serialized, long serialized_len,
+                         const char *encoder_propq);
+typedef int (decoder)(void **object,
+                           void *encoded, long encoded_len,
                            const char *pass);
 typedef int (tester)(const void *data1, size_t data1_len,
                      const void *data2, size_t data2_len);
 typedef int (checker)(const char *type, const void *data, size_t data_len);
 typedef void (dumper)(const char *label, const void *data, size_t data_len);
 
-static int test_serialize_deserialize(const char *type, EVP_PKEY *pkey,
+static int test_encode_decode(const char *type, EVP_PKEY *pkey,
                                       const char *pass, const char *pcipher,
-                                      serializer *serialize_cb,
-                                      deserializer *deserialize_cb,
+                                      encoder *encode_cb,
+                                      decoder *decode_cb,
                                       tester *test_cb,
                                       checker *check_cb, dumper *dump_cb,
-                                      const char *ser_propq, int make_legacy)
+                                      const char *encoder_propq, int make_legacy)
 {
-    void *serialized = NULL;
-    long serialized_len = 0;
+    void *encoded = NULL;
+    long encoded_len = 0;
     EVP_PKEY *pkey2 = NULL;
-    void *serialized2 = NULL;
-    long serialized2_len = 0;
+    void *encoded2 = NULL;
+    long encoded2_len = 0;
     int ok = 0;
 
-    if (!serialize_cb(&serialized, &serialized_len, pkey,
-                      pass, pcipher, ser_propq)
-        || !check_cb(type, serialized, serialized_len)
-        || !deserialize_cb((void **)&pkey2, serialized, serialized_len,
+    if (!encode_cb(&encoded, &encoded_len, pkey,
+                      pass, pcipher, encoder_propq)
+        || !check_cb(type, encoded, encoded_len)
+        || !decode_cb((void **)&pkey2, encoded, encoded_len,
                            pass)
         || !TEST_int_eq(EVP_PKEY_eq(pkey, pkey2), 1))
         goto end;
@@ -128,100 +128,100 @@ static int test_serialize_deserialize(const char *type, EVP_PKEY *pkey,
         goto end;
 
     /*
-     * Double check the serialization, but only for unprotected keys,
+     * Double check the encoding, but only for unprotected keys,
      * as protected keys have a random component, which makes the output
      * differ.
      */
     if ((pass == NULL && pcipher == NULL)
-        && (!serialize_cb(&serialized2, &serialized2_len, pkey2,
-                          pass, pcipher, ser_propq)
-            || !test_cb(serialized, serialized_len,
-                        serialized2, serialized2_len)))
+        && (!encode_cb(&encoded2, &encoded2_len, pkey2,
+                          pass, pcipher, encoder_propq)
+            || !test_cb(encoded, encoded_len,
+                        encoded2, encoded2_len)))
         goto end;
 
     ok = 1;
  end:
     if (!ok) {
-        if (serialized != NULL && serialized_len != 0)
-            dump_cb("serialized result", serialized, serialized_len);
-        if (serialized2 != NULL && serialized2_len != 0)
-            dump_cb("re-serialized result", serialized2, serialized2_len);
+        if (encoded != NULL && encoded_len != 0)
+            dump_cb("encoded result", encoded, encoded_len);
+        if (encoded2 != NULL && encoded2_len != 0)
+            dump_cb("re-encoded result", encoded2, encoded2_len);
     }
 
-    OPENSSL_free(serialized);
-    OPENSSL_free(serialized2);
+    OPENSSL_free(encoded);
+    OPENSSL_free(encoded2);
     EVP_PKEY_free(pkey2);
     return ok;
 }
 
-/* Serializing and desserializing methods */
+/* Encoding and desencoding methods */
 
-static int serialize_EVP_PKEY_prov(void **serialized, long *serialized_len,
+static int encode_EVP_PKEY_prov(void **encoded, long *encoded_len,
                                    void *object,
                                    const char *pass, const char *pcipher,
-                                   const char *ser_propq)
+                                   const char *encoder_propq)
 {
     EVP_PKEY *pkey = object;
-    OSSL_SERIALIZER_CTX *sctx = NULL;
+    OSSL_ENCODER_CTX *ectx = NULL;
     BIO *mem_ser = NULL;
     BUF_MEM *mem_buf = NULL;
     const unsigned char *upass = (const unsigned char *)pass;
     int ok = 0;
 
-    if (!TEST_ptr(sctx = OSSL_SERIALIZER_CTX_new_by_EVP_PKEY(pkey, ser_propq))
+    if (!TEST_ptr(ectx = OSSL_ENCODER_CTX_new_by_EVP_PKEY(pkey, encoder_propq))
         || (pass != NULL
-            && !TEST_true(OSSL_SERIALIZER_CTX_set_passphrase(sctx, upass,
+            && !TEST_true(OSSL_ENCODER_CTX_set_passphrase(ectx, upass,
                                                              strlen(pass))))
         || (pcipher != NULL
-            && !TEST_true(OSSL_SERIALIZER_CTX_set_cipher(sctx, pcipher, NULL)))
+            && !TEST_true(OSSL_ENCODER_CTX_set_cipher(ectx, pcipher, NULL)))
         || !TEST_ptr(mem_ser = BIO_new(BIO_s_mem()))
-        || !TEST_true(OSSL_SERIALIZER_to_bio(sctx, mem_ser))
+        || !TEST_true(OSSL_ENCODER_to_bio(ectx, mem_ser))
         || !TEST_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
-        || !TEST_ptr(*serialized = mem_buf->data)
-        || !TEST_long_gt(*serialized_len = mem_buf->length, 0))
+        || !TEST_ptr(*encoded = mem_buf->data)
+        || !TEST_long_gt(*encoded_len = mem_buf->length, 0))
         goto end;
 
-    /* Detach the serialized output */
+    /* Detach the encoded output */
     mem_buf->data = NULL;
     mem_buf->length = 0;
     ok = 1;
  end:
     BIO_free(mem_ser);
-    OSSL_SERIALIZER_CTX_free(sctx);
+    OSSL_ENCODER_CTX_free(ectx);
     return ok;
 }
 
-static int deserialize_EVP_PKEY_prov(void **object,
-                                     void *serialized, long serialized_len,
+static int decode_EVP_PKEY_prov(void **object,
+                                     void *encoded, long encoded_len,
                                      const char *pass)
 {
     EVP_PKEY *pkey = NULL;
-    OSSL_DESERIALIZER_CTX *dctx = NULL;
+    OSSL_DECODER_CTX *dctx = NULL;
     BIO *mem_deser = NULL;
     const unsigned char *upass = (const unsigned char *)pass;
     int ok = 0;
 
-    if (!TEST_ptr(dctx = OSSL_DESERIALIZER_CTX_new_by_EVP_PKEY(&pkey, NULL,
+    if (!TEST_ptr(dctx = OSSL_DECODER_CTX_new_by_EVP_PKEY(&pkey, NULL,
                                                                NULL, NULL))
         || (pass != NULL
-            && !OSSL_DESERIALIZER_CTX_set_passphrase(dctx, upass,
+            && !OSSL_DECODER_CTX_set_passphrase(dctx, upass,
                                                      strlen(pass)))
-        || !TEST_ptr(mem_deser = BIO_new_mem_buf(serialized, serialized_len))
-        || !TEST_true(OSSL_DESERIALIZER_from_bio(dctx, mem_deser)))
+        || !TEST_ptr(mem_deser = BIO_new_mem_buf(encoded, encoded_len))
+        || !TEST_true(OSSL_DECODER_from_bio(dctx, mem_deser)))
         goto end;
     ok = 1;
     *object = pkey;
  end:
     BIO_free(mem_deser);
-    OSSL_DESERIALIZER_CTX_free(dctx);
+    OSSL_DECODER_CTX_free(dctx);
     return ok;
 }
 
-static int serialize_EVP_PKEY_legacy_PEM(void **serialized,
-                                         long *serialized_len,
+static int encode_EVP_PKEY_legacy_PEM(void **encoded,
+                                         long *encoded_len,
                                          void *object,
                                          const char *pass, const char *pcipher,
-                                         ossl_unused const char *ser_propq)
+                                         ossl_unused const char *encoder_propq)
 {
     EVP_PKEY *pkey = object;
     EVP_CIPHER *cipher = NULL;
@@ -242,11 +242,11 @@ static int serialize_EVP_PKEY_legacy_PEM(void **serialized,
                                                            upass, passlen,
                                                            NULL, NULL))
         || !TEST_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
-        || !TEST_ptr(*serialized = mem_buf->data)
-        || !TEST_long_gt(*serialized_len = mem_buf->length, 0))
+        || !TEST_ptr(*encoded = mem_buf->data)
+        || !TEST_long_gt(*encoded_len = mem_buf->length, 0))
         goto end;
 
-    /* Detach the serialized output */
+    /* Detach the encoded output */
     mem_buf->data = NULL;
     mem_buf->length = 0;
     ok = 1;
@@ -257,12 +257,12 @@ static int serialize_EVP_PKEY_legacy_PEM(void **serialized,
 }
 
 #ifndef OPENSSL_NO_DSA
-static int serialize_EVP_PKEY_MSBLOB(void **serialized,
-                                     long *serialized_len,
+static int encode_EVP_PKEY_MSBLOB(void **encoded,
+                                     long *encoded_len,
                                      void *object,
                                      ossl_unused const char *pass,
                                      ossl_unused const char *pcipher,
-                                     ossl_unused const char *ser_propq)
+                                     ossl_unused const char *encoder_propq)
 {
     EVP_PKEY *pkey = object;
     BIO *mem_ser = NULL;
@@ -272,11 +272,11 @@ static int serialize_EVP_PKEY_MSBLOB(void **serialized,
     if (!TEST_ptr(mem_ser = BIO_new(BIO_s_mem()))
         || !TEST_int_ge(i2b_PrivateKey_bio(mem_ser, pkey), 0)
         || !TEST_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
-        || !TEST_ptr(*serialized = mem_buf->data)
-        || !TEST_long_gt(*serialized_len = mem_buf->length, 0))
+        || !TEST_ptr(*encoded = mem_buf->data)
+        || !TEST_long_gt(*encoded_len = mem_buf->length, 0))
         goto end;
 
-    /* Detach the serialized output */
+    /* Detach the encoded output */
     mem_buf->data = NULL;
     mem_buf->length = 0;
     ok = 1;
@@ -285,12 +285,12 @@ static int serialize_EVP_PKEY_MSBLOB(void **serialized,
     return ok;
 }
 
-static int serialize_public_EVP_PKEY_MSBLOB(void **serialized,
-                                            long *serialized_len,
+static int encode_public_EVP_PKEY_MSBLOB(void **encoded,
+                                            long *encoded_len,
                                             void *object,
                                             ossl_unused const char *pass,
                                             ossl_unused const char *pcipher,
-                                            ossl_unused const char *ser_propq)
+                                            ossl_unused const char *encoder_propq)
 {
     EVP_PKEY *pkey = object;
     BIO *mem_ser = NULL;
@@ -300,11 +300,11 @@ static int serialize_public_EVP_PKEY_MSBLOB(void **serialized,
     if (!TEST_ptr(mem_ser = BIO_new(BIO_s_mem()))
         || !TEST_int_ge(i2b_PublicKey_bio(mem_ser, pkey), 0)
         || !TEST_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
-        || !TEST_ptr(*serialized = mem_buf->data)
-        || !TEST_long_gt(*serialized_len = mem_buf->length, 0))
+        || !TEST_ptr(*encoded = mem_buf->data)
+        || !TEST_long_gt(*encoded_len = mem_buf->length, 0))
         goto end;
 
-    /* Detach the serialized output */
+    /* Detach the encoded output */
     mem_buf->data = NULL;
     mem_buf->length = 0;
     ok = 1;
@@ -321,11 +321,11 @@ static int pass_pw(char *buf, int size, int rwflag, void *userdata)
     return strlen(userdata);
 }
 
-static int serialize_EVP_PKEY_PVK(void **serialized, long *serialized_len,
+static int encode_EVP_PKEY_PVK(void **encoded, long *encoded_len,
                                   void *object,
                                   const char *pass,
                                   ossl_unused const char *pcipher,
-                                  ossl_unused const char *ser_propq)
+                                  ossl_unused const char *encoder_propq)
 {
     EVP_PKEY *pkey = object;
     BIO *mem_ser = NULL;
@@ -337,11 +337,11 @@ static int serialize_EVP_PKEY_PVK(void **serialized, long *serialized_len,
         || !TEST_int_ge(i2b_PVK_bio(mem_ser, pkey, enc,
                                     pass_pw, (void *)pass), 0)
         || !TEST_true(BIO_get_mem_ptr(mem_ser, &mem_buf) > 0)
-        || !TEST_ptr(*serialized = mem_buf->data)
-        || !TEST_long_gt(*serialized_len = mem_buf->length, 0))
+        || !TEST_ptr(*encoded = mem_buf->data)
+        || !TEST_long_gt(*encoded_len = mem_buf->length, 0))
         goto end;
 
-    /* Detach the serialized output */
+    /* Detach the encoded output */
     mem_buf->data = NULL;
     mem_buf->length = 0;
     ok = 1;
@@ -396,12 +396,12 @@ static int check_unprotected_PKCS8_DER(const char *type,
 
 static int test_unprotected_via_DER(const char *type, EVP_PKEY *key)
 {
-    return test_serialize_deserialize(type, key, NULL, NULL,
-                                      serialize_EVP_PKEY_prov,
-                                      deserialize_EVP_PKEY_prov,
+    return test_encode_decode(type, key, NULL, NULL,
+                                      encode_EVP_PKEY_prov,
+                                      decode_EVP_PKEY_prov,
                                       test_mem,
                                       check_unprotected_PKCS8_DER, dump_der,
-                                      OSSL_SERIALIZER_PrivateKey_TO_DER_PQ,
+                                      OSSL_ENCODER_PrivateKey_TO_DER_PQ,
                                       0);
 }
 
@@ -415,12 +415,12 @@ static int check_unprotected_PKCS8_PEM(const char *type,
 
 static int test_unprotected_via_PEM(const char *type, EVP_PKEY *key)
 {
-    return test_serialize_deserialize(type, key, NULL, NULL,
-                                      serialize_EVP_PKEY_prov,
-                                      deserialize_EVP_PKEY_prov,
+    return test_encode_decode(type, key, NULL, NULL,
+                                      encode_EVP_PKEY_prov,
+                                      decode_EVP_PKEY_prov,
                                       test_text,
                                       check_unprotected_PKCS8_PEM, dump_pem,
-                                      OSSL_SERIALIZER_PrivateKey_TO_PEM_PQ,
+                                      OSSL_ENCODER_PrivateKey_TO_PEM_PQ,
                                       0);
 }
 
@@ -437,9 +437,9 @@ static int check_unprotected_legacy_PEM(const char *type,
 
 static int test_unprotected_via_legacy_PEM(const char *type, EVP_PKEY *key)
 {
-    return test_serialize_deserialize(type, key, NULL, NULL,
-                                      serialize_EVP_PKEY_legacy_PEM,
-                                      deserialize_EVP_PKEY_prov,
+    return test_encode_decode(type, key, NULL, NULL,
+                                      encode_EVP_PKEY_legacy_PEM,
+                                      decode_EVP_PKEY_prov,
                                       test_text,
                                       check_unprotected_legacy_PEM, dump_pem,
                                       NULL, 1);
@@ -458,9 +458,9 @@ static int check_MSBLOB(const char *type, const void *data, size_t data_len)
 
 static int test_unprotected_via_MSBLOB(const char *type, EVP_PKEY *key)
 {
-    return test_serialize_deserialize(type, key, NULL, NULL,
-                                      serialize_EVP_PKEY_MSBLOB,
-                                      deserialize_EVP_PKEY_prov,
+    return test_encode_decode(type, key, NULL, NULL,
+                                      encode_EVP_PKEY_MSBLOB,
+                                      decode_EVP_PKEY_prov,
                                       test_mem,
                                       check_MSBLOB, dump_der,
                                       NULL, 0);
@@ -478,9 +478,9 @@ static int check_PVK(const char *type, const void *data, size_t data_len)
 
 static int test_unprotected_via_PVK(const char *type, EVP_PKEY *key)
 {
-    return test_serialize_deserialize(type, key, NULL, NULL,
-                                      serialize_EVP_PKEY_PVK,
-                                      deserialize_EVP_PKEY_prov,
+    return test_encode_decode(type, key, NULL, NULL,
+                                      encode_EVP_PKEY_PVK,
+                                      decode_EVP_PKEY_prov,
                                       test_mem,
                                       check_PVK, dump_der,
                                       NULL, 0);
@@ -504,12 +504,12 @@ static int check_protected_PKCS8_DER(const char *type,
 
 static int test_protected_via_DER(const char *type, EVP_PKEY *key)
 {
-    return test_serialize_deserialize(type, key, pass, pass_cipher,
-                                      serialize_EVP_PKEY_prov,
-                                      deserialize_EVP_PKEY_prov,
+    return test_encode_decode(type, key, pass, pass_cipher,
+                                      encode_EVP_PKEY_prov,
+                                      decode_EVP_PKEY_prov,
                                       test_mem,
                                       check_protected_PKCS8_DER, dump_der,
-                                      OSSL_SERIALIZER_PrivateKey_TO_DER_PQ,
+                                      OSSL_ENCODER_PrivateKey_TO_DER_PQ,
                                       0);
 }
 
@@ -523,12 +523,12 @@ static int check_protected_PKCS8_PEM(const char *type,
 
 static int test_protected_via_PEM(const char *type, EVP_PKEY *key)
 {
-    return test_serialize_deserialize(type, key, pass, pass_cipher,
-                                      serialize_EVP_PKEY_prov,
-                                      deserialize_EVP_PKEY_prov,
+    return test_encode_decode(type, key, pass, pass_cipher,
+                                      encode_EVP_PKEY_prov,
+                                      decode_EVP_PKEY_prov,
                                       test_text,
                                       check_protected_PKCS8_PEM, dump_pem,
-                                      OSSL_SERIALIZER_PrivateKey_TO_PEM_PQ,
+                                      OSSL_ENCODER_PrivateKey_TO_PEM_PQ,
                                       0);
 }
 
@@ -546,9 +546,9 @@ static int check_protected_legacy_PEM(const char *type,
 
 static int test_protected_via_legacy_PEM(const char *type, EVP_PKEY *key)
 {
-    return test_serialize_deserialize(type, key, pass, pass_cipher,
-                                      serialize_EVP_PKEY_legacy_PEM,
-                                      deserialize_EVP_PKEY_prov,
+    return test_encode_decode(type, key, pass, pass_cipher,
+                                      encode_EVP_PKEY_legacy_PEM,
+                                      decode_EVP_PKEY_prov,
                                       test_text,
                                       check_protected_legacy_PEM, dump_pem,
                                       NULL, 1);
@@ -557,9 +557,9 @@ static int test_protected_via_legacy_PEM(const char *type, EVP_PKEY *key)
 #if !defined(OPENSSL_NO_DSA) && !defined(OPENSSL_NO_RC4)
 static int test_protected_via_PVK(const char *type, EVP_PKEY *key)
 {
-    return test_serialize_deserialize(type, key, pass, NULL,
-                                      serialize_EVP_PKEY_PVK,
-                                      deserialize_EVP_PKEY_prov,
+    return test_encode_decode(type, key, pass, NULL,
+                                      encode_EVP_PKEY_PVK,
+                                      decode_EVP_PKEY_prov,
                                       test_mem,
                                       check_PVK, dump_der,
                                       NULL, 0);
@@ -578,12 +578,12 @@ static int check_public_DER(const char *type, const void *data, size_t data_len)
 
 static int test_public_via_DER(const char *type, EVP_PKEY *key)
 {
-    return test_serialize_deserialize(type, key, NULL, NULL,
-                                      serialize_EVP_PKEY_prov,
-                                      deserialize_EVP_PKEY_prov,
+    return test_encode_decode(type, key, NULL, NULL,
+                                      encode_EVP_PKEY_prov,
+                                      decode_EVP_PKEY_prov,
                                       test_mem,
                                       check_public_DER, dump_der,
-                                      OSSL_SERIALIZER_PUBKEY_TO_DER_PQ,
+                                      OSSL_ENCODER_PUBKEY_TO_DER_PQ,
                                       0);
 }
 
@@ -597,12 +597,12 @@ static int check_public_PEM(const char *type, const void *data, size_t data_len)
 
 static int test_public_via_PEM(const char *type, EVP_PKEY *key)
 {
-    return test_serialize_deserialize(type, key, NULL, NULL,
-                                      serialize_EVP_PKEY_prov,
-                                      deserialize_EVP_PKEY_prov,
+    return test_encode_decode(type, key, NULL, NULL,
+                                      encode_EVP_PKEY_prov,
+                                      decode_EVP_PKEY_prov,
                                       test_text,
                                       check_public_PEM, dump_pem,
-                                      OSSL_SERIALIZER_PUBKEY_TO_PEM_PQ,
+                                      OSSL_ENCODER_PUBKEY_TO_PEM_PQ,
                                       0);
 }
 
@@ -620,9 +620,9 @@ static int check_public_MSBLOB(const char *type,
 
 static int test_public_via_MSBLOB(const char *type, EVP_PKEY *key)
 {
-    return test_serialize_deserialize(type, key, NULL, NULL,
-                                      serialize_public_EVP_PKEY_MSBLOB,
-                                      deserialize_EVP_PKEY_prov,
+    return test_encode_decode(type, key, NULL, NULL,
+                                      encode_public_EVP_PKEY_MSBLOB,
+                                      decode_EVP_PKEY_prov,
                                       test_mem,
                                       check_public_MSBLOB, dump_der,
                                       NULL, 0);
diff --git a/test/evp_pkey_provided_test.c b/test/evp_pkey_provided_test.c
index 7e063bb77b..3678dc0584 100644
--- a/test/evp_pkey_provided_test.c
+++ b/test/evp_pkey_provided_test.c
@@ -10,7 +10,7 @@
 #include <string.h> /* memset */
 #include <openssl/evp.h>
 #include <openssl/pem.h>
-#include <openssl/serializer.h>
+#include <openssl/encoder.h>
 #include <openssl/provider.h>
 #include <openssl/param_build.h>
 #include <openssl/core_names.h>
@@ -152,41 +152,41 @@ static int test_print_key_using_pem(const char *alg, const EVP_PKEY *pk)
     return ret;
 }
 
-static int test_print_key_type_using_serializer(const char *alg, int type,
+static int test_print_key_type_using_encoder(const char *alg, int type,
                                                 const EVP_PKEY *pk)
 {
     const char *pq;
-    OSSL_SERIALIZER_CTX *ctx = NULL;
+    OSSL_ENCODER_CTX *ctx = NULL;
     BIO *membio = BIO_new(BIO_s_mem());
     int ret = 0;
 
     switch (type) {
     case PRIV_TEXT:
-        pq = OSSL_SERIALIZER_PrivateKey_TO_TEXT_PQ;
+        pq = OSSL_ENCODER_PrivateKey_TO_TEXT_PQ;
         break;
 
     case PRIV_PEM:
-        pq = OSSL_SERIALIZER_PrivateKey_TO_PEM_PQ;
+        pq = OSSL_ENCODER_PrivateKey_TO_PEM_PQ;
         break;
 
     case PRIV_DER:
-        pq = OSSL_SERIALIZER_PrivateKey_TO_DER_PQ;
+        pq = OSSL_ENCODER_PrivateKey_TO_DER_PQ;
         break;
 
     case PUB_TEXT:
-        pq = OSSL_SERIALIZER_PUBKEY_TO_TEXT_PQ;
+        pq = OSSL_ENCODER_PUBKEY_TO_TEXT_PQ;
         break;
 
     case PUB_PEM:
-        pq = OSSL_SERIALIZER_PUBKEY_TO_PEM_PQ;
+        pq = OSSL_ENCODER_PUBKEY_TO_PEM_PQ;
         break;
 
     case PUB_DER:
-        pq = OSSL_SERIALIZER_PUBKEY_TO_DER_PQ;
+        pq = OSSL_ENCODER_PUBKEY_TO_DER_PQ;
         break;
 
     default:
-        TEST_error("Invalid serialization type");
+        TEST_error("Invalid encoding type");
         goto err;
     }
 
@@ -194,58 +194,58 @@ static int test_print_key_type_using_serializer(const char *alg, int type,
         goto err;
 
     /* Make a context, it's valid for several prints */
-    TEST_note("Setting up a OSSL_SERIALIZER context with passphrase");
-    if (!TEST_ptr(ctx = OSSL_SERIALIZER_CTX_new_by_EVP_PKEY(pk, pq))
+    TEST_note("Setting up a OSSL_ENCODER context with passphrase");
+    if (!TEST_ptr(ctx = OSSL_ENCODER_CTX_new_by_EVP_PKEY(pk, pq))
         /* Check that this operation is supported */
-        || !TEST_ptr(OSSL_SERIALIZER_CTX_get_serializer(ctx)))
+        || !TEST_ptr(OSSL_ENCODER_CTX_get_encoder(ctx)))
         goto err;
 
     /* Use no cipher.  This should give us an unencrypted PEM */
     TEST_note("Testing with no encryption");
-    if (!TEST_true(OSSL_SERIALIZER_to_bio(ctx, membio))
+    if (!TEST_true(OSSL_ENCODER_to_bio(ctx, membio))
         || !TEST_true(compare_with_file(alg, type, membio)))
         goto err;
 
     if (type == PRIV_PEM) {
         /* Set a passphrase to be used later */
-        if (!TEST_true(OSSL_SERIALIZER_CTX_set_passphrase(ctx,
+        if (!TEST_true(OSSL_ENCODER_CTX_set_passphrase(ctx,
                                                           (unsigned char *)"pass",
                                                           4)))
             goto err;
 
         /* Use a valid cipher name */
         TEST_note("Displaying PEM encrypted with AES-256-CBC");
-        if (!TEST_true(OSSL_SERIALIZER_CTX_set_cipher(ctx, "AES-256-CBC", NULL))
-            || !TEST_true(OSSL_SERIALIZER_to_bio(ctx, bio_out)))
+        if (!TEST_true(OSSL_ENCODER_CTX_set_cipher(ctx, "AES-256-CBC", NULL))
+            || !TEST_true(OSSL_ENCODER_to_bio(ctx, bio_out)))
             goto err;
 
         /* Use an invalid cipher name, which should generate no output */
         TEST_note("NOT Displaying PEM encrypted with (invalid) FOO");
-        if (!TEST_false(OSSL_SERIALIZER_CTX_set_cipher(ctx, "FOO", NULL))
-            || !TEST_false(OSSL_SERIALIZER_to_bio(ctx, bio_out)))
+        if (!TEST_false(OSSL_ENCODER_CTX_set_cipher(ctx, "FOO", NULL))
+            || !TEST_false(OSSL_ENCODER_to_bio(ctx, bio_out)))
             goto err;
 
         /* Clear the cipher.  This should give us an unencrypted PEM again */
         TEST_note("Testing with encryption cleared (no encryption)");
-        if (!TEST_true(OSSL_SERIALIZER_CTX_set_cipher(ctx, NULL, NULL))
-            || !TEST_true(OSSL_SERIALIZER_to_bio(ctx, membio))
+        if (!TEST_true(OSSL_ENCODER_CTX_set_cipher(ctx, NULL, NULL))
+            || !TEST_true(OSSL_ENCODER_to_bio(ctx, membio))
             || !TEST_true(compare_with_file(alg, type, membio)))
             goto err;
     }
     ret = 1;
 err:
     BIO_free(membio);
-    OSSL_SERIALIZER_CTX_free(ctx);
+    OSSL_ENCODER_CTX_free(ctx);
     return ret;
 }
 
-static int test_print_key_using_serializer(const char *alg, const EVP_PKEY *pk)
+static int test_print_key_using_encoder(const char *alg, const EVP_PKEY *pk)
 {
     int i;
     int ret = 1;
 
     for (i = 0; i < 6; i++)
-        ret = ret && test_print_key_type_using_serializer(alg, i, pk);
+        ret = ret && test_print_key_type_using_encoder(alg, i, pk);
 
     return ret;
 }
@@ -326,7 +326,7 @@ static int test_fromdata_rsa(void)
             goto err;
     }
     ret = test_print_key_using_pem("RSA", pk)
-          && test_print_key_using_serializer("RSA", pk);
+          && test_print_key_using_encoder("RSA", pk);
  err:
     BN_free(bn_from);
     BN_free(bn);
@@ -512,7 +512,7 @@ static int test_fromdata_dh_named_group(void)
         goto err;
 
     ret = test_print_key_using_pem("DH", pk)
-          && test_print_key_using_serializer("DH", pk);
+          && test_print_key_using_encoder("DH", pk);
 err:
     BN_free(p);
     BN_free(q);
@@ -648,7 +648,7 @@ static int test_fromdata_dh_fips186_4(void)
         goto err;
 
     ret = test_print_key_using_pem("DH", pk)
-          && test_print_key_using_serializer("DH", pk);
+          && test_print_key_using_encoder("DH", pk);
 err:
     BN_free(p);
     BN_free(q);
@@ -876,7 +876,7 @@ static int test_fromdata_ecx(int tst)
         goto err;
 
     ret = test_print_key_using_pem(alg, pk)
-          && test_print_key_using_serializer(alg, pk);
+          && test_print_key_using_encoder(alg, pk);
 
 err:
     EVP_PKEY_free(pk);
@@ -977,7 +977,7 @@ static int test_fromdata_ec(void)
         goto err;
 
     ret = test_print_key_using_pem(alg, pk)
-          && test_print_key_using_serializer(alg, pk);
+          && test_print_key_using_encoder(alg, pk);
 err:
     BN_free(bn_priv);
     BN_free(ec_priv_bn);
@@ -1193,7 +1193,7 @@ static int test_fromdata_dsa_fips186_4(void)
         goto err;
 
     ret = test_print_key_using_pem("DSA", pk)
-          && test_print_key_using_serializer("DSA", pk);
+          && test_print_key_using_encoder("DSA", pk);
  err:
     OSSL_PARAM_BLD_free_params(fromdata_params);
     OSSL_PARAM_BLD_free(bld);
diff --git a/test/recipes/04-test_serializer_deserializer.t b/test/recipes/04-test_encoder_decoder.t
index 905fc3fccc..2041eb1fb9 100644
--- a/test/recipes/04-test_serializer_deserializer.t
+++ b/test/recipes/04-test_encoder_decoder.t
@@ -13,11 +13,11 @@ use OpenSSL::Test::Simple;
 use OpenSSL::Test qw/:DEFAULT srctop_file bldtop_dir/;
 use Cwd qw(abs_path);
 
-setup("test_serializer_deserializer");
+setup("test_encoder_decoder");
 
 plan tests => 1;
 
 $ENV{OPENSSL_MODULES} = abs_path(bldtop_dir("providers"));
 $ENV{OPENSSL_CONF} = abs_path(srctop_file("test", "default-and-legacy.cnf"));
 
-ok(run(test(["serdes_test"])));
+ok(run(test(["endecode_test"])));