Add fixed-width-serde integration tests

Add a `tests` directory. Add `serde` tests for the recently added fixed
width binary serialization code.

Please note, serialization is only fixed width when serialized with
the `bincode` crate.

Cargo.toml

@@ -50,6 +50,12 @@ rand = "0.8"
 rand_core = "0.6"
 serde_test = "1.0"
 bitcoin_hashes = "0.10"
+bincode = "1.3.3"
+
+# cbor does not build on WASM, we use it in a single trivial test (an example of when
+# fixed-width-serde breaks down). Just run the test when on an x86_64 machine.
+[target.'cfg(target_arch = "x86_64")'.dependencies]
+cbor = "0.4.1"
 
 [target.wasm32-unknown-unknown.dev-dependencies]
 wasm-bindgen-test = "0.3"

tests/serde.rs

@@ -0,0 +1,87 @@
+#![cfg(feature = "serde")]
+
+extern crate bincode;
+#[cfg(target_arch = "x86_64")]
+extern crate cbor;
+extern crate secp256k1;
+
+use secp256k1::{PublicKey, SecretKey, XOnlyPublicKey};
+#[cfg(feature = "global-context")]
+use secp256k1::{Secp256k1, KeyPair};
+
+// Arbitrary key data.
+
+static SK_BYTES: [u8; 32] = [
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+    0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23,
+    0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30, 0x31,
+    0x0f, 0x10, 0x1f, 0xa0, 0xa9, 0xaa, 0xaf, 0xff,
+];
+
+static PK_BYTES: [u8; 33] = [
+    0x02,
+    0x18, 0x84, 0x57, 0x81, 0xf6, 0x31, 0xc4, 0x8f,
+    0x1c, 0x97, 0x09, 0xe2, 0x30, 0x92, 0x06, 0x7d,
+    0x06, 0x83, 0x7f, 0x30, 0xaa, 0x0c, 0xd0, 0x54,
+    0x4a, 0xc8, 0x87, 0xfe, 0x91, 0xdd, 0xd1, 0x66,
+];
+
+static XONLY_PK_BYTES: [u8; 32] = [
+    0x18, 0x84, 0x57, 0x81, 0xf6, 0x31, 0xc4, 0x8f,
+    0x1c, 0x97, 0x09, 0xe2, 0x30, 0x92, 0x06, 0x7d,
+    0x06, 0x83, 0x7f, 0x30, 0xaa, 0x0c, 0xd0, 0x54,
+    0x4a, 0xc8, 0x87, 0xfe, 0x91, 0xdd, 0xd1, 0x66,
+];
+
+fn secret_key() -> SecretKey {
+    SecretKey::from_slice(&SK_BYTES).expect("failed to create sk from slice")
+}
+
+// Our current serde serialization implementation is only guaranteed to be fixed
+// width for bincode. https://docs.rs/bincode/latest/bincode/index.html
+#[test]
+fn bincode_secret_key() {
+    let sk = secret_key();
+    let ser = bincode::serialize(&sk).unwrap();
+
+    assert_eq!(ser, SK_BYTES);
+}
+
+#[test]
+fn bincode_public_key() {
+    let pk = PublicKey::from_slice(&PK_BYTES).expect("failed to create pk from slice");
+    let ser = bincode::serialize(&pk).unwrap();
+
+    assert_eq!(ser, &PK_BYTES as &[u8])
+}
+
+#[test]
+#[cfg(feature = "global-context")]
+fn bincode_key_pair() {
+    let secp = Secp256k1::new();
+    let kp = KeyPair::from_seckey_slice(&secp, &SK_BYTES).expect("failed to create keypair");
+    let ser = bincode::serialize(&kp).unwrap();
+
+    assert_eq!(ser, SK_BYTES);
+}
+
+#[test]
+fn bincode_x_only_public_key() {
+    let pk = XOnlyPublicKey::from_slice(&XONLY_PK_BYTES).expect("failed to create xonly pk from slice");
+    let ser = bincode::serialize(&pk).unwrap();
+
+    assert_eq!(ser, XONLY_PK_BYTES);
+}
+
+// cbor adds an additional byte of metadata to certain byte values (byte_value < 24).
+#[test]
+#[cfg(target_arch = "x86_64")]
+fn cbor() {
+    let sk = secret_key();
+
+    let mut e = cbor::Encoder::from_memory();
+    e.encode(sk.as_ref()).unwrap();
+
+    // 52 because there are 22 bytes in the key for which cbor adds metadata.
+    assert_eq!(e.as_bytes().len(), 52);
+}