Force write_sint to actually write a signed int as per the docs

rmp/README.md

@@ -78,14 +78,14 @@ assert_eq!([0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a], bufs[4][..]);
 
 But they aren't planned to be widely used. Instead we often need to encode bytes compactly to
 save space. In these cases RMP provides functions that guarantee that for encoding the most
-compact representation will be chosen.
+compact representation with the specified sign will be chosen.
 
 ```rust
 let mut buf = Vec::new();
 
 rmp::encode::write_sint(&mut buf, 300).unwrap();
 
-assert_eq!([0xcd, 0x1, 0x2c], buf[..]);
+assert_eq!([0xd1, 0x1, 0x2c], buf[..]);
 ```
 
 On the other hand for deserialization it is not matter in which representation the value is

rmp/src/encode/sint.rs

@@ -1,5 +1,5 @@
 use super::{write_marker, RmpWrite};
-use crate::encode::{write_pfix, write_u16, write_u32, write_u64, write_u8, ValueWriteError};
+use crate::encode::{write_pfix, ValueWriteError};
 use crate::Marker;
 
 /// Encodes and attempts to write a negative small integer value as a negative fixnum into the
@@ -151,18 +151,14 @@ pub fn write_sint<W: RmpWrite>(wr: &mut W, val: i64) -> Result<Marker, ValueWrit
                 .and(Ok(Marker::FixNeg(val as i8)))
                 .map_err(ValueWriteError::InvalidMarkerWrite)
         }
-        val if -128 <= val && val < -32 => write_i8(wr, val as i8).and(Ok(Marker::I8)),
-        val if -32768 <= val && val < -128 => write_i16(wr, val as i16).and(Ok(Marker::I16)),
-        val if -2147483648 <= val && val < -32768 => write_i32(wr, val as i32).and(Ok(Marker::I32)),
-        val if val < -2147483648 => write_i64(wr, val).and(Ok(Marker::I64)),
         val if 0 <= val && val < 128 => {
             write_pfix(wr, val as u8)
                 .and(Ok(Marker::FixPos(val as u8)))
                 .map_err(ValueWriteError::InvalidMarkerWrite)
         }
-        val if val < 256 => write_u8(wr, val as u8).and(Ok(Marker::U8)),
-        val if val < 65536 => write_u16(wr, val as u16).and(Ok(Marker::U16)),
-        val if val < 4294967296 => write_u32(wr, val as u32).and(Ok(Marker::U32)),
-        val => write_u64(wr, val as u64).and(Ok(Marker::U64)),
+        val if -128 <= val && val < 128 => write_i8(wr, val as i8).and(Ok(Marker::I8)),
+        val if -32768 <= val && val < 32768 => write_i16(wr, val as i16).and(Ok(Marker::I16)),
+        val if -2147483648 <= val && val < 2147483648 => write_i32(wr, val as i32).and(Ok(Marker::I32)),
+        val => write_i64(wr, val).and(Ok(Marker::I64)),
     }
 }

rmp/tests/func/encode/int.rs

@@ -210,9 +210,9 @@ fn pass_pack_sint_i16_min() {
 fn pass_pack_sint_i16_max() {
     let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
 
-    assert_eq!(Marker::U16, write_sint(&mut &mut buf[..], 32767).ok().unwrap());
+    assert_eq!(Marker::I16, write_sint(&mut &mut buf[..], 32767).ok().unwrap());
 
-    assert_eq!([0xcd, 0x7f, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], buf);
+    assert_eq!([0xd1, 0x7f, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], buf);
 }
 
 #[test]
@@ -228,9 +228,9 @@ fn pass_pack_sint_i32_min() {
 fn pass_pack_sint_i32_max() {
     let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
 
-    assert_eq!(Marker::U32, write_sint(&mut &mut buf[..], 2147483647).ok().unwrap());
+    assert_eq!(Marker::I32, write_sint(&mut &mut buf[..], 2147483647).ok().unwrap());
 
-    assert_eq!([0xce, 0x7f, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00], buf);
+    assert_eq!([0xd2, 0x7f, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00], buf);
 }
 
 #[test]
@@ -246,7 +246,7 @@ fn pass_pack_sint_i64_min() {
 fn pass_pack_sint_i64_max() {
     let mut buf = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
 
-    assert_eq!(Marker::U64, write_sint(&mut &mut buf[..], 9223372036854775807).ok().unwrap());
+    assert_eq!(Marker::I64, write_sint(&mut &mut buf[..], 9223372036854775807).ok().unwrap());
 
-    assert_eq!([0xcf, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff], buf);
+    assert_eq!([0xd3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff], buf);
 }