Add encoder wrapper type integration test

Add a file that creates a bunch of wrapper types as we expect the lib
to be used. And test:

- `ArrayEncoder`
- `BytesEncoder`
- `Encoder2`

Author: tcharding

consensus_encoding/tests/wrappers.rs

@@ -0,0 +1,111 @@
+//! Test using wrapper types as we expect the lib to be used.
+
+#![cfg(feature = "std")]
+
+use consensus_encoding as encoding;
+use encoding::{ArrayEncoder, BytesEncoder, Encodable, Encoder2};
+
+encoding::encoder_newtype! {
+    /// An encoder that uses an inner `ArrayEncoder`.
+    pub struct TestArrayEncoder(ArrayEncoder<4>);
+}
+
+encoding::encoder_newtype! {
+    /// An encoder that uses an inner `BytesEncoder`.
+    pub struct TestBytesEncoder<'e>(BytesEncoder<'e>);
+}
+
+#[test]
+fn array_encoder() {
+    #[derive(Debug, Default, Clone)]
+    pub struct Test(u32);
+
+    impl Encodable for Test {
+        type Encoder<'e> = TestArrayEncoder;
+        fn encoder(&self) -> Self::Encoder<'_> {
+            TestArrayEncoder(ArrayEncoder::without_length_prefix(self.0.to_le_bytes()))
+        }
+    }
+
+    let t = Test(0xcafe_babe); // Encodes using an array.
+
+    let want = [0xbe, 0xba, 0xfe, 0xca];
+    let got = encoding::encode_to_vec(&t);
+
+    assert_eq!(got, want);
+}
+
+#[test]
+fn bytes_encoder_without_length_prefix() {
+    #[derive(Debug, Default, Clone)]
+    pub struct Test(Vec<u8>);
+
+    impl Encodable for Test {
+        type Encoder<'e>
+            = TestBytesEncoder<'e>
+        where
+            Self: 'e;
+
+        fn encoder(&self) -> Self::Encoder<'_> {
+            TestBytesEncoder(BytesEncoder::without_length_prefix(self.0.as_ref()))
+        }
+    }
+
+    let t = Test(vec![0xca, 0xfe]);
+
+    let want = [0xca, 0xfe];
+    let got = encoding::encode_to_vec(&t);
+
+    assert_eq!(got, want);
+}
+
+#[test]
+fn bytes_encoder_with_length_prefix() {
+    #[derive(Debug, Default, Clone)]
+    pub struct Test(Vec<u8>);
+
+    impl Encodable for Test {
+        type Encoder<'e>
+            = TestBytesEncoder<'e>
+        where
+            Self: 'e;
+
+        fn encoder(&self) -> Self::Encoder<'_> {
+            TestBytesEncoder(BytesEncoder::with_length_prefix(self.0.as_ref()))
+        }
+    }
+
+    let t = Test(vec![0xca, 0xfe]);
+
+    let want = [0x02, 0xca, 0xfe];
+    let got = encoding::encode_to_vec(&t);
+
+    assert_eq!(got, want);
+}
+
+#[test]
+fn two_encoder() {
+    #[derive(Debug, Default, Clone)]
+    pub struct Test {
+        a: Vec<u8>, // Encode without prefix.
+        b: Vec<u8>, // Encode with prefix.
+    }
+
+    impl Encodable for Test {
+        type Encoder<'e> = Encoder2<TestBytesEncoder<'e>, TestBytesEncoder<'e>>;
+
+        fn encoder(&self) -> Self::Encoder<'_> {
+            let a = TestBytesEncoder(BytesEncoder::without_length_prefix(self.a.as_ref()));
+            let b = TestBytesEncoder(BytesEncoder::with_length_prefix(self.b.as_ref()));
+
+            Encoder2::new(a, b)
+        }
+    }
+
+    let t = Test { a: vec![0xca, 0xfe], b: (vec![0xba, 0xbe]) };
+
+    let want = [0xca, 0xfe, 0x02, 0xba, 0xbe];
+    let got = encoding::encode_to_vec(&t);
+
+    assert_eq!(got, want);
+}