Fixed failures

src/encoding/variable_byte_integer.rs

@@ -54,11 +54,11 @@ impl VariableByteIntegerEncoder {
         loop {
             let mut encoded_byte: u8;
             encoded_byte = var_int[i];
-
+            i = i + 1;
             if (encoded_byte & 128) == 0 {
                 break;
             }
-            i = i + 1;
+
         }
         return i;
     }

src/main.rs

@@ -4,12 +4,21 @@ use rust_mqtt::packet::property::*;*/
 use std::fs::File;
 use std::io::Read;*/
 
+use rust_mqtt::packet::mqtt_packet::Packet;
+use rust_mqtt::packet::subscription_packet::SubscriptionPacket;
+
 fn main() {
     env_logger::builder()
         .filter_level(log::LevelFilter::Info)
         .format_timestamp_nanos()
         .init();
     
+    let mut pckt: SubscriptionPacket<1> = SubscriptionPacket::new();
+    let mut res = vec![0; 14];
+    pckt.encode(&mut res);
+    println!("{:02X?}", res);
+    log::info!("xxx");
+    
     /*let fl = File::open("/Users/obabec/development/school/rust-mqtt/mqtt_control_example.bin");
 
     let mut f = File::open("/Users/obabec/development/school/rust-mqtt/mqtt_control_example.bin").expect("no file found");
@@ -17,7 +26,7 @@ fn main() {
     f.read(&mut buffer).expect("buffer overflow");
 
 
-    //let mut txt = Vec::new();
+    //
     let mut payld = *b"xxxxx";*/
     //let packet = Packet::clean(txt, &mut payld);
     /*let mut buffer_reader = BuffReader::new(&buffer);

src/packet/packet_type.rs

@@ -55,7 +55,7 @@ impl Into<u8> for PacketType {
             PacketType::Pubrec => 0x50,
             PacketType::Pubrel => 0x60,
             PacketType::Pubcomp => 0x70,
-            PacketType::Subscribe => 0x80,
+            PacketType::Subscribe => 0x82,
             PacketType::Suback => 0x90,
             PacketType::Unsubscribe => 0xA0,
             PacketType::Unsuback => 0xB0,

src/packet/subscription_packet.rs

@@ -32,9 +32,15 @@ pub struct SubscriptionPacket<'a, const MAX_FILTERS: usize> {
 }
 
 impl<'a, const MAX_FILTERS: usize> SubscriptionPacket<'a, MAX_FILTERS> {
-    /*pub fn new() -> Self {
-
-    }*/
+    pub fn new() -> Self {
+        let mut x = Self { fixed_header: PacketType::Subscribe.into(), remain_len: 0, packet_identifier: 1,
+            property_len: 0, properties: Vec::<Property<'a>, MAX_PROPERTIES>::new(), topic_filter_len: 1, topic_filters: Vec::<TopicFilter<'a>, MAX_FILTERS>::new() };
+        let mut p = TopicFilter::new();
+        p.filter.len = 6;
+        p.filter.string = "test/#";
+        x.topic_filters.push(p);
+        return x;
+    }
 }
 
 impl<'a, const MAX_FILTERS: usize> Packet<'a> for SubscriptionPacket<'a, MAX_FILTERS> {
@@ -44,14 +50,23 @@ impl<'a, const MAX_FILTERS: usize> Packet<'a> for SubscriptionPacket<'a, MAX_FIL
         let mut rm_ln = self.property_len;
         let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap();
         let property_len_len = VariableByteIntegerEncoder::len(property_len_enc);
-        rm_ln = rm_ln + property_len_len as u32 + 4 + self.topic_filter_len as u32;
+
+        let mut lt = 0;
+        let mut filters_len = 0;
+        loop {
+            filters_len = filters_len + self.topic_filters.get(lt).unwrap().filter.len + 3;
+            lt = lt + 1;
+            if lt == self.topic_filter_len as usize {
+                break;
+            }
+        }
+        rm_ln = rm_ln + property_len_len as u32 + 2 + filters_len as u32;
 
         buff_writer.write_u8(self.fixed_header);
         buff_writer.write_variable_byte_int(rm_ln);
         buff_writer.write_u16(self.packet_identifier);
         buff_writer.write_variable_byte_int(self.property_len);
         buff_writer.encode_properties::<MAX_PROPERTIES>(&self.properties);
-        buff_writer.write_u16(self.topic_filter_len);
         buff_writer.encode_topic_filters_ref(false, self.topic_filter_len as usize, & self.topic_filters);
     }
 

src/utils/buffer_writer.rs

@@ -107,6 +107,7 @@ impl<'a> BuffWriter<'a> {
 
     pub fn encode_properties<const LEN: usize>(& mut self, properties: & Vec<Property<'a>, LEN>) {
         let mut i = 0;
+        if properties.len() != 0 {
             loop {
                 let prop: &Property = properties.get(i).unwrap();
                 self.encode_property(prop);
@@ -116,6 +117,7 @@ impl<'a> BuffWriter<'a> {
                 }
             }
         }
+    }
 
     fn encode_topic_filter_ref(& mut self,  sub: bool, topic_filter: & TopicFilter<'a>) {
         self.write_string_ref(&topic_filter.filter);
@@ -129,6 +131,7 @@ impl<'a> BuffWriter<'a> {
         loop {
             let topic_filter: & TopicFilter<'a> = filters.get(i).unwrap();
             self.encode_topic_filter_ref(sub, topic_filter);
+            i = i + 1;
             if i == len {
                 break;
             }