41 files changed, 1413 insertions, 62 deletions

@@ -22,6 +22,43 @@ jobs:
       run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE
 
     - name: Build X86_64
+      shell: bash
+      working-directory: ${{github.workspace}}/build
+      run: cmake --build . --config $BUILD_TYPE
+
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Create Build Environment
+      run: cmake -E make_directory ${{github.workspace}}/build
+
+    - name: Configure CMake
+      shell: bash
       working-directory: ${{github.workspace}}/build
+      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE
+
+    - name: Build X86_64
       shell: bash
+      working-directory: ${{github.workspace}}/build
       run: cmake --build . --config $BUILD_TYPE
+
+    - name: Create Test Environment
+      run: cmake -E make_directory ${{github.workspace}}/test/build
+
+    - name: Configure CMake
+      shell: bash
+      working-directory: ${{github.workspace}}/test/build
+      run: cmake ${{github.workspace}}/test
+
+    - name: Build Tests
+      shell: bash
+      working-directory: ${{github.workspace}}/test/build
+      run: cmake --build .
+
+    - name: Test X86_64
+      shell: bash
+      working-directory: ${{github.workspace}}/test/build
+      run: ctest --output-on-failure
@@ -47,8 +47,15 @@ int libwifi_create_assoc_req(struct libwifi_assoc_req *assoc_req, const unsigned
     assoc_req->fixed_parameters.capabilities_information = BYTESWAP16(LIBWIFI_DEFAULT_AP_CAPABS);
     assoc_req->fixed_parameters.listen_interval = BYTESWAP16(LIBWIFI_DEFAULT_LISTEN_INTERVAL);
 
-    libwifi_quick_add_tag(&assoc_req->tags, TAG_SSID, (const unsigned char *) ssid, strlen(ssid));
-    libwifi_quick_add_tag(&assoc_req->tags, TAG_DS_PARAMETER, (const unsigned char *) &channel, 1);
+    int ret = libwifi_quick_add_tag(&assoc_req->tags, TAG_SSID, (const unsigned char *) ssid, strlen(ssid));
+    if (ret != 0) {
+        return ret;
+    }
+
+    ret = libwifi_quick_add_tag(&assoc_req->tags, TAG_DS_PARAMETER, (const unsigned char *) &channel, 1);
+    if (ret != 0) {
+        return ret;
+    }
 
     return 0;
 }
@@ -41,21 +41,28 @@ size_t libwifi_get_assoc_resp_length(struct libwifi_assoc_resp *assoc_resp) {
  * Simple helper function to set the channel of an association response by removing and re-adding the
  * DS tagged parameter.
  */
-void libwifi_set_assoc_resp_channel(struct libwifi_assoc_resp *assoc_resp, uint8_t channel) {
+int libwifi_set_assoc_resp_channel(struct libwifi_assoc_resp *assoc_resp, uint8_t channel) {
+    int ret = 0;
+
     if (assoc_resp->tags.length != 0) {
-        libwifi_remove_tag(&assoc_resp->tags, TAG_DS_PARAMETER);
+        ret = libwifi_remove_tag(&assoc_resp->tags, TAG_DS_PARAMETER);
+        if (ret != 0) {
+            return ret;
+        }
     }
 
     const unsigned char *chan = (const unsigned char *) &channel;
 
-    libwifi_quick_add_tag(&assoc_resp->tags, TAG_DS_PARAMETER, chan, 1);
+    ret = libwifi_quick_add_tag(&assoc_resp->tags, TAG_DS_PARAMETER, chan, 1);
+
+    return ret;
 }
 
 /**
  * The generated association response frame is made with sane defaults defined in common.h and core/types.h.
  * Two tagged parameters are also added to the association response: Channel and Supported Rates.
  */
-void libwifi_create_assoc_resp(struct libwifi_assoc_resp *assoc_resp, const unsigned char receiver[6],
+int libwifi_create_assoc_resp(struct libwifi_assoc_resp *assoc_resp, const unsigned char receiver[6],
                                const unsigned char transmitter[6], uint8_t channel) {
     memset(assoc_resp, 0, sizeof(struct libwifi_assoc_resp));
 
@@ -71,7 +78,9 @@ void libwifi_create_assoc_resp(struct libwifi_assoc_resp *assoc_resp, const unsi
     libwifi_set_assoc_resp_channel(assoc_resp, channel);
 
     const unsigned char supported_rates[] = LIBWIFI_DEFAULT_SUPP_RATES;
-    libwifi_quick_add_tag(&assoc_resp->tags, TAG_SUPP_RATES, supported_rates, sizeof(supported_rates) - 1);
+    int ret = libwifi_quick_add_tag(&assoc_resp->tags, TAG_SUPP_RATES, supported_rates, sizeof(supported_rates) - 1);
+
+    return ret;
 }
 
 /**
@@ -24,7 +24,7 @@
  * @param assoc_resp A libwifi_assoc_resp
  * @param channel The new channel
  */
-void libwifi_set_assoc_resp_channel(struct libwifi_assoc_resp *assoc_resp, uint8_t channel);
+int libwifi_set_assoc_resp_channel(struct libwifi_assoc_resp *assoc_resp, uint8_t channel);
 
 /**
  * Calculate the length of a given libwifi_assoc_resp
@@ -46,7 +46,7 @@ size_t libwifi_get_assoc_resp_length(struct libwifi_assoc_resp *assoc_resp);
  * @param channel The desired channel of the assoc_resp
  *
  */
-void libwifi_create_assoc_resp(struct libwifi_assoc_resp *assoc_resp, const unsigned char receiver[6],
+int libwifi_create_assoc_resp(struct libwifi_assoc_resp *assoc_resp, const unsigned char receiver[6],
                                const unsigned char transmitter[6], uint8_t channel);
 
 /**
@@ -32,7 +32,7 @@ size_t libwifi_get_auth_length(struct libwifi_auth *auth) {
 /**
  * The generated authentication frame is made with sane defaults defined in common.h.
  */
-void libwifi_create_auth(struct libwifi_auth *auth, const unsigned char receiver[6],
+int libwifi_create_auth(struct libwifi_auth *auth, const unsigned char receiver[6],
                          const unsigned char transmitter[6], uint16_t algorithm_number,
                          uint16_t transaction_sequence, uint16_t status_code) {
     memset(auth, 0, sizeof(struct libwifi_auth));
@@ -47,6 +47,8 @@ void libwifi_create_auth(struct libwifi_auth *auth, const unsigned char receiver
     auth->fixed_parameters.algorithm_number = algorithm_number;
     auth->fixed_parameters.transaction_sequence = transaction_sequence;
     auth->fixed_parameters.status_code = status_code;
+
+    return 0;
 }
 
 /**
@@ -40,7 +40,7 @@ size_t libwifi_get_auth_length(struct libwifi_auth *auth);
  * @param algorithm_number Algorithm type to use
  *
  */
-void libwifi_create_auth(struct libwifi_auth *auth, const unsigned char receiver[6],
+int libwifi_create_auth(struct libwifi_auth *auth, const unsigned char receiver[6],
                          const unsigned char transmitter[6], uint16_t algorithm_number,
                          uint16_t transaction_sequence, uint16_t status_code);
 
@@ -39,32 +39,46 @@ size_t libwifi_get_beacon_length(struct libwifi_beacon *beacon) {
 /**
  * Simple helper to set the beacon SSID tag by removing it and then adding it back with the new value.
  */
-void libwifi_set_beacon_ssid(struct libwifi_beacon *beacon, const char *ssid) {
+int libwifi_set_beacon_ssid(struct libwifi_beacon *beacon, const char *ssid) {
+    int ret = 0;
+
     if (beacon->tags.length != 0) {
-        libwifi_remove_tag(&beacon->tags, TAG_SSID);
+        ret = libwifi_remove_tag(&beacon->tags, TAG_SSID);
+        if (ret != 0) {
+            return ret;
+        }
     }
 
-    libwifi_quick_add_tag(&beacon->tags, TAG_SSID, (void *) ssid, strlen(ssid));
+    ret = libwifi_quick_add_tag(&beacon->tags, TAG_SSID, (void *) ssid, strlen(ssid));
+
+    return ret;
 }
 
 /**
  * Simple helper to set the beacon DS tag by removing it and then adding it back with the new value.
  */
-void libwifi_set_beacon_channel(struct libwifi_beacon *beacon, uint8_t channel) {
+int libwifi_set_beacon_channel(struct libwifi_beacon *beacon, uint8_t channel) {
+    int ret = 0;
+
     if (beacon->tags.length != 0) {
-        libwifi_remove_tag(&beacon->tags, TAG_DS_PARAMETER);
+        ret = libwifi_remove_tag(&beacon->tags, TAG_DS_PARAMETER);
+        if (ret != 0) {
+            return ret;
+        }
     }
 
     const unsigned char *chan = (const unsigned char *) &channel;
 
-    libwifi_quick_add_tag(&beacon->tags, TAG_DS_PARAMETER, chan, 1);
+    ret = libwifi_quick_add_tag(&beacon->tags, TAG_DS_PARAMETER, chan, 1);
+
+    return ret;
 }
 
 /**
  * The generated beacon frame is made with sane defaults defined in common.h.
  * Three tagged parameters are also added to the beacon: SSID, Channel and Supported Rates.
  */
-void libwifi_create_beacon(struct libwifi_beacon *beacon, const unsigned char receiver[6],
+int libwifi_create_beacon(struct libwifi_beacon *beacon, const unsigned char receiver[6],
                            const unsigned char transmitter[6], const char *ssid, uint8_t channel) {
     memset(beacon, 0, sizeof(struct libwifi_beacon));
 
@@ -82,7 +96,9 @@ void libwifi_create_beacon(struct libwifi_beacon *beacon, const unsigned char re
     libwifi_set_beacon_channel(beacon, channel);
 
     const unsigned char supported_rates[] = LIBWIFI_DEFAULT_SUPP_RATES;
-    libwifi_quick_add_tag(&beacon->tags, TAG_SUPP_RATES, supported_rates, sizeof(supported_rates) - 1);
+    int ret = libwifi_quick_add_tag(&beacon->tags, TAG_SUPP_RATES, supported_rates, sizeof(supported_rates) - 1);
+
+    return ret;
 }
 
 /**
@@ -24,7 +24,7 @@
  * @param beacon A struct libwifi_beacon
  * @param ssid The new SSID
  */
-void libwifi_set_beacon_ssid(struct libwifi_beacon *beacon, const char *ssid);
+int libwifi_set_beacon_ssid(struct libwifi_beacon *beacon, const char *ssid);
 
 /**
  * Set the channel of a struct libwifi_beacon.
@@ -32,7 +32,7 @@ void libwifi_set_beacon_ssid(struct libwifi_beacon *beacon, const char *ssid);
  * @param beacon A struct libwifi_beacon
  * @param channel The new channel
  */
-void libwifi_set_beacon_channel(struct libwifi_beacon *beacon, uint8_t channel);
+int libwifi_set_beacon_channel(struct libwifi_beacon *beacon, uint8_t channel);
 
 /**
  * Calculate the length of a given struct libwifi_beacon
@@ -55,7 +55,7 @@ size_t libwifi_get_beacon_length(struct libwifi_beacon *beacon);
  * @param channel The desired channel of the beacon
  *
  */
-void libwifi_create_beacon(struct libwifi_beacon *beacon, const unsigned char receiver[6],
+int libwifi_create_beacon(struct libwifi_beacon *beacon, const unsigned char receiver[6],
                            const unsigned char transmitter[6], const char *ssid, uint8_t channel);
 
 /**
@@ -33,7 +33,7 @@ size_t libwifi_get_disassoc_length(struct libwifi_disassoc *disassoc) {
  * The generated disassociation frame contains only the supplied receiver, transmitter and reason_code by
  * default.
  */
-void libwifi_create_disassoc(struct libwifi_disassoc *disassoc, const unsigned char receiver[6],
+int libwifi_create_disassoc(struct libwifi_disassoc *disassoc, const unsigned char receiver[6],
                              const unsigned char transmitter[6], uint16_t reason_code) {
     memset(disassoc, 0, sizeof(struct libwifi_disassoc));
 
@@ -46,6 +46,8 @@ void libwifi_create_disassoc(struct libwifi_disassoc *disassoc, const unsigned c
     disassoc->frame_header.seq_control.sequence_number = (rand() % 4096);
 
     memcpy(&disassoc->fixed_parameters.reason_code, &reason_code, sizeof(reason_code));
+
+    return 0;
 }
 
 /**
@@ -40,7 +40,7 @@ size_t libwifi_get_disassoc_length(struct libwifi_disassoc *disassoc);
  * @param reason_code The disassoc reason code
  *
  */
-void libwifi_create_disassoc(struct libwifi_disassoc *disassoc, const unsigned char receiver[6],
+int libwifi_create_disassoc(struct libwifi_disassoc *disassoc, const unsigned char receiver[6],
                              const unsigned char transmitter[6], uint16_t reason_code);
 
 /**
@@ -31,7 +31,7 @@ size_t libwifi_get_probe_req_length(struct libwifi_probe_req *probe_req) {
  * The generated probe request frame is made with sane defaults defined in common.h.
  * Two tagged parameters are also added to the beacon: SSID and Channel.
  */
-void libwifi_create_probe_req(struct libwifi_probe_req *probe_req, const unsigned char receiver[6],
+int libwifi_create_probe_req(struct libwifi_probe_req *probe_req, const unsigned char receiver[6],
                               const unsigned char transmitter[6], const unsigned char bssid[6],
                               const char *ssid, uint8_t channel) {
     memset(probe_req, 0, sizeof(struct libwifi_probe_req));
@@ -43,8 +43,13 @@ void libwifi_create_probe_req(struct libwifi_probe_req *probe_req, const unsigne
     memcpy(&probe_req->frame_header.addr3, bssid, 6);
     probe_req->frame_header.seq_control.sequence_number = (rand() % 4096);
 
-    libwifi_quick_add_tag(&probe_req->tags, TAG_SSID, (const unsigned char *) ssid, strlen(ssid));
-    libwifi_quick_add_tag(&probe_req->tags, TAG_DS_PARAMETER, (const unsigned char *) &channel, 1);
+    int ret = libwifi_quick_add_tag(&probe_req->tags, TAG_SSID, (const unsigned char *) ssid, strlen(ssid));
+    if (ret != 0) {
+        return ret;
+    }
+
+    ret = libwifi_quick_add_tag(&probe_req->tags, TAG_DS_PARAMETER, (const unsigned char *) &channel, 1);
+    return ret;
 }
 
 /**
@@ -40,7 +40,7 @@ size_t libwifi_get_probe_req_length(struct libwifi_probe_req *probe_req);
  * @param reason_code The probe_req reason code
  *
  */
-void libwifi_create_probe_req(struct libwifi_probe_req *probe_req, const unsigned char receiver[6],
+int libwifi_create_probe_req(struct libwifi_probe_req *probe_req, const unsigned char receiver[6],
                               const unsigned char transmitter[6], const unsigned char bssid[6],
                               const char *ssid, uint8_t channel);
 
@@ -39,32 +39,46 @@ size_t libwifi_get_probe_resp_length(struct libwifi_probe_resp *probe_resp) {
 /**
  * Simple helper to set the probe response SSID tag by removing it and then adding it back with the new value.
  */
-void libwifi_set_probe_resp_ssid(struct libwifi_probe_resp *probe_resp, const char *ssid) {
+int libwifi_set_probe_resp_ssid(struct libwifi_probe_resp *probe_resp, const char *ssid) {
+    int ret = 0;
+
     if (probe_resp->tags.length != 0) {
-        libwifi_remove_tag(&probe_resp->tags, TAG_SSID);
+        ret = libwifi_remove_tag(&probe_resp->tags, TAG_SSID);
+        if (ret != 0) {
+            return ret;
+        }
     }
 
-    libwifi_quick_add_tag(&probe_resp->tags, TAG_SSID, (void *) ssid, strlen(ssid));
+    ret = libwifi_quick_add_tag(&probe_resp->tags, TAG_SSID, (void *) ssid, strlen(ssid));
+
+    return ret;
 }
 
 /**
  * Simple helper to set the probe response DS tag by removing it and then adding it back with the new value.
  */
-void libwifi_set_probe_resp_channel(struct libwifi_probe_resp *probe_resp, uint8_t channel) {
+int libwifi_set_probe_resp_channel(struct libwifi_probe_resp *probe_resp, uint8_t channel) {
+    int ret = 0;
+
     if (probe_resp->tags.length != 0) {
-        libwifi_remove_tag(&probe_resp->tags, TAG_DS_PARAMETER);
+        ret = libwifi_remove_tag(&probe_resp->tags, TAG_DS_PARAMETER);
+        if (ret != 0) {
+            return ret;
+        }
     }
 
     const unsigned char *chan = (const unsigned char *) &channel;
 
-    libwifi_quick_add_tag(&probe_resp->tags, TAG_DS_PARAMETER, chan, 1);
+    ret = libwifi_quick_add_tag(&probe_resp->tags, TAG_DS_PARAMETER, chan, 1);
+
+    return ret;
 }
 
 /**
  * The generated probe response frame is made with sane defaults defined in common.h.
  * Three tagged parameters are also added to the probe response: SSID, Channel and Supported Rates.
  */
-void libwifi_create_probe_resp(struct libwifi_probe_resp *probe_resp, const unsigned char receiver[6],
+int libwifi_create_probe_resp(struct libwifi_probe_resp *probe_resp, const unsigned char receiver[6],
                                const unsigned char transmitter[6], const char *ssid, uint8_t channel) {
     memset(probe_resp, 0, sizeof(struct libwifi_probe_resp));
 
@@ -79,11 +93,20 @@ void libwifi_create_probe_resp(struct libwifi_probe_resp *probe_resp, const unsi
     probe_resp->fixed_parameters.probe_resp_interval = BYTESWAP16(probe_resp_interval);
     probe_resp->fixed_parameters.capabilities_information = BYTESWAP16(LIBWIFI_DEFAULT_AP_CAPABS);
 
-    libwifi_set_probe_resp_ssid(probe_resp, ssid);
-    libwifi_set_probe_resp_channel(probe_resp, channel);
+    int ret = libwifi_set_probe_resp_ssid(probe_resp, ssid);
+    if (ret != 0) {
+        return ret;
+    }
+
+    ret = libwifi_set_probe_resp_channel(probe_resp, channel);
+    if (ret != 0) {
+        return ret;
+    }
 
     const unsigned char supported_rates[] = LIBWIFI_DEFAULT_SUPP_RATES;
-    libwifi_quick_add_tag(&probe_resp->tags, TAG_SUPP_RATES, supported_rates, sizeof(supported_rates) - 1);
+    ret = libwifi_quick_add_tag(&probe_resp->tags, TAG_SUPP_RATES, supported_rates, sizeof(supported_rates) - 1);
+
+    return ret;
 }
 
 /**
@@ -24,7 +24,7 @@
  * @param probe_resp A libwifi_probe_resp
  * @param ssid The new SSID
  */
-void libwifi_set_probe_resp_ssid(struct libwifi_probe_resp *probe_resp, const char *ssid);
+int libwifi_set_probe_resp_ssid(struct libwifi_probe_resp *probe_resp, const char *ssid);
 
 /**
  * Set the channel of a libwifi_probe_resp.
@@ -32,7 +32,7 @@ void libwifi_set_probe_resp_ssid(struct libwifi_probe_resp *probe_resp, const ch
  * @param probe_resp A libwifi_probe_resp
  * @param channel The new channel
  */
-void libwifi_set_probe_resp_channel(struct libwifi_probe_resp *probe_resp, uint8_t channel);
+int libwifi_set_probe_resp_channel(struct libwifi_probe_resp *probe_resp, uint8_t channel);
 
 /**
  * Calculate the length of a given libwifi_probe_resp
@@ -55,7 +55,7 @@ size_t libwifi_get_probe_resp_length(struct libwifi_probe_resp *probe_resp);
  * @param channel The desired channel of the probe_resp
  *
  */
-void libwifi_create_probe_resp(struct libwifi_probe_resp *probe_resp, const unsigned char receiver[6],
+int libwifi_create_probe_resp(struct libwifi_probe_resp *probe_resp, const unsigned char receiver[6],
                                const unsigned char transmitter[6], const char *ssid, uint8_t channel);
 
 /**
@@ -49,10 +49,14 @@ int libwifi_create_reassoc_req(struct libwifi_reassoc_req *reassoc_req, const un
     reassoc_req->fixed_parameters.listen_interval = BYTESWAP16(LIBWIFI_DEFAULT_LISTEN_INTERVAL);
     memcpy(&reassoc_req->fixed_parameters.current_ap_address, current_ap, 6);
 
-    libwifi_quick_add_tag(&reassoc_req->tags, TAG_SSID, (const unsigned char *) ssid, strlen(ssid));
-    libwifi_quick_add_tag(&reassoc_req->tags, TAG_DS_PARAMETER, (const unsigned char *) &channel, 1);
+    int ret = libwifi_quick_add_tag(&reassoc_req->tags, TAG_SSID, (const unsigned char *) ssid, strlen(ssid));
+    if (ret != 0) {
+        return ret;
+    }
+
+    ret = libwifi_quick_add_tag(&reassoc_req->tags, TAG_DS_PARAMETER, (const unsigned char *) &channel, 1);
 
-    return 0;
+    return ret;
 }
 
 /**
@@ -41,21 +41,27 @@ size_t libwifi_get_reassoc_resp_length(struct libwifi_reassoc_resp *reassoc_resp
  * Simple helper to set the reassociation response DS tag by removing it and then adding it back with the new
  * value.
  */
-void libwifi_set_reassoc_resp_channel(struct libwifi_reassoc_resp *reassoc_resp, uint8_t channel) {
+int libwifi_set_reassoc_resp_channel(struct libwifi_reassoc_resp *reassoc_resp, uint8_t channel) {
+    int ret = 0;
+
     if (reassoc_resp->tags.length != 0) {
-        libwifi_remove_tag(&reassoc_resp->tags, TAG_DS_PARAMETER);
+        ret = libwifi_remove_tag(&reassoc_resp->tags, TAG_DS_PARAMETER);
+        if (ret != 0) {
+            return ret;
+        }
     }
 
     const unsigned char *chan = (const unsigned char *) &channel;
+    ret = libwifi_quick_add_tag(&reassoc_resp->tags, TAG_DS_PARAMETER, chan, 1);
 
-    libwifi_quick_add_tag(&reassoc_resp->tags, TAG_DS_PARAMETER, chan, 1);
+    return ret;
 }
 
 /**
  * The generated reassoc_resp frame is made with sane defaults defined in common.h.
  * Three tagged parameters are also added to the reassoc_resp: SSID, Channel and Supported Rates.
  */
-void libwifi_create_reassoc_resp(struct libwifi_reassoc_resp *reassoc_resp, const unsigned char receiver[6],
+int libwifi_create_reassoc_resp(struct libwifi_reassoc_resp *reassoc_resp, const unsigned char receiver[6],
                                  const unsigned char transmitter[6], uint8_t channel) {
     memset(reassoc_resp, 0, sizeof(struct libwifi_reassoc_resp));
 
@@ -68,10 +74,15 @@ void libwifi_create_reassoc_resp(struct libwifi_reassoc_resp *reassoc_resp, cons
     reassoc_resp->fixed_parameters.status_code = STATUS_SUCCESS;
     reassoc_resp->fixed_parameters.association_id = rand() % 4096;
 
-    libwifi_set_reassoc_resp_channel(reassoc_resp, channel);
+    int ret = libwifi_set_reassoc_resp_channel(reassoc_resp, channel);
+    if (ret != 0) {
+        return ret;
+    }
 
     const unsigned char supported_rates[] = LIBWIFI_DEFAULT_SUPP_RATES;
-    libwifi_quick_add_tag(&reassoc_resp->tags, TAG_SUPP_RATES, supported_rates, sizeof(supported_rates) - 1);
+    ret = libwifi_quick_add_tag(&reassoc_resp->tags, TAG_SUPP_RATES, supported_rates, sizeof(supported_rates) - 1);
+
+    return ret;
 }
 
 /**
@@ -24,7 +24,7 @@
  * @param reassoc_resp A libwifi_reassoc_resp
  * @param channel The new channel
  */
-void libwifi_set_reassoc_resp_channel(struct libwifi_reassoc_resp *reassoc_resp, uint8_t channel);
+int libwifi_set_reassoc_resp_channel(struct libwifi_reassoc_resp *reassoc_resp, uint8_t channel);
 
 /**
  * Calculate the length of a given libwifi_reassoc_resp
@@ -46,7 +46,7 @@ size_t libwifi_get_reassoc_resp_length(struct libwifi_reassoc_resp *reassoc_resp
  * @param channel The desired channel of the reassoc_resp
  *
  */
-void libwifi_create_reassoc_resp(struct libwifi_reassoc_resp *reassoc_resp, const unsigned char receiver[6],
+int libwifi_create_reassoc_resp(struct libwifi_reassoc_resp *reassoc_resp, const unsigned char receiver[6],
                                  const unsigned char transmitter[6], uint8_t channel);
 
 /**
@@ -19,10 +19,11 @@
 #include "../../core/misc/epoch.h"
 #include "../../core/frame/tag.h"
 
+#include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 
-void libwifi_create_timing_advert(struct libwifi_timing_advert *adv, const unsigned char destination[6],
+int libwifi_create_timing_advert(struct libwifi_timing_advert *adv, const unsigned char destination[6],
                                   const unsigned char transmitter[6], struct libwifi_timing_advert_fields *adv_fields,
                                   const char country[3], uint16_t max_reg_power, uint8_t max_tx_power, uint8_t tx_power_used,
                                   uint8_t noise_floor) {
@@ -45,7 +46,7 @@ void libwifi_create_timing_advert(struct libwifi_timing_advert *adv, const unsig
     adv->fixed_parameters.noise_floor = noise_floor;
 
     if (adv_fields == NULL) {
-        return;
+        return -EINVAL;
     }
 
     // Maximum element size is 17
@@ -78,7 +79,9 @@ void libwifi_create_timing_advert(struct libwifi_timing_advert *adv, const unsig
 
     element_data_len = offset;
 
-    libwifi_quick_add_tag(&adv->tags, TAG_TIME_ADVERTISEMENT, element_data, element_data_len);
+    int ret = libwifi_quick_add_tag(&adv->tags, TAG_TIME_ADVERTISEMENT, element_data, element_data_len);
+
+    return ret;
 }
 
 size_t libwifi_get_timing_advert_length(struct libwifi_timing_advert *adv) {
@@ -18,7 +18,7 @@
 
 #include "../../core/frame/management/timing_ad.h"
 
-void libwifi_create_timing_advert(struct libwifi_timing_advert *adv, const unsigned char destination[6],
+int libwifi_create_timing_advert(struct libwifi_timing_advert *adv, const unsigned char destination[6],
                                   const unsigned char transmitter[6], struct libwifi_timing_advert_fields *adv_fields,
                                   const char country[3], uint16_t max_reg_power, uint8_t max_tx_power, uint8_t tx_power_used,
                                   uint8_t noise_floor);
@@ -7,10 +7,69 @@ set(CMAKE_CXX_STANDARD_REQUIRED True)
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ggdb -O0")
 
-add_executable(test_misc src/helpers.c src/test_misc.c)
-add_executable(test_generation src/helpers.c src/test_generation.c)
-add_executable(test_parsing src/helpers.c src/test_parsing.c)
+link_directories("../build/")
 
-target_link_libraries(test_misc wifi)
-target_link_libraries(test_generation wifi pcap)
-target_link_libraries(test_parsing wifi pcap)
+add_executable(action_tests src/action_tests.c)
+target_link_libraries(action_tests wifi)
+add_executable(assoc_req_tests src/assoc_req_tests.c)
+target_link_libraries(assoc_req_tests wifi)
+add_executable(assoc_resp_tests src/assoc_resp_tests.c)
+target_link_libraries(assoc_resp_tests wifi)
+add_executable(atim_tests src/atim_tests.c)
+target_link_libraries(atim_tests wifi)
+add_executable(auth_tests src/auth_tests.c)
+target_link_libraries(auth_tests wifi)
+add_executable(beacon_tests src/beacon_tests.c)
+target_link_libraries(beacon_tests wifi)
+add_executable(deauth_tests src/deauth_tests.c)
+target_link_libraries(deauth_tests wifi)
+add_executable(disassoc_tests src/disassoc_tests.c)
+target_link_libraries(disassoc_tests wifi)
+add_executable(probe_req_tests src/probe_req_tests.c)
+target_link_libraries(probe_req_tests wifi)
+add_executable(probe_resp_tests src/probe_resp_tests.c)
+target_link_libraries(probe_resp_tests wifi)
+add_executable(reassoc_req_tests src/reassoc_req_tests.c)
+target_link_libraries(reassoc_req_tests wifi)
+add_executable(reassoc_resp_tests src/reassoc_resp_tests.c)
+target_link_libraries(reassoc_resp_tests wifi)
+add_executable(timing_ad_tests src/timing_ad_tests.c)
+target_link_libraries(timing_ad_tests wifi)
+
+enable_testing()
+add_test(NAME test_action_gen_full COMMAND action_tests --action-gen-full)
+add_test(NAME test_action_gen_details COMMAND action_tests --action-gen-details)
+
+add_test(NAME test_assoc_req_gen_full COMMAND assoc_req_tests --assoc_req-gen-full)
+add_test(NAME test_assoc_req_gen_tags COMMAND assoc_req_tests --assoc_req-gen-tags)
+
+add_test(NAME test_assoc_resp_gen_full COMMAND assoc_resp_tests --assoc_resp-gen-full)
+add_test(NAME test_assoc_resp_gen_tags COMMAND assoc_resp_tests --assoc_resp-gen-tags)
+
+add_test(NAME test_atim_gen_full COMMAND atim_tests --atim-gen-full)
+
+add_test(NAME test_auth_gen_full COMMAND auth_tests --auth-gen-full)
+add_test(NAME test_auth_gen_tags COMMAND auth_tests --auth-gen-tags)
+
+add_test(NAME test_beacon_gen_full COMMAND beacon_tests --beacon-gen-full)
+add_test(NAME test_beacon_gen_tags COMMAND beacon_tests --beacon-gen-tags)
+
+add_test(NAME test_deauth_gen_full COMMAND deauth_tests --deauth-gen-full)
+add_test(NAME test_deauth_gen_tags COMMAND deauth_tests --deauth-gen-tags)
+
+add_test(NAME test_disassoc_gen_full COMMAND disassoc_tests --disassoc-gen-full)
+add_test(NAME test_disassoc_gen_tags COMMAND disassoc_tests --disassoc-gen-tags)
+
+add_test(NAME test_probe_req_gen_full COMMAND probe_req_tests --probe_req-gen-full)
+add_test(NAME test_probe_req_gen_tags COMMAND probe_req_tests --probe_req-gen-tags)
+
+add_test(NAME test_probe_resp_gen_full COMMAND probe_resp_tests --probe_resp-gen-full)
+add_test(NAME test_probe_resp_gen_tags COMMAND probe_resp_tests --probe_resp-gen-tags)
+
+add_test(NAME test_reassoc_req_gen_full COMMAND reassoc_req_tests --reassoc_req-gen-full)
+add_test(NAME test_reassoc_req_gen_tags COMMAND reassoc_req_tests --reassoc_req-gen-tags)
+
+add_test(NAME test_reassoc_resp_gen_full COMMAND reassoc_resp_tests --reassoc_resp-gen-full)
+add_test(NAME test_reassoc_resp_gen_tags COMMAND reassoc_resp_tests --reassoc_resp-gen-tags)
+
+add_test(NAME test_timing_ad_gen_tags COMMAND timing_ad_tests --timing_ad-gen-full)
@@ -0,0 +1,69 @@
+# libwifi Tests
+libwifi uses CMakes testing functionalities. The tests are in the `src/` directory, and can be used with `make test`.
+
+## Running Tests
+```
+>> mkdir build
+>> cd build
+>> cmake ..
+>> make && make test
+```
+
+## Expected Output
+```
+>> make test
+Running tests...
+Test project libwifi/test/build
+      Start  1: test_action_gen_full
+ 1/24 Test  #1: test_action_gen_full .............   Passed    0.00 sec
+      Start  2: test_action_gen_details
+ 2/24 Test  #2: test_action_gen_details ..........   Passed    0.00 sec
+      Start  3: test_assoc_req_gen_full
+ 3/24 Test  #3: test_assoc_req_gen_full ..........   Passed    0.00 sec
+      Start  4: test_assoc_req_gen_tags
+ 4/24 Test  #4: test_assoc_req_gen_tags ..........   Passed    0.00 sec
+      Start  5: test_assoc_resp_gen_full
+ 5/24 Test  #5: test_assoc_resp_gen_full .........   Passed    0.00 sec
+      Start  6: test_assoc_resp_gen_tags
+ 6/24 Test  #6: test_assoc_resp_gen_tags .........   Passed    0.00 sec
+      Start  7: test_atim_gen_full
+ 7/24 Test  #7: test_atim_gen_full ...............   Passed    0.00 sec
+      Start  8: test_auth_gen_full
+ 8/24 Test  #8: test_auth_gen_full ...............   Passed    0.00 sec
+      Start  9: test_auth_gen_tags
+ 9/24 Test  #9: test_auth_gen_tags ...............   Passed    0.00 sec
+      Start 10: test_beacon_gen_full
+10/24 Test #10: test_beacon_gen_full .............   Passed    0.00 sec
+      Start 11: test_beacon_gen_tags
+11/24 Test #11: test_beacon_gen_tags .............   Passed    0.00 sec
+      Start 12: test_deauth_gen_full
+12/24 Test #12: test_deauth_gen_full .............   Passed    0.00 sec
+      Start 13: test_deauth_gen_tags
+13/24 Test #13: test_deauth_gen_tags .............   Passed    0.00 sec
+      Start 14: test_disassoc_gen_full
+14/24 Test #14: test_disassoc_gen_full ...........   Passed    0.00 sec
+      Start 15: test_disassoc_gen_tags
+15/24 Test #15: test_disassoc_gen_tags ...........   Passed    0.00 sec
+      Start 16: test_probe_req_gen_full
+16/24 Test #16: test_probe_req_gen_full ..........   Passed    0.00 sec
+      Start 17: test_probe_req_gen_tags
+17/24 Test #17: test_probe_req_gen_tags ..........   Passed    0.00 sec
+      Start 18: test_probe_resp_gen_full
+18/24 Test #18: test_probe_resp_gen_full .........   Passed    0.00 sec
+      Start 19: test_probe_resp_gen_tags
+19/24 Test #19: test_probe_resp_gen_tags .........   Passed    0.00 sec
+      Start 20: test_reassoc_req_gen_full
+20/24 Test #20: test_reassoc_req_gen_full ........   Passed    0.00 sec
+      Start 21: test_reassoc_req_gen_tags
+21/24 Test #21: test_reassoc_req_gen_tags ........   Passed    0.00 sec
+      Start 22: test_reassoc_resp_gen_full
+22/24 Test #22: test_reassoc_resp_gen_full .......   Passed    0.00 sec
+      Start 23: test_reassoc_resp_gen_tags
+23/24 Test #23: test_reassoc_resp_gen_tags .......   Passed    0.00 sec
+      Start 24: test_timing_ad_gen_tags
+24/24 Test #24: test_timing_ad_gen_tags ..........   Passed    0.00 sec
+
+100% tests passed, 0 tests failed out of 24
+
+Total Test time (real) =   0.06 sec
+```
@@ -0,0 +1,87 @@
+#include "../../src/libwifi.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#define BCAST_MAC "\xff\xff\xff\xff\xff\xff"
+#define TO_MAC "\x00\x20\x91\xAA\xBB\xCC"
+const unsigned char to[] = TO_MAC;
+const unsigned char bcast[] = BCAST_MAC;
+
+int test_action_gen_full() {
+    struct libwifi_action action = {0};
+
+    int ret = libwifi_create_action(&action, bcast, to, ACTION_HT);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create action: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int action_len = libwifi_get_action_length(&action);
+    if (action_len <= 0) {
+        fprintf(stderr, "Invalid action length: %d\n", action_len);
+        return action_len;
+    }
+
+    unsigned char *buf = malloc(action_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_action(&action, buf, action_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump action\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int test_action_add_detail() {
+    struct libwifi_action action = {0};
+
+    int ret = libwifi_create_action(&action, bcast, to, ACTION_HT);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create action: %s\n", strerror(ret));
+        return ret;
+    }
+
+    ret = libwifi_add_action_detail(&action.fixed_parameters.details, (const unsigned char *) "HELLO WORLD", strlen("HELLO WORLD"));
+
+    int action_len = libwifi_get_action_length(&action);
+    if (action_len <= 0) {
+        fprintf(stderr, "Invalid action length: %d\n", action_len);
+        return action_len;
+    }
+
+    unsigned char *buf = malloc(action_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_action(&action, buf, action_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump action\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        printf("Specify test\n");
+        return -1;
+    }
+
+    if (strcmp(argv[1], "--action-gen-full") == 0) {
+        return test_action_gen_full();
+    } else if (strcmp(argv[1], "--action-gen-details") == 0) {
+        return test_action_add_detail();
+    }
+
+    return -1;
+}
@@ -0,0 +1,91 @@
+#include "../../src/libwifi.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#define BCAST_MAC "\xff\xff\xff\xff\xff\xff"
+#define TO_MAC "\x00\x20\x91\xAA\xBB\xCC"
+const unsigned char to[] = TO_MAC;
+const unsigned char bcast[] = BCAST_MAC;
+
+int test_assoc_req_gen_full() {
+    struct libwifi_assoc_req assoc_req = {0};
+
+    int ret = libwifi_create_assoc_req(&assoc_req, bcast, to, "Some SSID", 11);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create assoc_req: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int assoc_req_len = libwifi_get_assoc_req_length(&assoc_req);
+    if (assoc_req_len <= 0) {
+        fprintf(stderr, "Invalid assoc_req length: %d\n", assoc_req_len);
+        return assoc_req_len;
+    }
+
+    unsigned char *buf = malloc(assoc_req_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_assoc_req(&assoc_req, buf, assoc_req_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump assoc_req\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int test_assoc_req_add_tag() {
+    struct libwifi_assoc_req assoc_req = {0};
+
+    int ret = libwifi_create_assoc_req(&assoc_req, bcast, to, "Some SSID", 11);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create assoc_req: %s\n", strerror(ret));
+        return ret;
+    }
+
+    ret = libwifi_quick_add_tag(&assoc_req.tags, TAG_VENDOR_SPECIFIC, (const unsigned char *) "\x00\x11\x22\xAAHello World", 15);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to add assoc_req tagged parameter: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int assoc_req_len = libwifi_get_assoc_req_length(&assoc_req);
+    if (assoc_req_len <= 0) {
+        fprintf(stderr, "Invalid assoc_req length: %d\n", assoc_req_len);
+        return assoc_req_len;
+    }
+
+    unsigned char *buf = malloc(assoc_req_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_assoc_req(&assoc_req, buf, assoc_req_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump assoc_req\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        printf("Specify test\n");
+        return -1;
+    }
+
+    if (strcmp(argv[1], "--assoc_req-gen-full") == 0) {
+        return test_assoc_req_gen_full();
+    } else if (strcmp(argv[1], "--assoc_req-gen-tags") == 0) {
+        return test_assoc_req_add_tag();
+    }
+
+    return -1;
+}
@@ -0,0 +1,91 @@
+#include "../../src/libwifi.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#define BCAST_MAC "\xff\xff\xff\xff\xff\xff"
+#define TO_MAC "\x00\x20\x91\xAA\xBB\xCC"
+const unsigned char to[] = TO_MAC;
+const unsigned char bcast[] = BCAST_MAC;
+
+int test_assoc_resp_gen_full() {
+    struct libwifi_assoc_resp assoc_resp = {0};
+
+    int ret = libwifi_create_assoc_resp(&assoc_resp, bcast, to, 11);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create assoc_resp: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int assoc_resp_len = libwifi_get_assoc_resp_length(&assoc_resp);
+    if (assoc_resp_len <= 0) {
+        fprintf(stderr, "Invalid assoc_resp length: %d\n", assoc_resp_len);
+        return assoc_resp_len;
+    }
+
+    unsigned char *buf = malloc(assoc_resp_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_assoc_resp(&assoc_resp, buf, assoc_resp_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump assoc_resp\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int test_assoc_resp_add_tag() {
+    struct libwifi_assoc_resp assoc_resp = {0};
+
+    int ret = libwifi_create_assoc_resp(&assoc_resp, bcast, to, 11);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create assoc_resp: %s\n", strerror(ret));
+        return ret;
+    }
+
+    ret = libwifi_quick_add_tag(&assoc_resp.tags, TAG_VENDOR_SPECIFIC, (const unsigned char *) "\x00\x11\x22\xAAHello World", 15);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to add assoc_resp tagged parameter: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int assoc_resp_len = libwifi_get_assoc_resp_length(&assoc_resp);
+    if (assoc_resp_len <= 0) {
+        fprintf(stderr, "Invalid assoc_resp length: %d\n", assoc_resp_len);
+        return assoc_resp_len;
+    }
+
+    unsigned char *buf = malloc(assoc_resp_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_assoc_resp(&assoc_resp, buf, assoc_resp_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump assoc_resp\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        printf("Specify test\n");
+        return -1;
+    }
+
+    if (strcmp(argv[1], "--assoc_resp-gen-full") == 0) {
+        return test_assoc_resp_gen_full();
+    } else if (strcmp(argv[1], "--assoc_resp-gen-tags") == 0) {
+        return test_assoc_resp_add_tag();
+    }
+
+    return -1;
+}
@@ -0,0 +1,35 @@
+#include "../../src/libwifi.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#define BCAST_MAC "\xff\xff\xff\xff\xff\xff"
+#define TO_MAC "\x00\x20\x91\xAA\xBB\xCC"
+const unsigned char to[] = TO_MAC;
+const unsigned char bcast[] = BCAST_MAC;
+
+int test_atim_gen_full() {
+    struct libwifi_atim atim = {0};
+
+    int ret = libwifi_create_atim(&atim, bcast, to, to);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create atim: %s\n", strerror(ret));
+        return ret;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        printf("Specify test\n");
+        return -1;
+    }
+
+    if (strcmp(argv[1], "--atim-gen-full") == 0) {
+        return test_atim_gen_full();
+    }
+
+    return -1;
+}
@@ -0,0 +1,91 @@
+#include "../../src/libwifi.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#define BCAST_MAC "\xff\xff\xff\xff\xff\xff"
+#define TO_MAC "\x00\x20\x91\xAA\xBB\xCC"
+const unsigned char to[] = TO_MAC;
+const unsigned char bcast[] = BCAST_MAC;
+
+int test_auth_gen_full() {
+    struct libwifi_auth auth = {0};
+
+    int ret = libwifi_create_auth(&auth, bcast, to, 0, 100, STATUS_SUCCESS);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create auth: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int auth_len = libwifi_get_auth_length(&auth);
+    if (auth_len <= 0) {
+        fprintf(stderr, "Invalid auth length: %d\n", auth_len);
+        return auth_len;
+    }
+
+    unsigned char *buf = malloc(auth_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_auth(&auth, buf, auth_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump auth\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int test_auth_add_tag() {
+    struct libwifi_auth auth = {0};
+
+    int ret = libwifi_create_auth(&auth, bcast, to, 0, 100, STATUS_SUCCESS);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create auth: %s\n", strerror(ret));
+        return ret;
+    }
+
+    ret = libwifi_quick_add_tag(&auth.tags, TAG_VENDOR_SPECIFIC, (const unsigned char *) "\x00\x11\x22\xAAHello World", 15);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to add auth tagged parameter: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int auth_len = libwifi_get_auth_length(&auth);
+    if (auth_len <= 0) {
+        fprintf(stderr, "Invalid auth length: %d\n", auth_len);
+        return auth_len;
+    }
+
+    unsigned char *buf = malloc(auth_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_auth(&auth, buf, auth_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump auth\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        printf("Specify test\n");
+        return -1;
+    }
+
+    if (strcmp(argv[1], "--auth-gen-full") == 0) {
+        return test_auth_gen_full();
+    } else if (strcmp(argv[1], "--auth-gen-tags") == 0) {
+        return test_auth_add_tag();
+    }
+
+    return -1;
+}
@@ -0,0 +1,91 @@
+#include "../../src/libwifi.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#define BCAST_MAC "\xff\xff\xff\xff\xff\xff"
+#define TO_MAC "\x00\x20\x91\xAA\xBB\xCC"
+const unsigned char to[] = TO_MAC;
+const unsigned char bcast[] = BCAST_MAC;
+
+int test_beacon_gen_full() {
+    struct libwifi_beacon beacon = {0};
+
+    int ret = libwifi_create_beacon(&beacon, bcast, to, "Some SSID", 11);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create beacon: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int beacon_len = libwifi_get_beacon_length(&beacon);
+    if (beacon_len <= 0) {
+        fprintf(stderr, "Invalid beacon length: %d\n", beacon_len);
+        return beacon_len;
+    }
+
+    unsigned char *buf = malloc(beacon_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_beacon(&beacon, buf, beacon_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump beacon\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int test_beacon_add_tag() {
+    struct libwifi_beacon beacon = {0};
+
+    int ret = libwifi_create_beacon(&beacon, bcast, to, "Some SSID", 11);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create beacon: %s\n", strerror(ret));
+        return ret;
+    }
+
+    ret = libwifi_quick_add_tag(&beacon.tags, TAG_VENDOR_SPECIFIC, (const unsigned char *) "\x00\x11\x22\xAAHello World", 15);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to add beacon tagged parameter: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int beacon_len = libwifi_get_beacon_length(&beacon);
+    if (beacon_len <= 0) {
+        fprintf(stderr, "Invalid beacon length: %d\n", beacon_len);
+        return beacon_len;
+    }
+
+    unsigned char *buf = malloc(beacon_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_beacon(&beacon, buf, beacon_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump beacon\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        printf("Specify test\n");
+        return -1;
+    }
+
+    if (strcmp(argv[1], "--beacon-gen-full") == 0) {
+        return test_beacon_gen_full();
+    } else if (strcmp(argv[1], "--beacon-gen-tags") == 0) {
+        return test_beacon_add_tag();
+    }
+
+    return -1;
+}
@@ -0,0 +1,91 @@
+#include "../../src/libwifi.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#define BCAST_MAC "\xff\xff\xff\xff\xff\xff"
+#define TO_MAC "\x00\x20\x91\xAA\xBB\xCC"
+const unsigned char to[] = TO_MAC;
+const unsigned char bcast[] = BCAST_MAC;
+
+int test_deauth_gen_full() {
+    struct libwifi_deauth deauth = {0};
+
+    int ret = libwifi_create_deauth(&deauth, bcast, to, REASON_STA_LEAVING);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create deauth: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int deauth_len = libwifi_get_deauth_length(&deauth);
+    if (deauth_len <= 0) {
+        fprintf(stderr, "Invalid deauth length: %d\n", deauth_len);
+        return deauth_len;
+    }
+
+    unsigned char *buf = malloc(deauth_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_deauth(&deauth, buf, deauth_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump deauth\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int test_deauth_add_tag() {
+    struct libwifi_deauth deauth = {0};
+
+    int ret = libwifi_create_deauth(&deauth, bcast, to, REASON_STA_LEAVING);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create deauth: %s\n", strerror(ret));
+        return ret;
+    }
+
+    ret = libwifi_quick_add_tag(&deauth.tags, TAG_VENDOR_SPECIFIC, (const unsigned char *) "\x00\x11\x22\xAAHello World", 15);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to add deauth tagged parameter: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int deauth_len = libwifi_get_deauth_length(&deauth);
+    if (deauth_len <= 0) {
+        fprintf(stderr, "Invalid deauth length: %d\n", deauth_len);
+        return deauth_len;
+    }
+
+    unsigned char *buf = malloc(deauth_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_deauth(&deauth, buf, deauth_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump deauth\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        printf("Specify test\n");
+        return -1;
+    }
+
+    if (strcmp(argv[1], "--deauth-gen-full") == 0) {
+        return test_deauth_gen_full();
+    } else if (strcmp(argv[1], "--deauth-gen-tags") == 0) {
+        return test_deauth_add_tag();
+    }
+
+    return -1;
+}
@@ -0,0 +1,91 @@
+#include "../../src/libwifi.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#define BCAST_MAC "\xff\xff\xff\xff\xff\xff"
+#define TO_MAC "\x00\x20\x91\xAA\xBB\xCC"
+const unsigned char to[] = TO_MAC;
+const unsigned char bcast[] = BCAST_MAC;
+
+int test_disassoc_gen_full() {
+    struct libwifi_disassoc disassoc = {0};
+
+    int ret = libwifi_create_disassoc(&disassoc, bcast, to, REASON_STA_LEAVING);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create disassoc: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int disassoc_len = libwifi_get_disassoc_length(&disassoc);
+    if (disassoc_len <= 0) {
+        fprintf(stderr, "Invalid disassoc length: %d\n", disassoc_len);
+        return disassoc_len;
+    }
+
+    unsigned char *buf = malloc(disassoc_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_disassoc(&disassoc, buf, disassoc_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump disassoc\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int test_disassoc_add_tag() {
+    struct libwifi_disassoc disassoc = {0};
+
+    int ret = libwifi_create_disassoc(&disassoc, bcast, to, REASON_STA_LEAVING);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create disassoc: %s\n", strerror(ret));
+        return ret;
+    }
+
+    ret = libwifi_quick_add_tag(&disassoc.tags, TAG_VENDOR_SPECIFIC, (const unsigned char *) "\x00\x11\x22\xAAHello World", 15);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to add disassoc tagged parameter: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int disassoc_len = libwifi_get_disassoc_length(&disassoc);
+    if (disassoc_len <= 0) {
+        fprintf(stderr, "Invalid disassoc length: %d\n", disassoc_len);
+        return disassoc_len;
+    }
+
+    unsigned char *buf = malloc(disassoc_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_disassoc(&disassoc, buf, disassoc_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump disassoc\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        printf("Specify test\n");
+        return -1;
+    }
+
+    if (strcmp(argv[1], "--disassoc-gen-full") == 0) {
+        return test_disassoc_gen_full();
+    } else if (strcmp(argv[1], "--disassoc-gen-tags") == 0) {
+        return test_disassoc_add_tag();
+    }
+
+    return -1;
+}
@@ -0,0 +1,91 @@
+#include "../../src/libwifi.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#define BCAST_MAC "\xff\xff\xff\xff\xff\xff"
+#define TO_MAC "\x00\x20\x91\xAA\xBB\xCC"
+const unsigned char to[] = TO_MAC;
+const unsigned char bcast[] = BCAST_MAC;
+
+int test_probe_req_gen_full() {
+    struct libwifi_probe_req probe_req = {0};
+
+    int ret = libwifi_create_probe_req(&probe_req, bcast, to, to, "Some SSID", 11);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create probe_req: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int probe_req_len = libwifi_get_probe_req_length(&probe_req);
+    if (probe_req_len <= 0) {
+        fprintf(stderr, "Invalid probe_req length: %d\n", probe_req_len);
+        return probe_req_len;
+    }
+
+    unsigned char *buf = malloc(probe_req_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_probe_req(&probe_req, buf, probe_req_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump probe_req\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int test_probe_req_add_tag() {
+    struct libwifi_probe_req probe_req = {0};
+
+    int ret = libwifi_create_probe_req(&probe_req, bcast, to, to, "Some SSID", 11);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create probe_req: %s\n", strerror(ret));
+        return ret;
+    }
+
+    ret = libwifi_quick_add_tag(&probe_req.tags, TAG_VENDOR_SPECIFIC, (const unsigned char *) "\x00\x11\x22\xAAHello World", 15);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to add probe_req tagged parameter: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int probe_req_len = libwifi_get_probe_req_length(&probe_req);
+    if (probe_req_len <= 0) {
+        fprintf(stderr, "Invalid probe_req length: %d\n", probe_req_len);
+        return probe_req_len;
+    }
+
+    unsigned char *buf = malloc(probe_req_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_probe_req(&probe_req, buf, probe_req_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump probe_req\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        printf("Specify test\n");
+        return -1;
+    }
+
+    if (strcmp(argv[1], "--probe_req-gen-full") == 0) {
+        return test_probe_req_gen_full();
+    } else if (strcmp(argv[1], "--probe_req-gen-tags") == 0) {
+        return test_probe_req_add_tag();
+    }
+
+    return -1;
+}
@@ -0,0 +1,91 @@
+#include "../../src/libwifi.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#define BCAST_MAC "\xff\xff\xff\xff\xff\xff"
+#define TO_MAC "\x00\x20\x91\xAA\xBB\xCC"
+const unsigned char to[] = TO_MAC;
+const unsigned char bcast[] = BCAST_MAC;
+
+int test_probe_resp_gen_full() {
+    struct libwifi_probe_resp probe_resp = {0};
+
+    int ret = libwifi_create_probe_resp(&probe_resp, bcast, to, "Some SSID", 11);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create probe_resp: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int probe_resp_len = libwifi_get_probe_resp_length(&probe_resp);
+    if (probe_resp_len <= 0) {
+        fprintf(stderr, "Invalid probe_resp length: %d\n", probe_resp_len);
+        return probe_resp_len;
+    }
+
+    unsigned char *buf = malloc(probe_resp_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_probe_resp(&probe_resp, buf, probe_resp_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump probe_resp\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int test_probe_resp_add_tag() {
+    struct libwifi_probe_resp probe_resp = {0};
+
+    int ret = libwifi_create_probe_resp(&probe_resp, bcast, to, "Some SSID", 11);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create probe_resp: %s\n", strerror(ret));
+        return ret;
+    }
+
+    ret = libwifi_quick_add_tag(&probe_resp.tags, TAG_VENDOR_SPECIFIC, (const unsigned char *) "\x00\x11\x22\xAAHello World", 15);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to add probe_resp tagged parameter: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int probe_resp_len = libwifi_get_probe_resp_length(&probe_resp);
+    if (probe_resp_len <= 0) {
+        fprintf(stderr, "Invalid probe_resp length: %d\n", probe_resp_len);
+        return probe_resp_len;
+    }
+
+    unsigned char *buf = malloc(probe_resp_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_probe_resp(&probe_resp, buf, probe_resp_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump probe_resp\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        printf("Specify test\n");
+        return -1;
+    }
+
+    if (strcmp(argv[1], "--probe_resp-gen-full") == 0) {
+        return test_probe_resp_gen_full();
+    } else if (strcmp(argv[1], "--probe_resp-gen-tags") == 0) {
+        return test_probe_resp_add_tag();
+    }
+
+    return -1;
+}
@@ -0,0 +1,91 @@
+#include "../../src/libwifi.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#define BCAST_MAC "\xff\xff\xff\xff\xff\xff"
+#define TO_MAC "\x00\x20\x91\xAA\xBB\xCC"
+const unsigned char to[] = TO_MAC;
+const unsigned char bcast[] = BCAST_MAC;
+
+int test_reassoc_req_gen_full() {
+    struct libwifi_reassoc_req reassoc_req = {0};
+
+    int ret = libwifi_create_reassoc_req(&reassoc_req, bcast, to, to, "Some SSID", 11);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create reassoc_req: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int reassoc_req_len = libwifi_get_reassoc_req_length(&reassoc_req);
+    if (reassoc_req_len <= 0) {
+        fprintf(stderr, "Invalid reassoc_req length: %d\n", reassoc_req_len);
+        return reassoc_req_len;
+    }
+
+    unsigned char *buf = malloc(reassoc_req_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_reassoc_req(&reassoc_req, buf, reassoc_req_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump reassoc_req\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int test_reassoc_req_add_tag() {
+    struct libwifi_reassoc_req reassoc_req = {0};
+
+    int ret = libwifi_create_reassoc_req(&reassoc_req, bcast, to, to, "Some SSID", 11);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create reassoc_req: %s\n", strerror(ret));
+        return ret;
+    }
+
+    ret = libwifi_quick_add_tag(&reassoc_req.tags, TAG_VENDOR_SPECIFIC, (const unsigned char *) "\x00\x11\x22\xAAHello World", 15);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to add reassoc_req tagged parameter: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int reassoc_req_len = libwifi_get_reassoc_req_length(&reassoc_req);
+    if (reassoc_req_len <= 0) {
+        fprintf(stderr, "Invalid reassoc_req length: %d\n", reassoc_req_len);
+        return reassoc_req_len;
+    }
+
+    unsigned char *buf = malloc(reassoc_req_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_reassoc_req(&reassoc_req, buf, reassoc_req_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump reassoc_req\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        printf("Specify test\n");
+        return -1;
+    }
+
+    if (strcmp(argv[1], "--reassoc_req-gen-full") == 0) {
+        return test_reassoc_req_gen_full();
+    } else if (strcmp(argv[1], "--reassoc_req-gen-tags") == 0) {
+        return test_reassoc_req_add_tag();
+    }
+
+    return -1;
+}
@@ -0,0 +1,91 @@
+#include "../../src/libwifi.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#define BCAST_MAC "\xff\xff\xff\xff\xff\xff"
+#define TO_MAC "\x00\x20\x91\xAA\xBB\xCC"
+const unsigned char to[] = TO_MAC;
+const unsigned char bcast[] = BCAST_MAC;
+
+int test_reassoc_resp_gen_full() {
+    struct libwifi_reassoc_resp reassoc_resp = {0};
+
+    int ret = libwifi_create_reassoc_resp(&reassoc_resp, bcast, to, 11);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create reassoc_resp: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int reassoc_resp_len = libwifi_get_reassoc_resp_length(&reassoc_resp);
+    if (reassoc_resp_len <= 0) {
+        fprintf(stderr, "Invalid reassoc_resp length: %d\n", reassoc_resp_len);
+        return reassoc_resp_len;
+    }
+
+    unsigned char *buf = malloc(reassoc_resp_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_reassoc_resp(&reassoc_resp, buf, reassoc_resp_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump reassoc_resp\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int test_reassoc_resp_add_tag() {
+    struct libwifi_reassoc_resp reassoc_resp = {0};
+
+    int ret = libwifi_create_reassoc_resp(&reassoc_resp, bcast, to, 11);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create reassoc_resp: %s\n", strerror(ret));
+        return ret;
+    }
+
+    ret = libwifi_quick_add_tag(&reassoc_resp.tags, TAG_VENDOR_SPECIFIC, (const unsigned char *) "\x00\x11\x22\xAAHello World", 15);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to add reassoc_resp tagged parameter: %s\n", strerror(ret));
+        return ret;
+    }
+
+    int reassoc_resp_len = libwifi_get_reassoc_resp_length(&reassoc_resp);
+    if (reassoc_resp_len <= 0) {
+        fprintf(stderr, "Invalid reassoc_resp length: %d\n", reassoc_resp_len);
+        return reassoc_resp_len;
+    }
+
+    unsigned char *buf = malloc(reassoc_resp_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to allocate buffer\n");
+        return -1;
+    }
+
+    int dump_len = libwifi_dump_reassoc_resp(&reassoc_resp, buf, reassoc_resp_len);
+    if (dump_len <= 0) {
+        fprintf(stderr, "Failed to dump reassoc_resp\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        printf("Specify test\n");
+        return -1;
+    }
+
+    if (strcmp(argv[1], "--reassoc_resp-gen-full") == 0) {
+        return test_reassoc_resp_gen_full();
+    } else if (strcmp(argv[1], "--reassoc_resp-gen-tags") == 0) {
+        return test_reassoc_resp_add_tag();
+    }
+
+    return -1;
+}
@@ -0,0 +1,57 @@
+#include "../../src/libwifi.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#define BCAST_MAC "\xff\xff\xff\xff\xff\xff"
+#define TO_MAC "\x00\x20\x91\xAA\xBB\xCC"
+const unsigned char to[] = TO_MAC;
+const unsigned char bcast[] = BCAST_MAC;
+
+int test_timing_ad_gen_full() {
+    struct libwifi_timing_advert time_ad = {0};
+    struct libwifi_timing_advert_fields ad_fields = {0};
+
+    ad_fields.timing_capabilities = 2;
+    memcpy(ad_fields.time_error, "\xCC\xCC\xCC\xCC\xCC", 5);
+    memcpy(ad_fields.time_update, "\xBB", 1);
+    memcpy(ad_fields.time_value,
+          "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA", 10);
+
+    int ret = libwifi_create_timing_advert(&time_ad, to, to, &ad_fields, "GB", -56, -56, -30, -20);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to create timing advert\n");
+        return ret;
+    }
+
+    unsigned char *buf = NULL;
+    size_t buf_len = libwifi_get_timing_advert_length(&time_ad);
+    buf = malloc(buf_len);
+    if (buf == NULL) {
+        fprintf(stderr, "Failed to create buffer\n");
+        return -1;
+    }
+    printf("buf_len: %zu\n", buf_len);
+
+    ret = libwifi_dump_timing_advert(&time_ad, buf, buf_len);
+    if (ret < 0) {
+        fprintf(stderr, "Failed to dump advert");
+        return ret;
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        printf("Specify test\n");
+        return -1;
+    }
+
+    if (strcmp(argv[1], "--timing_ad-gen-full") == 0) {
+        return test_timing_ad_gen_full();
+    }
+
+    return -1;
+}
@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.18)
+
+project(libwifi_tests VERSION 0.1)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ggdb -O0")
+
+add_executable(test_misc src/helpers.c src/test_misc.c)
+add_executable(test_generation src/helpers.c src/test_generation.c)
+add_executable(test_parsing src/helpers.c src/test_parsing.c)
+target_link_libraries(test_misc wifi)
+target_link_libraries(test_generation wifi pcap)
+target_link_libraries(test_parsing wifi pcap)