scylla_cql/frame/
types.rs

1//! CQL binary protocol in-wire types.
2
3use super::frame_errors::LowLevelDeserializationError;
4use super::TryFromPrimitiveError;
5use byteorder::{BigEndian, ReadBytesExt};
6use bytes::Bytes;
7#[cfg(test)]
8use bytes::BytesMut;
9use bytes::{Buf, BufMut};
10use std::collections::HashMap;
11use std::convert::TryFrom;
12use std::convert::TryInto;
13use std::net::IpAddr;
14use std::net::SocketAddr;
15use std::str;
16use thiserror::Error;
17use uuid::Uuid;
18
19#[derive(Debug, Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord)]
20#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
21#[cfg_attr(feature = "serde", serde(rename_all = "SCREAMING_SNAKE_CASE"))]
22#[repr(u16)]
23pub enum Consistency {
24    Any = 0x0000,
25    One = 0x0001,
26    Two = 0x0002,
27    Three = 0x0003,
28    Quorum = 0x0004,
29    All = 0x0005,
30    #[default]
31    LocalQuorum = 0x0006,
32    EachQuorum = 0x0007,
33    LocalOne = 0x000A,
34
35    // Apparently, Consistency can be set to Serial or LocalSerial in SELECT statements
36    // to make them use Paxos.
37    Serial = 0x0008,
38    LocalSerial = 0x0009,
39}
40
41impl TryFrom<u16> for Consistency {
42    type Error = TryFromPrimitiveError<u16>;
43
44    fn try_from(value: u16) -> Result<Self, Self::Error> {
45        match value {
46            0x0000 => Ok(Consistency::Any),
47            0x0001 => Ok(Consistency::One),
48            0x0002 => Ok(Consistency::Two),
49            0x0003 => Ok(Consistency::Three),
50            0x0004 => Ok(Consistency::Quorum),
51            0x0005 => Ok(Consistency::All),
52            0x0006 => Ok(Consistency::LocalQuorum),
53            0x0007 => Ok(Consistency::EachQuorum),
54            0x000A => Ok(Consistency::LocalOne),
55            0x0008 => Ok(Consistency::Serial),
56            0x0009 => Ok(Consistency::LocalSerial),
57            _ => Err(TryFromPrimitiveError {
58                enum_name: "Consistency",
59                primitive: value,
60            }),
61        }
62    }
63}
64
65#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
66#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
67#[cfg_attr(feature = "serde", serde(rename_all = "SCREAMING_SNAKE_CASE"))]
68#[repr(i16)]
69pub enum SerialConsistency {
70    Serial = 0x0008,
71    LocalSerial = 0x0009,
72}
73
74impl TryFrom<i16> for SerialConsistency {
75    type Error = TryFromPrimitiveError<i16>;
76
77    fn try_from(value: i16) -> Result<Self, Self::Error> {
78        match value {
79            0x0008 => Ok(Self::Serial),
80            0x0009 => Ok(Self::LocalSerial),
81            _ => Err(TryFromPrimitiveError {
82                enum_name: "SerialConsistency",
83                primitive: value,
84            }),
85        }
86    }
87}
88
89impl Consistency {
90    pub fn is_serial(&self) -> bool {
91        matches!(self, Consistency::Serial | Consistency::LocalSerial)
92    }
93}
94
95#[derive(Debug, Error)]
96#[error("Expected Consistency Serial or LocalSerial, got: {0}")]
97pub struct NonSerialConsistencyError(Consistency);
98
99impl TryFrom<Consistency> for SerialConsistency {
100    type Error = NonSerialConsistencyError;
101
102    fn try_from(c: Consistency) -> Result<Self, Self::Error> {
103        match c {
104            Consistency::Any
105            | Consistency::One
106            | Consistency::Two
107            | Consistency::Three
108            | Consistency::Quorum
109            | Consistency::All
110            | Consistency::LocalQuorum
111            | Consistency::EachQuorum
112            | Consistency::LocalOne => Err(NonSerialConsistencyError(c)),
113            Consistency::Serial => Ok(SerialConsistency::Serial),
114            Consistency::LocalSerial => Ok(SerialConsistency::LocalSerial),
115        }
116    }
117}
118
119impl std::fmt::Display for Consistency {
120    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
121        write!(f, "{:?}", self)
122    }
123}
124
125impl std::fmt::Display for SerialConsistency {
126    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
127        write!(f, "{:?}", self)
128    }
129}
130
131#[derive(Copy, Clone, Debug, PartialEq, Eq)]
132pub enum RawValue<'a> {
133    Null,
134    Unset,
135    Value(&'a [u8]),
136}
137
138impl<'a> RawValue<'a> {
139    #[inline]
140    pub fn as_value(&self) -> Option<&'a [u8]> {
141        match self {
142            RawValue::Value(v) => Some(v),
143            RawValue::Null | RawValue::Unset => None,
144        }
145    }
146}
147
148fn read_raw_bytes<'a>(
149    count: usize,
150    buf: &mut &'a [u8],
151) -> Result<&'a [u8], LowLevelDeserializationError> {
152    if buf.len() < count {
153        return Err(LowLevelDeserializationError::TooFewBytesReceived {
154            expected: count,
155            received: buf.len(),
156        });
157    }
158    let (ret, rest) = buf.split_at(count);
159    *buf = rest;
160    Ok(ret)
161}
162
163pub fn read_int(buf: &mut &[u8]) -> Result<i32, std::io::Error> {
164    let v = buf.read_i32::<BigEndian>()?;
165    Ok(v)
166}
167
168pub fn write_int(v: i32, buf: &mut impl BufMut) {
169    buf.put_i32(v);
170}
171
172pub fn read_int_length(buf: &mut &[u8]) -> Result<usize, LowLevelDeserializationError> {
173    let v = read_int(buf)?;
174    let v: usize = v.try_into()?;
175
176    Ok(v)
177}
178
179pub(crate) fn write_int_length(
180    v: usize,
181    buf: &mut impl BufMut,
182) -> Result<(), std::num::TryFromIntError> {
183    let v: i32 = v.try_into()?;
184
185    write_int(v, buf);
186    Ok(())
187}
188
189#[test]
190fn type_int() {
191    let vals = [i32::MIN, -1, 0, 1, i32::MAX];
192    for val in vals.iter() {
193        let mut buf = Vec::new();
194        write_int(*val, &mut buf);
195        assert_eq!(read_int(&mut &buf[..]).unwrap(), *val);
196    }
197}
198
199pub fn read_long(buf: &mut &[u8]) -> Result<i64, std::io::Error> {
200    let v = buf.read_i64::<BigEndian>()?;
201    Ok(v)
202}
203
204pub fn write_long(v: i64, buf: &mut impl BufMut) {
205    buf.put_i64(v);
206}
207
208#[test]
209fn type_long() {
210    let vals = [i64::MIN, -1, 0, 1, i64::MAX];
211    for val in vals.iter() {
212        let mut buf = Vec::new();
213        write_long(*val, &mut buf);
214        assert_eq!(read_long(&mut &buf[..]).unwrap(), *val);
215    }
216}
217
218pub fn read_short(buf: &mut &[u8]) -> Result<u16, std::io::Error> {
219    let v = buf.read_u16::<BigEndian>()?;
220    Ok(v)
221}
222
223pub fn write_short(v: u16, buf: &mut impl BufMut) {
224    buf.put_u16(v);
225}
226
227pub(crate) fn read_short_length(buf: &mut &[u8]) -> Result<usize, std::io::Error> {
228    let v = read_short(buf)?;
229    let v: usize = v.into();
230    Ok(v)
231}
232
233pub(crate) fn write_short_length(
234    v: usize,
235    buf: &mut impl BufMut,
236) -> Result<(), std::num::TryFromIntError> {
237    let v: u16 = v.try_into()?;
238    write_short(v, buf);
239    Ok(())
240}
241
242#[test]
243fn type_short() {
244    let vals: [u16; 3] = [0, 1, u16::MAX];
245    for val in vals.iter() {
246        let mut buf = Vec::new();
247        write_short(*val, &mut buf);
248        assert_eq!(read_short(&mut &buf[..]).unwrap(), *val);
249    }
250}
251
252// https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v4.spec#L208
253pub fn read_bytes_opt<'a>(
254    buf: &mut &'a [u8],
255) -> Result<Option<&'a [u8]>, LowLevelDeserializationError> {
256    let len = read_int(buf)?;
257    if len < 0 {
258        return Ok(None);
259    }
260    let len = len as usize;
261    let v = Some(read_raw_bytes(len, buf)?);
262    Ok(v)
263}
264
265// Same as read_bytes, but we assume the value won't be `null`
266pub fn read_bytes<'a>(buf: &mut &'a [u8]) -> Result<&'a [u8], LowLevelDeserializationError> {
267    let len = read_int_length(buf)?;
268    let v = read_raw_bytes(len, buf)?;
269    Ok(v)
270}
271
272pub fn read_value<'a>(buf: &mut &'a [u8]) -> Result<RawValue<'a>, LowLevelDeserializationError> {
273    let len = read_int(buf)?;
274    match len {
275        -2 => Ok(RawValue::Unset),
276        -1 => Ok(RawValue::Null),
277        len if len >= 0 => {
278            let v = read_raw_bytes(len as usize, buf)?;
279            Ok(RawValue::Value(v))
280        }
281        len => Err(LowLevelDeserializationError::InvalidValueLength(len)),
282    }
283}
284
285pub fn read_short_bytes<'a>(buf: &mut &'a [u8]) -> Result<&'a [u8], LowLevelDeserializationError> {
286    let len = read_short_length(buf)?;
287    let v = read_raw_bytes(len, buf)?;
288    Ok(v)
289}
290
291pub fn write_bytes(v: &[u8], buf: &mut impl BufMut) -> Result<(), std::num::TryFromIntError> {
292    write_int_length(v.len(), buf)?;
293    buf.put_slice(v);
294    Ok(())
295}
296
297pub fn write_bytes_opt(
298    v: Option<impl AsRef<[u8]>>,
299    buf: &mut impl BufMut,
300) -> Result<(), std::num::TryFromIntError> {
301    match v {
302        Some(bytes) => {
303            write_int_length(bytes.as_ref().len(), buf)?;
304            buf.put_slice(bytes.as_ref());
305        }
306        None => write_int(-1, buf),
307    }
308
309    Ok(())
310}
311
312pub fn write_short_bytes(v: &[u8], buf: &mut impl BufMut) -> Result<(), std::num::TryFromIntError> {
313    write_short_length(v.len(), buf)?;
314    buf.put_slice(v);
315    Ok(())
316}
317
318pub fn read_bytes_map(
319    buf: &mut &[u8],
320) -> Result<HashMap<String, Bytes>, LowLevelDeserializationError> {
321    let len = read_short_length(buf)?;
322    let mut v = HashMap::with_capacity(len);
323    for _ in 0..len {
324        let key = read_string(buf)?.to_owned();
325        let val = Bytes::copy_from_slice(read_bytes(buf)?);
326        v.insert(key, val);
327    }
328    Ok(v)
329}
330
331pub fn write_bytes_map<B>(
332    v: &HashMap<String, B>,
333    buf: &mut impl BufMut,
334) -> Result<(), std::num::TryFromIntError>
335where
336    B: AsRef<[u8]>,
337{
338    let len = v.len();
339    write_short_length(len, buf)?;
340    for (key, val) in v.iter() {
341        write_string(key, buf)?;
342        write_bytes(val.as_ref(), buf)?;
343    }
344    Ok(())
345}
346
347#[test]
348fn type_bytes_map() {
349    let mut val = HashMap::new();
350    val.insert("".to_owned(), Bytes::new());
351    val.insert("EXTENSION1".to_owned(), Bytes::from_static(&[1, 2, 3]));
352    val.insert("EXTENSION2".to_owned(), Bytes::from_static(&[4, 5, 6]));
353    let mut buf = BytesMut::new();
354    write_bytes_map(&val, &mut buf).unwrap();
355    assert_eq!(read_bytes_map(&mut &*buf).unwrap(), val);
356}
357
358pub fn read_string<'a>(buf: &mut &'a [u8]) -> Result<&'a str, LowLevelDeserializationError> {
359    let len = read_short_length(buf)?;
360    let raw = read_raw_bytes(len, buf)?;
361    let v = str::from_utf8(raw)?;
362    Ok(v)
363}
364
365pub fn write_string(v: &str, buf: &mut impl BufMut) -> Result<(), std::num::TryFromIntError> {
366    let raw = v.as_bytes();
367    write_short_length(v.len(), buf)?;
368    buf.put_slice(raw);
369    Ok(())
370}
371
372#[test]
373fn type_string() {
374    let vals = [String::from(""), String::from("hello, world!")];
375    for val in vals.iter() {
376        let mut buf = Vec::new();
377        write_string(val, &mut buf).unwrap();
378        assert_eq!(read_string(&mut &buf[..]).unwrap(), *val);
379    }
380}
381
382pub fn read_long_string<'a>(buf: &mut &'a [u8]) -> Result<&'a str, LowLevelDeserializationError> {
383    let len = read_int_length(buf)?;
384    let raw = read_raw_bytes(len, buf)?;
385    let v = str::from_utf8(raw)?;
386    Ok(v)
387}
388
389pub fn write_long_string(v: &str, buf: &mut impl BufMut) -> Result<(), std::num::TryFromIntError> {
390    let raw = v.as_bytes();
391    let len = raw.len();
392    write_int_length(len, buf)?;
393    buf.put_slice(raw);
394    Ok(())
395}
396
397#[test]
398fn type_long_string() {
399    let vals = [String::from(""), String::from("hello, world!")];
400    for val in vals.iter() {
401        let mut buf = Vec::new();
402        write_long_string(val, &mut buf).unwrap();
403        assert_eq!(read_long_string(&mut &buf[..]).unwrap(), *val);
404    }
405}
406
407pub fn read_string_map(
408    buf: &mut &[u8],
409) -> Result<HashMap<String, String>, LowLevelDeserializationError> {
410    let len = read_short_length(buf)?;
411    let mut v = HashMap::with_capacity(len);
412    for _ in 0..len {
413        let key = read_string(buf)?.to_owned();
414        let val = read_string(buf)?.to_owned();
415        v.insert(key, val);
416    }
417    Ok(v)
418}
419
420pub fn write_string_map(
421    v: &HashMap<impl AsRef<str>, impl AsRef<str>>,
422    buf: &mut impl BufMut,
423) -> Result<(), std::num::TryFromIntError> {
424    let len = v.len();
425    write_short_length(len, buf)?;
426    for (key, val) in v.iter() {
427        write_string(key.as_ref(), buf)?;
428        write_string(val.as_ref(), buf)?;
429    }
430    Ok(())
431}
432
433#[test]
434fn type_string_map() {
435    let mut val = HashMap::new();
436    val.insert(String::from(""), String::from(""));
437    val.insert(String::from("CQL_VERSION"), String::from("3.0.0"));
438    val.insert(String::from("THROW_ON_OVERLOAD"), String::from(""));
439    let mut buf = Vec::new();
440    write_string_map(&val, &mut buf).unwrap();
441    assert_eq!(read_string_map(&mut &buf[..]).unwrap(), val);
442}
443
444pub fn read_string_list(buf: &mut &[u8]) -> Result<Vec<String>, LowLevelDeserializationError> {
445    let len = read_short_length(buf)?;
446    let mut v = Vec::with_capacity(len);
447    for _ in 0..len {
448        v.push(read_string(buf)?.to_owned());
449    }
450    Ok(v)
451}
452
453pub fn write_string_list(
454    v: &[String],
455    buf: &mut impl BufMut,
456) -> Result<(), std::num::TryFromIntError> {
457    let len = v.len();
458    write_short_length(len, buf)?;
459    for v in v.iter() {
460        write_string(v, buf)?;
461    }
462    Ok(())
463}
464
465#[test]
466fn type_string_list() {
467    let val = vec![
468        "".to_owned(),
469        "CQL_VERSION".to_owned(),
470        "THROW_ON_OVERLOAD".to_owned(),
471    ];
472
473    let mut buf = Vec::new();
474    write_string_list(&val, &mut buf).unwrap();
475    assert_eq!(read_string_list(&mut &buf[..]).unwrap(), val);
476}
477
478pub fn read_string_multimap(
479    buf: &mut &[u8],
480) -> Result<HashMap<String, Vec<String>>, LowLevelDeserializationError> {
481    let len = read_short_length(buf)?;
482    let mut v = HashMap::with_capacity(len);
483    for _ in 0..len {
484        let key = read_string(buf)?.to_owned();
485        let val = read_string_list(buf)?;
486        v.insert(key, val);
487    }
488    Ok(v)
489}
490
491pub fn write_string_multimap(
492    v: &HashMap<String, Vec<String>>,
493    buf: &mut impl BufMut,
494) -> Result<(), std::num::TryFromIntError> {
495    let len = v.len();
496    write_short_length(len, buf)?;
497    for (key, val) in v.iter() {
498        write_string(key, buf)?;
499        write_string_list(val, buf)?;
500    }
501    Ok(())
502}
503
504#[test]
505fn type_string_multimap() {
506    let mut val = HashMap::new();
507    val.insert(String::from(""), vec![String::from("")]);
508    val.insert(
509        String::from("versions"),
510        vec![String::from("3.0.0"), String::from("4.2.0")],
511    );
512    val.insert(String::from("empty"), vec![]);
513    let mut buf = Vec::new();
514    write_string_multimap(&val, &mut buf).unwrap();
515    assert_eq!(read_string_multimap(&mut &buf[..]).unwrap(), val);
516}
517
518pub fn read_uuid(buf: &mut &[u8]) -> Result<Uuid, LowLevelDeserializationError> {
519    let raw = read_raw_bytes(16, buf)?;
520
521    // It's safe to unwrap here because the conversion only fails
522    // if the argument slice's length does not match, which
523    // `read_raw_bytes` prevents.
524    let raw_array: &[u8; 16] = raw.try_into().unwrap();
525
526    Ok(Uuid::from_bytes(*raw_array))
527}
528
529pub fn write_uuid(uuid: &Uuid, buf: &mut impl BufMut) {
530    buf.put_slice(&uuid.as_bytes()[..]);
531}
532
533#[test]
534fn type_uuid() {
535    let u = Uuid::parse_str("f3b4958c-52a1-11e7-802a-010203040506").unwrap();
536    let mut buf = Vec::new();
537    write_uuid(&u, &mut buf);
538    let u2 = read_uuid(&mut &*buf).unwrap();
539    assert_eq!(u, u2);
540}
541
542pub fn read_consistency(buf: &mut &[u8]) -> Result<Consistency, LowLevelDeserializationError> {
543    let raw = read_short(buf)?;
544    Consistency::try_from(raw).map_err(LowLevelDeserializationError::UnknownConsistency)
545}
546
547pub fn write_consistency(c: Consistency, buf: &mut impl BufMut) {
548    write_short(c as u16, buf);
549}
550
551pub fn write_serial_consistency(c: SerialConsistency, buf: &mut impl BufMut) {
552    write_short(c as u16, buf);
553}
554
555#[test]
556fn type_consistency() {
557    let c = Consistency::Quorum;
558    let mut buf = Vec::new();
559    write_consistency(c, &mut buf);
560    let c2 = read_consistency(&mut &*buf).unwrap();
561    assert_eq!(c, c2);
562
563    let c: i16 = 0x1234;
564    buf.clear();
565    buf.put_i16(c);
566    let c_result = read_consistency(&mut &*buf);
567    assert!(c_result.is_err());
568
569    // Check that the error message contains information about the invalid value
570    let err_str = format!("{}", c_result.unwrap_err());
571    assert!(err_str.contains(&format!("{}", c)));
572}
573
574pub fn read_inet(buf: &mut &[u8]) -> Result<SocketAddr, LowLevelDeserializationError> {
575    let len = buf.read_u8()?;
576    let ip_addr = match len {
577        4 => {
578            let ret = IpAddr::from(<[u8; 4]>::try_from(&buf[0..4])?);
579            buf.advance(4);
580            ret
581        }
582        16 => {
583            let ret = IpAddr::from(<[u8; 16]>::try_from(&buf[0..16])?);
584            buf.advance(16);
585            ret
586        }
587        v => return Err(LowLevelDeserializationError::InvalidInetLength(v)),
588    };
589    let port = read_int(buf)?;
590
591    Ok(SocketAddr::new(ip_addr, port as u16))
592}
593
594pub fn write_inet(addr: SocketAddr, buf: &mut impl BufMut) {
595    match addr.ip() {
596        IpAddr::V4(v4) => {
597            buf.put_u8(4);
598            buf.put_slice(&v4.octets());
599        }
600        IpAddr::V6(v6) => {
601            buf.put_u8(16);
602            buf.put_slice(&v6.octets());
603        }
604    }
605
606    write_int(addr.port() as i32, buf)
607}
608
609#[test]
610fn type_inet() {
611    use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
612
613    let iv4 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 1234);
614    let iv6 = SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)), 2345);
615    let mut buf = Vec::new();
616
617    write_inet(iv4, &mut buf);
618    let read_iv4 = read_inet(&mut &*buf).unwrap();
619    assert_eq!(iv4, read_iv4);
620    buf.clear();
621
622    write_inet(iv6, &mut buf);
623    let read_iv6 = read_inet(&mut &*buf).unwrap();
624    assert_eq!(iv6, read_iv6);
625}
626
627fn zig_zag_encode(v: i64) -> u64 {
628    ((v >> 63) ^ (v << 1)) as u64
629}
630
631fn zig_zag_decode(v: u64) -> i64 {
632    ((v >> 1) as i64) ^ -((v & 1) as i64)
633}
634
635fn unsigned_vint_encode(v: u64, buf: &mut Vec<u8>) {
636    let mut v = v;
637    let mut number_of_bytes = (639 - 9 * v.leading_zeros()) >> 6;
638    if number_of_bytes <= 1 {
639        return buf.put_u8(v as u8);
640    }
641
642    if number_of_bytes != 9 {
643        let extra_bytes = number_of_bytes - 1;
644        let length_bits = !(0xff >> extra_bytes);
645        v |= (length_bits as u64) << (8 * extra_bytes);
646    } else {
647        buf.put_u8(0xff);
648        number_of_bytes -= 1;
649    }
650    buf.put_uint(v, number_of_bytes as usize)
651}
652
653fn unsigned_vint_decode(buf: &mut &[u8]) -> Result<u64, std::io::Error> {
654    let first_byte = buf.read_u8()?;
655    let extra_bytes = first_byte.leading_ones() as usize;
656
657    let mut v = if extra_bytes != 8 {
658        let first_byte_bits = first_byte & (0xffu8 >> extra_bytes);
659        (first_byte_bits as u64) << (8 * extra_bytes)
660    } else {
661        0
662    };
663
664    if extra_bytes != 0 {
665        v += buf.read_uint::<BigEndian>(extra_bytes)?;
666    }
667
668    Ok(v)
669}
670
671pub(crate) fn vint_encode(v: i64, buf: &mut Vec<u8>) {
672    unsigned_vint_encode(zig_zag_encode(v), buf)
673}
674
675pub(crate) fn vint_decode(buf: &mut &[u8]) -> Result<i64, std::io::Error> {
676    unsigned_vint_decode(buf).map(zig_zag_decode)
677}
678
679#[test]
680fn zig_zag_encode_test() {
681    assert_eq!(zig_zag_encode(0), 0);
682    assert_eq!(zig_zag_encode(-1), 1);
683    assert_eq!(zig_zag_encode(1), 2);
684    assert_eq!(zig_zag_encode(-2), 3);
685    assert_eq!(zig_zag_encode(2), 4);
686    assert_eq!(zig_zag_encode(-3), 5);
687    assert_eq!(zig_zag_encode(3), 6);
688}
689
690#[test]
691fn zig_zag_decode_test() {
692    assert_eq!(zig_zag_decode(0), 0);
693    assert_eq!(zig_zag_decode(1), -1);
694    assert_eq!(zig_zag_decode(2), 1);
695    assert_eq!(zig_zag_decode(3), -2);
696    assert_eq!(zig_zag_decode(4), 2);
697    assert_eq!(zig_zag_decode(5), -3);
698    assert_eq!(zig_zag_decode(6), 3);
699}
700
701#[test]
702fn unsigned_vint_encode_and_decode_test() {
703    let unsigned_vint_encoding = vec![
704        (0, vec![0]),
705        (1, vec![1]),
706        (2, vec![2]),
707        ((1 << 2) - 1, vec![3]),
708        (1 << 2, vec![4]),
709        ((1 << 2) + 1, vec![5]),
710        ((1 << 3) - 1, vec![7]),
711        (1 << 3, vec![8]),
712        ((1 << 3) + 1, vec![9]),
713        ((1 << 4) - 1, vec![15]),
714        (1 << 4, vec![16]),
715        ((1 << 4) + 1, vec![17]),
716        ((1 << 5) - 1, vec![31]),
717        (1 << 5, vec![32]),
718        ((1 << 5) + 1, vec![33]),
719        ((1 << 6) - 1, vec![63]),
720        (1 << 6, vec![64]),
721        ((1 << 6) + 1, vec![65]),
722        ((1 << 7) - 1, vec![127]),
723        (1 << 7, vec![128, 128]),
724        ((1 << 7) + 1, vec![128, 129]),
725        ((1 << 8) - 1, vec![128, 255]),
726        (1 << 8, vec![129, 0]),
727        ((1 << 8) + 1, vec![129, 1]),
728        ((1 << 9) - 1, vec![129, 255]),
729        (1 << 9, vec![130, 0]),
730        ((1 << 9) + 1, vec![130, 1]),
731        ((1 << 10) - 1, vec![131, 255]),
732        (1 << 10, vec![132, 0]),
733        ((1 << 10) + 1, vec![132, 1]),
734        ((1 << 11) - 1, vec![135, 255]),
735        (1 << 11, vec![136, 0]),
736        ((1 << 11) + 1, vec![136, 1]),
737        ((1 << 12) - 1, vec![143, 255]),
738        (1 << 12, vec![144, 0]),
739        ((1 << 12) + 1, vec![144, 1]),
740        ((1 << 13) - 1, vec![159, 255]),
741        (1 << 13, vec![160, 0]),
742        ((1 << 13) + 1, vec![160, 1]),
743        ((1 << 14) - 1, vec![191, 255]),
744        (1 << 14, vec![192, 64, 0]),
745        ((1 << 14) + 1, vec![192, 64, 1]),
746        ((1 << 15) - 1, vec![192, 127, 255]),
747        (1 << 15, vec![192, 128, 0]),
748        ((1 << 15) + 1, vec![192, 128, 1]),
749        ((1 << 16) - 1, vec![192, 255, 255]),
750        (1 << 16, vec![193, 0, 0]),
751        ((1 << 16) + 1, vec![193, 0, 1]),
752        ((1 << 17) - 1, vec![193, 255, 255]),
753        (1 << 17, vec![194, 0, 0]),
754        ((1 << 17) + 1, vec![194, 0, 1]),
755        ((1 << 18) - 1, vec![195, 255, 255]),
756        (1 << 18, vec![196, 0, 0]),
757        ((1 << 18) + 1, vec![196, 0, 1]),
758        ((1 << 19) - 1, vec![199, 255, 255]),
759        (1 << 19, vec![200, 0, 0]),
760        ((1 << 19) + 1, vec![200, 0, 1]),
761        ((1 << 20) - 1, vec![207, 255, 255]),
762        (1 << 20, vec![208, 0, 0]),
763        ((1 << 20) + 1, vec![208, 0, 1]),
764        ((1 << 21) - 1, vec![223, 255, 255]),
765        (1 << 21, vec![224, 32, 0, 0]),
766        ((1 << 21) + 1, vec![224, 32, 0, 1]),
767        ((1 << 22) - 1, vec![224, 63, 255, 255]),
768        (1 << 22, vec![224, 64, 0, 0]),
769        ((1 << 22) + 1, vec![224, 64, 0, 1]),
770        ((1 << 23) - 1, vec![224, 127, 255, 255]),
771        (1 << 23, vec![224, 128, 0, 0]),
772        ((1 << 23) + 1, vec![224, 128, 0, 1]),
773        ((1 << 24) - 1, vec![224, 255, 255, 255]),
774        (1 << 24, vec![225, 0, 0, 0]),
775        ((1 << 24) + 1, vec![225, 0, 0, 1]),
776        ((1 << 25) - 1, vec![225, 255, 255, 255]),
777        (1 << 25, vec![226, 0, 0, 0]),
778        ((1 << 25) + 1, vec![226, 0, 0, 1]),
779        ((1 << 26) - 1, vec![227, 255, 255, 255]),
780        (1 << 26, vec![228, 0, 0, 0]),
781        ((1 << 26) + 1, vec![228, 0, 0, 1]),
782        ((1 << 27) - 1, vec![231, 255, 255, 255]),
783        (1 << 27, vec![232, 0, 0, 0]),
784        ((1 << 27) + 1, vec![232, 0, 0, 1]),
785        ((1 << 28) - 1, vec![239, 255, 255, 255]),
786        (1 << 28, vec![240, 16, 0, 0, 0]),
787        ((1 << 28) + 1, vec![240, 16, 0, 0, 1]),
788        ((1 << 29) - 1, vec![240, 31, 255, 255, 255]),
789        (1 << 29, vec![240, 32, 0, 0, 0]),
790        ((1 << 29) + 1, vec![240, 32, 0, 0, 1]),
791        ((1 << 30) - 1, vec![240, 63, 255, 255, 255]),
792        (1 << 30, vec![240, 64, 0, 0, 0]),
793        ((1 << 30) + 1, vec![240, 64, 0, 0, 1]),
794        ((1 << 31) - 1, vec![240, 127, 255, 255, 255]),
795        (1 << 31, vec![240, 128, 0, 0, 0]),
796        ((1 << 31) + 1, vec![240, 128, 0, 0, 1]),
797        ((1 << 32) - 1, vec![240, 255, 255, 255, 255]),
798        (1 << 32, vec![241, 0, 0, 0, 0]),
799        ((1 << 32) + 1, vec![241, 0, 0, 0, 1]),
800        ((1 << 33) - 1, vec![241, 255, 255, 255, 255]),
801        (1 << 33, vec![242, 0, 0, 0, 0]),
802        ((1 << 33) + 1, vec![242, 0, 0, 0, 1]),
803        ((1 << 34) - 1, vec![243, 255, 255, 255, 255]),
804        (1 << 34, vec![244, 0, 0, 0, 0]),
805        ((1 << 34) + 1, vec![244, 0, 0, 0, 1]),
806        ((1 << 35) - 1, vec![247, 255, 255, 255, 255]),
807        (1 << 35, vec![248, 8, 0, 0, 0, 0]),
808        ((1 << 35) + 1, vec![248, 8, 0, 0, 0, 1]),
809        ((1 << 36) - 1, vec![248, 15, 255, 255, 255, 255]),
810        (1 << 36, vec![248, 16, 0, 0, 0, 0]),
811        ((1 << 36) + 1, vec![248, 16, 0, 0, 0, 1]),
812        ((1 << 37) - 1, vec![248, 31, 255, 255, 255, 255]),
813        (1 << 37, vec![248, 32, 0, 0, 0, 0]),
814        ((1 << 37) + 1, vec![248, 32, 0, 0, 0, 1]),
815        ((1 << 38) - 1, vec![248, 63, 255, 255, 255, 255]),
816        (1 << 38, vec![248, 64, 0, 0, 0, 0]),
817        ((1 << 38) + 1, vec![248, 64, 0, 0, 0, 1]),
818        ((1 << 39) - 1, vec![248, 127, 255, 255, 255, 255]),
819        (1 << 39, vec![248, 128, 0, 0, 0, 0]),
820        ((1 << 39) + 1, vec![248, 128, 0, 0, 0, 1]),
821        ((1 << 40) - 1, vec![248, 255, 255, 255, 255, 255]),
822        (1 << 40, vec![249, 0, 0, 0, 0, 0]),
823        ((1 << 40) + 1, vec![249, 0, 0, 0, 0, 1]),
824        ((1 << 41) - 1, vec![249, 255, 255, 255, 255, 255]),
825        (1 << 41, vec![250, 0, 0, 0, 0, 0]),
826        ((1 << 41) + 1, vec![250, 0, 0, 0, 0, 1]),
827        ((1 << 42) - 1, vec![251, 255, 255, 255, 255, 255]),
828        (1 << 42, vec![252, 4, 0, 0, 0, 0, 0]),
829        ((1 << 42) + 1, vec![252, 4, 0, 0, 0, 0, 1]),
830        ((1 << 43) - 1, vec![252, 7, 255, 255, 255, 255, 255]),
831        (1 << 43, vec![252, 8, 0, 0, 0, 0, 0]),
832        ((1 << 43) + 1, vec![252, 8, 0, 0, 0, 0, 1]),
833        ((1 << 44) - 1, vec![252, 15, 255, 255, 255, 255, 255]),
834        (1 << 44, vec![252, 16, 0, 0, 0, 0, 0]),
835        ((1 << 44) + 1, vec![252, 16, 0, 0, 0, 0, 1]),
836        ((1 << 45) - 1, vec![252, 31, 255, 255, 255, 255, 255]),
837        (1 << 45, vec![252, 32, 0, 0, 0, 0, 0]),
838        ((1 << 45) + 1, vec![252, 32, 0, 0, 0, 0, 1]),
839        ((1 << 46) - 1, vec![252, 63, 255, 255, 255, 255, 255]),
840        (1 << 46, vec![252, 64, 0, 0, 0, 0, 0]),
841        ((1 << 46) + 1, vec![252, 64, 0, 0, 0, 0, 1]),
842        ((1 << 47) - 1, vec![252, 127, 255, 255, 255, 255, 255]),
843        (1 << 47, vec![252, 128, 0, 0, 0, 0, 0]),
844        ((1 << 47) + 1, vec![252, 128, 0, 0, 0, 0, 1]),
845        ((1 << 48) - 1, vec![252, 255, 255, 255, 255, 255, 255]),
846        (1 << 48, vec![253, 0, 0, 0, 0, 0, 0]),
847        ((1 << 48) + 1, vec![253, 0, 0, 0, 0, 0, 1]),
848        ((1 << 49) - 1, vec![253, 255, 255, 255, 255, 255, 255]),
849        (1 << 49, vec![254, 2, 0, 0, 0, 0, 0, 0]),
850        ((1 << 49) + 1, vec![254, 2, 0, 0, 0, 0, 0, 1]),
851        ((1 << 50) - 1, vec![254, 3, 255, 255, 255, 255, 255, 255]),
852        (1 << 50, vec![254, 4, 0, 0, 0, 0, 0, 0]),
853        ((1 << 50) + 1, vec![254, 4, 0, 0, 0, 0, 0, 1]),
854        ((1 << 51) - 1, vec![254, 7, 255, 255, 255, 255, 255, 255]),
855        (1 << 51, vec![254, 8, 0, 0, 0, 0, 0, 0]),
856        ((1 << 51) + 1, vec![254, 8, 0, 0, 0, 0, 0, 1]),
857        ((1 << 52) - 1, vec![254, 15, 255, 255, 255, 255, 255, 255]),
858        (1 << 52, vec![254, 16, 0, 0, 0, 0, 0, 0]),
859        ((1 << 52) + 1, vec![254, 16, 0, 0, 0, 0, 0, 1]),
860        ((1 << 53) - 1, vec![254, 31, 255, 255, 255, 255, 255, 255]),
861        (1 << 53, vec![254, 32, 0, 0, 0, 0, 0, 0]),
862        ((1 << 53) + 1, vec![254, 32, 0, 0, 0, 0, 0, 1]),
863        ((1 << 54) - 1, vec![254, 63, 255, 255, 255, 255, 255, 255]),
864        (1 << 54, vec![254, 64, 0, 0, 0, 0, 0, 0]),
865        ((1 << 54) + 1, vec![254, 64, 0, 0, 0, 0, 0, 1]),
866        ((1 << 55) - 1, vec![254, 127, 255, 255, 255, 255, 255, 255]),
867        (1 << 55, vec![254, 128, 0, 0, 0, 0, 0, 0]),
868        ((1 << 55) + 1, vec![254, 128, 0, 0, 0, 0, 0, 1]),
869        ((1 << 56) - 1, vec![254, 255, 255, 255, 255, 255, 255, 255]),
870        (1 << 56, vec![255, 1, 0, 0, 0, 0, 0, 0, 0]),
871        ((1 << 56) + 1, vec![255, 1, 0, 0, 0, 0, 0, 0, 1]),
872        (
873            (1 << 57) - 1,
874            vec![255, 1, 255, 255, 255, 255, 255, 255, 255],
875        ),
876        (1 << 57, vec![255, 2, 0, 0, 0, 0, 0, 0, 0]),
877        ((1 << 57) + 1, vec![255, 2, 0, 0, 0, 0, 0, 0, 1]),
878        (
879            (1 << 58) - 1,
880            vec![255, 3, 255, 255, 255, 255, 255, 255, 255],
881        ),
882        (1 << 58, vec![255, 4, 0, 0, 0, 0, 0, 0, 0]),
883        ((1 << 58) + 1, vec![255, 4, 0, 0, 0, 0, 0, 0, 1]),
884        (
885            (1 << 59) - 1,
886            vec![255, 7, 255, 255, 255, 255, 255, 255, 255],
887        ),
888        (1 << 59, vec![255, 8, 0, 0, 0, 0, 0, 0, 0]),
889        ((1 << 59) + 1, vec![255, 8, 0, 0, 0, 0, 0, 0, 1]),
890        (
891            (1 << 60) - 1,
892            vec![255, 15, 255, 255, 255, 255, 255, 255, 255],
893        ),
894        (1 << 60, vec![255, 16, 0, 0, 0, 0, 0, 0, 0]),
895        ((1 << 60) + 1, vec![255, 16, 0, 0, 0, 0, 0, 0, 1]),
896        (
897            (1 << 61) - 1,
898            vec![255, 31, 255, 255, 255, 255, 255, 255, 255],
899        ),
900        (1 << 61, vec![255, 32, 0, 0, 0, 0, 0, 0, 0]),
901        ((1 << 61) + 1, vec![255, 32, 0, 0, 0, 0, 0, 0, 1]),
902        (
903            (1 << 62) - 1,
904            vec![255, 63, 255, 255, 255, 255, 255, 255, 255],
905        ),
906        (1 << 62, vec![255, 64, 0, 0, 0, 0, 0, 0, 0]),
907        ((1 << 62) + 1, vec![255, 64, 0, 0, 0, 0, 0, 0, 1]),
908        (
909            (1 << 63) - 1,
910            vec![255, 127, 255, 255, 255, 255, 255, 255, 255],
911        ),
912        (1 << 63, vec![255, 128, 0, 0, 0, 0, 0, 0, 0]),
913        ((1 << 63) + 1, vec![255, 128, 0, 0, 0, 0, 0, 0, 1]),
914        (u64::MAX, vec![255, 255, 255, 255, 255, 255, 255, 255, 255]),
915    ];
916
917    let mut buf = Vec::new();
918
919    for (v, result) in unsigned_vint_encoding.into_iter() {
920        unsigned_vint_encode(v, &mut buf);
921        assert_eq!(buf, result);
922        let decoded_v = unsigned_vint_decode(&mut buf.as_slice()).unwrap();
923        assert_eq!(v, decoded_v);
924        buf.clear();
925    }
926}
927
928#[test]
929fn vint_encode_and_decode_test() {
930    let mut buf: Vec<u8> = Vec::with_capacity(128);
931
932    let mut check = |n: i64| {
933        vint_encode(n, &mut buf);
934        assert_eq!(vint_decode(&mut buf.as_slice()).unwrap(), n);
935        buf.clear();
936    };
937
938    for i in 0..63 {
939        check((1 << i) - 1);
940        check(1 - (1 << i));
941        check(1 << i);
942        check(-(1 << i));
943        check((1 << i) + 1);
944        check(-1 - (1 << i));
945    }
946    check(i64::MAX);
947    check(-i64::MAX);
948    check(i64::MIN)
949}
scylla_cql/frame/types.rs

scylla_cql/frame/
types.rs
