fixed test cases
This commit is contained in:
+178
-115
@@ -1,26 +1,21 @@
|
||||
extern crate bytes;
|
||||
mod types;
|
||||
|
||||
use std::{error, fmt};
|
||||
use std::io::{Read, Cursor};
|
||||
use std::collections::HashMap;
|
||||
use std::io::Cursor;
|
||||
|
||||
use bytes::Buf;
|
||||
|
||||
mod types;
|
||||
|
||||
use std::io::Read;
|
||||
use std::error;
|
||||
use std::fmt;
|
||||
|
||||
use types::TypeCode;
|
||||
|
||||
pub use types::Parameters;
|
||||
pub use types::Value;
|
||||
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct DeserializationError
|
||||
{
|
||||
type_code: u8
|
||||
pub struct DeserializationError {
|
||||
type_code: u8,
|
||||
}
|
||||
|
||||
impl fmt::Display for DeserializationError {
|
||||
@@ -35,56 +30,91 @@ impl error::Error for DeserializationError {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
pub fn deserialize_boolean(buf: &mut Cursor<&[u8]>) -> Option<bool> {
|
||||
let v = if buf.remaining() > 0 {buf.get_u8()} else { return None;};
|
||||
let v = if buf.remaining() > 0 {
|
||||
buf.get_u8()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(v != 0)
|
||||
}
|
||||
|
||||
pub fn deserialize_byte(buf: &mut Cursor<&[u8]>) -> Option<u8> {
|
||||
let v = if buf.remaining() > 0 {buf.get_u8()} else { return None;};
|
||||
let v = if buf.remaining() > 0 {
|
||||
buf.get_u8()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(v)
|
||||
}
|
||||
|
||||
pub fn deserialize_float(buf: &mut Cursor<&[u8]>) -> Option<f32> {
|
||||
let v = if buf.remaining() >= 4 {buf.get_f32_be()} else { return None;};
|
||||
let v = if buf.remaining() >= 4 {
|
||||
buf.get_f32_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(v)
|
||||
}
|
||||
|
||||
pub fn deserialize_integer(buf: &mut Cursor<&[u8]>) -> Option<u32> {
|
||||
let v = if buf.remaining() >= 4 {buf.get_u32_be()} else { return None;};
|
||||
let v = if buf.remaining() >= 4 {
|
||||
buf.get_u32_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(v)
|
||||
}
|
||||
|
||||
pub fn deserialize_long(buf: &mut Cursor<&[u8]>) -> Option<i64> {
|
||||
let v = if buf.remaining() >= 8 {buf.get_i64_be()} else { return None;};
|
||||
let v = if buf.remaining() >= 8 {
|
||||
buf.get_i64_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(v)
|
||||
}
|
||||
|
||||
pub fn deserialize_short(buf: &mut Cursor<&[u8]>) -> Option<i16> {
|
||||
let v = if buf.remaining() >= 2 {buf.get_i16_be()} else { return None;};
|
||||
let v = if buf.remaining() >= 2 {
|
||||
buf.get_i16_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(v)
|
||||
}
|
||||
|
||||
pub fn deserialize_double(buf: &mut Cursor<&[u8]>) -> Option<f64> {
|
||||
let v = if buf.remaining() >= 8 {buf.get_f64_be()} else { return None;};
|
||||
let v = if buf.remaining() >= 8 {
|
||||
buf.get_f64_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(v)
|
||||
}
|
||||
|
||||
pub fn deserialize_string(buf: &mut Cursor<&[u8]>) -> Option<String> {
|
||||
let size = if buf.remaining() >= 2 {buf.get_i16_be()} else { return None;};
|
||||
let size = if buf.remaining() >= 2 {
|
||||
buf.get_i16_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
let mut local_buffer = vec![0; size as usize];
|
||||
|
||||
if let Ok(_) = buf.read_exact(&mut local_buffer[..]) {
|
||||
if let Ok(s) = String::from_utf8(local_buffer) {
|
||||
return Some(s)
|
||||
return Some(s);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
pub fn deserialize_string_array(buf: &mut Cursor<&[u8]>) -> Option<Vec<String>> {
|
||||
let size = if buf.remaining() >= 2 {buf.get_i16_be() as usize } else { return None;};
|
||||
let size = if buf.remaining() >= 2 {
|
||||
buf.get_i16_be() as usize
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
let mut value = vec![];
|
||||
|
||||
for _ in 0..size {
|
||||
@@ -104,7 +134,7 @@ pub fn deserialize_byte_array(buf: &mut Cursor<&[u8]>) -> Option<Vec<u8>> {
|
||||
if buf.remaining() > 0 {
|
||||
value.push(buf.get_u8());
|
||||
} else {
|
||||
return None
|
||||
return None;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -112,7 +142,11 @@ pub fn deserialize_byte_array(buf: &mut Cursor<&[u8]>) -> Option<Vec<u8>> {
|
||||
}
|
||||
|
||||
pub fn deserialize_array(buf: &mut Cursor<&[u8]>) -> Option<Vec<Value>> {
|
||||
let size = if buf.remaining() >= 2 {buf.get_i16_be()} else { return None;};
|
||||
let size = if buf.remaining() >= 2 {
|
||||
buf.get_i16_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
let mut value = vec![];
|
||||
|
||||
if size == 0 {
|
||||
@@ -135,7 +169,11 @@ pub fn deserialize_array(buf: &mut Cursor<&[u8]>) -> Option<Vec<Value>> {
|
||||
pub fn deserialize_dictionary(buf: &mut Cursor<&[u8]>) -> Option<HashMap<String, Value>> {
|
||||
let key_type_code = buf.get_u8();
|
||||
let value_type_code = buf.get_u8();
|
||||
let size = if buf.remaining() >= 2 {buf.get_i16_be()} else { return None;};
|
||||
let size = if buf.remaining() >= 2 {
|
||||
buf.get_i16_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
|
||||
if size == 0 {
|
||||
return None;
|
||||
@@ -167,11 +205,23 @@ pub fn deserialize_dictionary(buf: &mut Cursor<&[u8]>) -> Option<HashMap<String,
|
||||
fn deserialize_parameter_table(buf: &mut Cursor<&[u8]>) -> HashMap<u8, Value> {
|
||||
let mut value: HashMap<u8, Value> = HashMap::new();
|
||||
|
||||
let size = if buf.remaining() >= 2 {buf.get_i16_be()} else { return value;};
|
||||
let size = if buf.remaining() >= 2 {
|
||||
buf.get_i16_be()
|
||||
} else {
|
||||
return value;
|
||||
};
|
||||
|
||||
for _ in 0..size {
|
||||
let key_type_code = if buf.remaining() > 0 { buf.get_u8() } else { break; };
|
||||
let value_type_code = if buf.remaining() > 0 { buf.get_u8() } else { break; };
|
||||
let key_type_code = if buf.remaining() > 0 {
|
||||
buf.get_u8()
|
||||
} else {
|
||||
break;
|
||||
};
|
||||
let value_type_code = if buf.remaining() > 0 {
|
||||
buf.get_u8()
|
||||
} else {
|
||||
break;
|
||||
};
|
||||
let val = deserialize(value_type_code, buf);
|
||||
if let Ok(val) = val {
|
||||
value.insert(key_type_code, val);
|
||||
@@ -217,7 +267,11 @@ pub fn deserialize_operation_request(buf: &mut Cursor<&[u8]>) -> Option<types::O
|
||||
}
|
||||
|
||||
pub fn deserialize_object_array(buf: &mut Cursor<&[u8]>) -> Option<Vec<Value>> {
|
||||
let size = if buf.remaining() >= 2 {buf.get_i16_be()} else { return None;};
|
||||
let size = if buf.remaining() >= 2 {
|
||||
buf.get_i16_be()
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
let mut value = vec![];
|
||||
|
||||
if size == 0 {
|
||||
@@ -225,7 +279,11 @@ pub fn deserialize_object_array(buf: &mut Cursor<&[u8]>) -> Option<Vec<Value>> {
|
||||
}
|
||||
|
||||
for _ in 0..size {
|
||||
let type_code = if buf.remaining() > 0 { buf.get_u8() } else { break; };
|
||||
let type_code = if buf.remaining() > 0 {
|
||||
buf.get_u8()
|
||||
} else {
|
||||
break;
|
||||
};
|
||||
value.push(deserialize(type_code, buf).unwrap());
|
||||
}
|
||||
|
||||
@@ -235,22 +293,54 @@ pub fn deserialize_object_array(buf: &mut Cursor<&[u8]>) -> Option<Vec<Value>> {
|
||||
pub fn deserialize(type_code: u8, buf: &mut Cursor<&[u8]>) -> Result<Value, DeserializationError> {
|
||||
match TypeCode::from(type_code) {
|
||||
TypeCode::Null => Ok(Value::None),
|
||||
TypeCode::Boolean => if let Some(v) = deserialize_boolean(buf) {Ok(Value::Boolean(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::Byte => if let Some(v) = deserialize_byte(buf) {Ok(Value::Byte(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::Double => if let Some(v) = deserialize_double(buf) {Ok(Value::Double(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::Float => if let Some(v) = deserialize_float(buf) {Ok(Value::Float(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::Integer => if let Some(v) = deserialize_integer(buf) {Ok(Value::Integer(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::Long => if let Some(v) = deserialize_long(buf) {Ok(Value::Long(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::Short => if let Some(v) = deserialize_short(buf) {Ok(Value::Short(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::String => if let Some(v) = deserialize_string(buf) {Ok(Value::String(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::StringArray => if let Some(v) = deserialize_string_array(buf) {Ok(Value::StringArray(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::ByteArray => if let Some(v) = deserialize_byte_array(buf) {Ok(Value::ByteArray(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::Array => if let Some(v) = deserialize_array(buf) {Ok(Value::Array(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::Dictionary => if let Some(v) = deserialize_dictionary(buf) {Ok(Value::Dictionary(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::OperationRequest => if let Some(v) = deserialize_operation_request(buf) {Ok(Value::OperationRequest(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::OperationResponse => if let Some(v) = deserialize_operation_response(buf) {Ok(Value::OperationResponse(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::EventData => if let Some(v) = deserialize_event_data(buf) {Ok(Value::EventData(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::ObjectArray => if let Some(v) = deserialize_object_array(buf) {Ok(Value::ObjectArray(v))} else {Err(DeserializationError{type_code})},
|
||||
TypeCode::Boolean => deserialize_boolean(buf)
|
||||
.map(|v| Ok(Value::Boolean(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Byte => deserialize_byte(buf)
|
||||
.map(|v| Ok(Value::Byte(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Double => deserialize_double(buf)
|
||||
.map(|v| Ok(Value::Double(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Float => deserialize_float(buf)
|
||||
.map(|v| Ok(Value::Float(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Integer => deserialize_integer(buf)
|
||||
.map(|v| Ok(Value::Integer(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Long => deserialize_long(buf)
|
||||
.map(|v| Ok(Value::Long(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Short => deserialize_short(buf)
|
||||
.map(|v| Ok(Value::Short(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::String => deserialize_string(buf)
|
||||
.map(|v| Ok(Value::String(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::StringArray => deserialize_string_array(buf)
|
||||
.map(|v| Ok(Value::StringArray(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::ByteArray => deserialize_byte_array(buf)
|
||||
.map(|v| Ok(Value::ByteArray(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Array => deserialize_array(buf)
|
||||
.map(|v| Ok(Value::Array(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::Dictionary => deserialize_dictionary(buf)
|
||||
.map(|v| Ok(Value::Dictionary(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::OperationRequest => deserialize_operation_request(buf)
|
||||
.map(|v| Ok(Value::OperationRequest(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::OperationResponse => deserialize_operation_response(buf)
|
||||
.map(|v| Ok(Value::OperationResponse(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::EventData => deserialize_event_data(buf)
|
||||
.map(|v| Ok(Value::EventData(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
TypeCode::ObjectArray => deserialize_object_array(buf)
|
||||
.map(|v| Ok(Value::ObjectArray(v)))
|
||||
.unwrap_or(Err(DeserializationError { type_code })),
|
||||
_ => Err(DeserializationError { type_code }),
|
||||
}
|
||||
}
|
||||
@@ -270,7 +360,8 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Dictionary(v) => {
|
||||
return assert_eq!(
|
||||
@@ -281,8 +372,6 @@ mod tests {
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_string_array() {
|
||||
@@ -294,7 +383,9 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
|
||||
match value {
|
||||
Value::Array(v) => {
|
||||
if let Value::String(val) = &v[0] {
|
||||
@@ -311,8 +402,6 @@ mod tests {
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_deserialize_byte() {
|
||||
@@ -321,14 +410,13 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Byte(v) => return assert_eq!(v, 6),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_double() {
|
||||
@@ -337,19 +425,13 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Double(v) => return assert_eq!(v, 1234.55),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
// typed_code = struct.unpack("B", byte_stream.read(1))[0]
|
||||
// result = deseliarizer.deserialize(byte_stream, typed_code)
|
||||
|
||||
// assert result
|
||||
// assert result == 1234.55
|
||||
|
||||
#[test]
|
||||
fn deserialize_event_data() {
|
||||
@@ -361,7 +443,8 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::EventData(v) => {
|
||||
assert_eq!(v.code, 100);
|
||||
@@ -374,8 +457,6 @@ mod tests {
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_float() {
|
||||
@@ -384,14 +465,13 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Float(v) => return assert_eq!(v, 1234.55),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_integer() {
|
||||
@@ -400,14 +480,13 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Integer(v) => return assert_eq!(v, 1234),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_short() {
|
||||
@@ -416,14 +495,13 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Short(v) => return assert_eq!(v, 1234),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_long() {
|
||||
@@ -432,14 +510,13 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Long(v) => return assert_eq!(v, 1234),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_integer_array() {
|
||||
@@ -448,7 +525,8 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Array(v) => {
|
||||
if let Value::Integer(val) = v[0] {
|
||||
@@ -462,14 +540,6 @@ mod tests {
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
// typed_code = struct.unpack("B", byte_stream.read(1))[0]
|
||||
// result = deseliarizer.deserialize(byte_stream, typed_code)
|
||||
|
||||
// assert result
|
||||
// assert result[0] == 0
|
||||
// assert result[1] == 1
|
||||
|
||||
#[test]
|
||||
fn deserialize_boolean() {
|
||||
@@ -478,14 +548,14 @@ mod tests {
|
||||
|
||||
let type_code = buf.get_u8();
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Boolean(v) => return assert_eq!(v, true),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
assert!(false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_operation_response() {
|
||||
let value = vec![
|
||||
@@ -496,7 +566,8 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::OperationResponse(v) => {
|
||||
assert_eq!(v.code, 100);
|
||||
@@ -510,8 +581,6 @@ mod tests {
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_operation_request() {
|
||||
@@ -523,7 +592,8 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::OperationRequest(v) => {
|
||||
assert_eq!(v.code, 100);
|
||||
@@ -536,8 +606,6 @@ mod tests {
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_string() {
|
||||
@@ -548,14 +616,13 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::String(v) => return assert_eq!(&v, "test_message"),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_byte_array() {
|
||||
@@ -564,7 +631,8 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::ByteArray(v) => {
|
||||
assert_eq!(&v[0], &6);
|
||||
@@ -574,8 +642,6 @@ mod tests {
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_array_dictionary() {
|
||||
@@ -587,7 +653,8 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Array(v) => {
|
||||
if let Value::Dictionary(val) = &v[0] {
|
||||
@@ -598,8 +665,6 @@ mod tests {
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_array_byte_array() {
|
||||
@@ -608,7 +673,9 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
|
||||
match value {
|
||||
Value::Array(v) => {
|
||||
if let Value::ByteArray(val) = &v[0] {
|
||||
@@ -622,8 +689,6 @@ mod tests {
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_array_array() {
|
||||
@@ -635,7 +700,8 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
match value {
|
||||
Value::Array(v) => {
|
||||
if let Value::Integer(val) = &v[0][0] {
|
||||
@@ -652,8 +718,6 @@ mod tests {
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deserialize_object_array() {
|
||||
@@ -665,7 +729,9 @@ mod tests {
|
||||
let type_code = buf.get_u8();
|
||||
|
||||
let result = deserialize(type_code, &mut buf);
|
||||
if let Some(value) = result {
|
||||
assert!(result.is_ok(), "Unimplemented!");
|
||||
let value = result.unwrap();
|
||||
|
||||
match value {
|
||||
Value::ObjectArray(v) => {
|
||||
if let Value::String(val) = &v[0] {
|
||||
@@ -674,11 +740,8 @@ mod tests {
|
||||
if let Value::String(val) = &v[1] {
|
||||
assert_eq!(val, &"test2".to_owned());
|
||||
}
|
||||
return;
|
||||
}
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
panic!("Unimplemented!")
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user