don't use variable length or zero-length arrays in test files

as some compilers don't handle that

1 files changed, 75 insertions, 77 deletions

diff --git a/tests/test_group_session.cpp b/tests/test_group_session.cpp
index 63241d5..19b7761 100644
--- a/tests/test_group_session.cpp
+++ b/tests/test_group_session.cpp
@@ -16,6 +16,7 @@
 #include "olm/outbound_group_session.h"
 #include "unittest.hh"
 
+#include <vector>
 
 int main() {
 
@@ -23,33 +24,32 @@ int main() {
     TestCase test_case("Pickle outbound group session");
 
     size_t size = olm_outbound_group_session_size();
-    uint8_t memory[size];
-    OlmOutboundGroupSession *session = olm_outbound_group_session(memory);
+    std::vector<uint8_t> memory(size);
+    OlmOutboundGroupSession *session = olm_outbound_group_session(memory.data());
 
     size_t pickle_length = olm_pickle_outbound_group_session_length(session);
-    uint8_t pickle1[pickle_length];
+    std::vector<uint8_t> pickle1(pickle_length);
     size_t res = olm_pickle_outbound_group_session(
-        session, "secret_key", 10, pickle1, pickle_length
+        session, "secret_key", 10, pickle1.data(), pickle_length
     );
     assert_equals(pickle_length, res);
 
-    uint8_t pickle2[pickle_length];
-    memcpy(pickle2, pickle1, pickle_length);
+    std::vector<uint8_t> pickle2(pickle1);
 
-    uint8_t buffer2[size];
-    OlmOutboundGroupSession *session2 = olm_outbound_group_session(buffer2);
+    std::vector<uint8_t> buffer2(size);
+    OlmOutboundGroupSession *session2 = olm_outbound_group_session(buffer2.data());
     res = olm_unpickle_outbound_group_session(
-        session2, "secret_key", 10, pickle2, pickle_length
+        session2, "secret_key", 10, pickle2.data(), pickle_length
     );
     assert_not_equals((size_t)-1, res);
     assert_equals(pickle_length,
                   olm_pickle_outbound_group_session_length(session2));
     res = olm_pickle_outbound_group_session(
-        session2, "secret_key", 10, pickle2, pickle_length
+        session2, "secret_key", 10, pickle2.data(), pickle_length
     );
     assert_equals(pickle_length, res);
 
-    assert_equals(pickle1, pickle2, pickle_length);
+    assert_equals(pickle1.data(), pickle2.data(), pickle_length);
 }
 
 
@@ -57,32 +57,31 @@ int main() {
     TestCase test_case("Pickle inbound group session");
 
     size_t size = olm_inbound_group_session_size();
-    uint8_t memory[size];
-    OlmInboundGroupSession *session = olm_inbound_group_session(memory);
+    std::vector<uint8_t> memory(size);
+    OlmInboundGroupSession *session = olm_inbound_group_session(memory.data());
 
     size_t pickle_length = olm_pickle_inbound_group_session_length(session);
-    uint8_t pickle1[pickle_length];
+    std::vector<uint8_t> pickle1(pickle_length);
     size_t res = olm_pickle_inbound_group_session(
-        session, "secret_key", 10, pickle1, pickle_length
+        session, "secret_key", 10, pickle1.data(), pickle_length
     );
     assert_equals(pickle_length, res);
 
-    uint8_t pickle2[pickle_length];
-    memcpy(pickle2, pickle1, pickle_length);
+    std::vector<uint8_t> pickle2(pickle1);
 
-    uint8_t buffer2[size];
-    OlmInboundGroupSession *session2 = olm_inbound_group_session(buffer2);
+    std::vector<uint8_t> buffer2(size);
+    OlmInboundGroupSession *session2 = olm_inbound_group_session(buffer2.data());
     res = olm_unpickle_inbound_group_session(
-        session2, "secret_key", 10, pickle2, pickle_length
+        session2, "secret_key", 10, pickle2.data(), pickle_length
     );
     assert_not_equals((size_t)-1, res);
     assert_equals(pickle_length,
                   olm_pickle_inbound_group_session_length(session2));
     res = olm_pickle_inbound_group_session(
-        session2, "secret_key", 10, pickle2, pickle_length
+        session2, "secret_key", 10, pickle2.data(), pickle_length
     );
 
-    assert_equals(pickle1, pickle2, pickle_length);
+    assert_equals(pickle1.data(), pickle2.data(), pickle_length);
 }
 
 {
@@ -99,8 +98,8 @@ int main() {
 
     /* build the outbound session */
     size_t size = olm_outbound_group_session_size();
-    uint8_t memory[size];
-    OlmOutboundGroupSession *session = olm_outbound_group_session(memory);
+    std::vector<uint8_t> memory(size);
+    OlmOutboundGroupSession *session = olm_outbound_group_session(memory.data());
 
     assert_equals((size_t)160,
                   olm_init_outbound_group_session_random_length(session));
@@ -111,8 +110,8 @@ int main() {
 
     assert_equals(0U, olm_outbound_group_session_message_index(session));
     size_t session_key_len = olm_outbound_group_session_key_length(session);
-    uint8_t session_key[session_key_len];
-    olm_outbound_group_session_key(session, session_key, session_key_len);
+    std::vector<uint8_t> session_key(session_key_len);
+    olm_outbound_group_session_key(session, session_key.data(), session_key_len);
 
     /* encode the message */
     uint8_t plaintext[] = "Message";
@@ -121,57 +120,56 @@ int main() {
     size_t msglen = olm_group_encrypt_message_length(
         session, plaintext_length);
 
-    uint8_t msg[msglen];
+    std::vector<uint8_t> msg(msglen);
     res = olm_group_encrypt(session, plaintext, plaintext_length,
-                            msg, msglen);
+                            msg.data(), msglen);
     assert_equals(msglen, res);
     assert_equals(1U, olm_outbound_group_session_message_index(session));
 
     /* build the inbound session */
     size = olm_inbound_group_session_size();
-    uint8_t inbound_session_memory[size];
+    std::vector<uint8_t> inbound_session_memory(size);
     OlmInboundGroupSession *inbound_session =
-        olm_inbound_group_session(inbound_session_memory);
+        olm_inbound_group_session(inbound_session_memory.data());
 
     assert_equals(0, olm_inbound_group_session_is_verified(inbound_session));
 
     res = olm_init_inbound_group_session(
-        inbound_session, session_key, session_key_len);
+        inbound_session, session_key.data(), session_key_len);
     assert_equals((size_t)0, res);
     assert_equals(1, olm_inbound_group_session_is_verified(inbound_session));
 
     /* Check the session ids */
 
     size_t out_session_id_len = olm_outbound_group_session_id_length(session);
-    uint8_t out_session_id[out_session_id_len];
+    std::vector<uint8_t> out_session_id(out_session_id_len);
     assert_equals(out_session_id_len, olm_outbound_group_session_id(
-        session, out_session_id, out_session_id_len
+        session, out_session_id.data(), out_session_id_len
     ));
 
     size_t in_session_id_len = olm_inbound_group_session_id_length(
         inbound_session
     );
-    uint8_t in_session_id[in_session_id_len];
+    std::vector<uint8_t> in_session_id(in_session_id_len);
     assert_equals(in_session_id_len, olm_inbound_group_session_id(
-        inbound_session, in_session_id, in_session_id_len
+        inbound_session, in_session_id.data(), in_session_id_len
     ));
 
     assert_equals(in_session_id_len, out_session_id_len);
-    assert_equals(out_session_id, in_session_id, in_session_id_len);
+    assert_equals(out_session_id.data(), in_session_id.data(), in_session_id_len);
 
     /* decode the message */
 
     /* olm_group_decrypt_max_plaintext_length destroys the input so we have to
        copy it. */
-    uint8_t msgcopy[msglen];
-    memcpy(msgcopy, msg, msglen);
-    size = olm_group_decrypt_max_plaintext_length(inbound_session, msgcopy, msglen);
-    uint8_t plaintext_buf[size];
+    std::vector<uint8_t> msgcopy(msg);
+    size = olm_group_decrypt_max_plaintext_length(inbound_session, msgcopy.data(), msglen);
+    std::vector<uint8_t> plaintext_buf(size);
     uint32_t message_index;
-    res = olm_group_decrypt(inbound_session, msg, msglen,
-                            plaintext_buf, size, &message_index);
+    res = olm_group_decrypt(inbound_session, msg.data(), msglen,
+                            plaintext_buf.data(), size, &message_index);
     assert_equals(plaintext_length, res);
-    assert_equals(plaintext, plaintext_buf, res);
+    assert_equals(plaintext, plaintext_buf.data(), res);
     assert_equals(message_index, uint32_t(0));
 }
 
@@ -192,9 +190,9 @@ int main() {
 
     /* init first inbound group session, and decrypt */
     std::size_t size = olm_inbound_group_session_size();
-    uint8_t session_memory1[size];
+    std::vector<uint8_t> session_memory1(size);
     OlmInboundGroupSession *session1 =
-        olm_inbound_group_session(session_memory1);
+        olm_inbound_group_session(session_memory1.data());
     assert_equals(0, olm_inbound_group_session_is_verified(session1));
 
     std::size_t res = olm_init_inbound_group_session(
@@ -205,24 +203,24 @@ int main() {
 
     /* olm_group_decrypt_max_plaintext_length destroys the input so we have to
        copy it. */
-    uint8_t msgcopy[msglen];
-    memcpy(msgcopy, message, msglen);
-    size = olm_group_decrypt_max_plaintext_length(session1, msgcopy, msglen);
-    uint8_t plaintext_buf[size];
+    std::vector<uint8_t> msgcopy(msglen);
+    memcpy(msgcopy.data(), message, msglen);
+    size = olm_group_decrypt_max_plaintext_length(session1, msgcopy.data(), msglen);
+    std::vector<uint8_t> plaintext_buf(size);
     uint32_t message_index;
-    memcpy(msgcopy, message, msglen);
+    memcpy(msgcopy.data(), message, msglen);
     res = olm_group_decrypt(
-        session1, msgcopy, msglen, plaintext_buf, size, &message_index
+        session1, msgcopy.data(), msglen, plaintext_buf.data(), size, &message_index
     );
     assert_equals((std::size_t)7, res);
-    assert_equals((const uint8_t *)"Message", plaintext_buf, res);
+    assert_equals((const uint8_t *)"Message", plaintext_buf.data(), res);
     assert_equals(uint32_t(0), message_index);
 
     /* export the keys */
     size = olm_export_inbound_group_session_length(session1);
-    uint8_t export_memory[size];
+    std::vector<uint8_t> export_memory(size);
     res = olm_export_inbound_group_session(
-        session1, export_memory, size, 0
+        session1, export_memory.data(), size, 0
     );
     assert_equals(size, res);
 
@@ -231,25 +229,25 @@ int main() {
 
     /* import the keys into another inbound group session */
     size = olm_inbound_group_session_size();
-    uint8_t session_memory2[size];
+    std::vector<uint8_t> session_memory2(size);
     OlmInboundGroupSession *session2 =
-        olm_inbound_group_session(session_memory2);
+        olm_inbound_group_session(session_memory2.data());
     res = olm_import_inbound_group_session(
-        session2, export_memory, sizeof(export_memory)
+        session2, export_memory.data(), export_memory.size()
     );
     assert_equals((size_t)0, res);
     assert_equals(0, olm_inbound_group_session_is_verified(session2));
 
     /* decrypt the message with the new session */
-    memcpy(msgcopy, message, msglen);
-    size = olm_group_decrypt_max_plaintext_length(session2, msgcopy, msglen);
-    uint8_t plaintext_buf2[size];
-    memcpy(msgcopy, message, msglen);
+    memcpy(msgcopy.data(), message, msglen);
+    size = olm_group_decrypt_max_plaintext_length(session2, msgcopy.data(), msglen);
+    std::vector<uint8_t> plaintext_buf2(size);
+    memcpy(msgcopy.data(), message, msglen);
     res = olm_group_decrypt(
-        session2, msgcopy, msglen, plaintext_buf2, size, &message_index
+        session2, msgcopy.data(), msglen, plaintext_buf2.data(), size, &message_index
     );
     assert_equals((std::size_t)7, res);
-    assert_equals((const uint8_t *)"Message", plaintext_buf2, res);
+    assert_equals((const uint8_t *)"Message", plaintext_buf2.data(), res);
     assert_equals(uint32_t(0), message_index);
     assert_equals(1, olm_inbound_group_session_is_verified(session2));
 }
@@ -274,9 +272,9 @@ int main() {
 
     /* build the inbound session */
     size_t size = olm_inbound_group_session_size();
-    uint8_t inbound_session_memory[size];
+    std::vector<uint8_t> inbound_session_memory(size);
     OlmInboundGroupSession *inbound_session =
-        olm_inbound_group_session(inbound_session_memory);
+        olm_inbound_group_session(inbound_session_memory.data());
 
     size_t res = olm_init_inbound_group_session(
         inbound_session, session_key, sizeof(session_key)-1
@@ -287,36 +285,36 @@ int main() {
 
     /* olm_group_decrypt_max_plaintext_length destroys the input so we have to
        copy it. */
-    uint8_t msgcopy[msglen];
-    memcpy(msgcopy, message, msglen);
+    std::vector<uint8_t> msgcopy(msglen);
+    memcpy(msgcopy.data(), message, msglen);
     size = olm_group_decrypt_max_plaintext_length(
-        inbound_session, msgcopy, msglen
+        inbound_session, msgcopy.data(), msglen
     );
 
-    memcpy(msgcopy, message, msglen);
-    uint8_t plaintext_buf[size];
+    memcpy(msgcopy.data(), message, msglen);
+    std::vector<uint8_t> plaintext_buf(size);
     uint32_t message_index;
     res = olm_group_decrypt(
-        inbound_session, msgcopy, msglen, plaintext_buf, size, &message_index
+        inbound_session, msgcopy.data(), msglen, plaintext_buf.data(), size, &message_index
     );
     assert_equals(message_index, uint32_t(0));
     assert_equals(plaintext_length, res);
-    assert_equals(plaintext, plaintext_buf, res);
+    assert_equals(plaintext, plaintext_buf.data(), res);
 
     /* now twiddle the signature */
     message[msglen-1] = 'E';
-    memcpy(msgcopy, message, msglen);
+    memcpy(msgcopy.data(), message, msglen);
     assert_equals(
         size,
         olm_group_decrypt_max_plaintext_length(
-            inbound_session, msgcopy, msglen
+            inbound_session, msgcopy.data(), msglen
         )
     );
 
-    memcpy(msgcopy, message, msglen);
+    memcpy(msgcopy.data(), message, msglen);
     res = olm_group_decrypt(
-        inbound_session, msgcopy, msglen,
-        plaintext_buf, size, &message_index
+        inbound_session, msgcopy.data(), msglen,
+        plaintext_buf.data(), size, &message_index
     );
     assert_equals((size_t)-1, res);
     assert_equals(