Fix some printf format specifiers.

8 files changed, 38 insertions, 38 deletions

diff --git a/auto_tests/conference_simple_test.c b/auto_tests/conference_simple_test.c
index 010ae029..20e4ec8b 100644
--- a/auto_tests/conference_simple_test.c
+++ b/auto_tests/conference_simple_test.c
@@ -27,7 +27,7 @@ static void handle_self_connection_status(Tox *tox, TOX_CONNECTION connection_st
 {
     State *state = (State *)user_data;
 
-    fprintf(stderr, "self_connection_status(#%d, %d, _)\n", state->id, connection_status);
+    fprintf(stderr, "self_connection_status(#%u, %d, _)\n", state->id, connection_status);
     state->self_online = connection_status != TOX_CONNECTION_NONE;
 }
 
@@ -36,7 +36,7 @@ static void handle_friend_connection_status(Tox *tox, uint32_t friend_number, TO
 {
     State *state = (State *)user_data;
 
-    fprintf(stderr, "handle_friend_connection_status(#%d, %d, %d, _)\n", state->id, friend_number, connection_status);
+    fprintf(stderr, "handle_friend_connection_status(#%u, %u, %d, _)\n", state->id, friend_number, connection_status);
     state->friend_online = connection_status != TOX_CONNECTION_NONE;
 }
 
@@ -45,15 +45,15 @@ static void handle_conference_invite(Tox *tox, uint32_t friend_number, TOX_CONFE
 {
     State *state = (State *)user_data;
 
-    fprintf(stderr, "handle_conference_invite(#%d, %d, %d, uint8_t[%u], _)\n",
+    fprintf(stderr, "handle_conference_invite(#%u, %u, %d, uint8_t[%u], _)\n",
             state->id, friend_number, type, (unsigned)length);
-    fprintf(stderr, "tox%d joining conference\n", state->id);
+    fprintf(stderr, "tox%u joining conference\n", state->id);
 
     {
         TOX_ERR_CONFERENCE_JOIN err;
         state->conference = tox_conference_join(tox, friend_number, cookie, length, &err);
         ck_assert_msg(err == TOX_ERR_CONFERENCE_JOIN_OK, "failed to join a conference: err = %d", err);
-        fprintf(stderr, "tox%d Joined conference %d\n", state->id, state->conference);
+        fprintf(stderr, "tox%u Joined conference %u\n", state->id, state->conference);
         state->joined = true;
     }
 }
@@ -63,10 +63,10 @@ static void handle_conference_message(Tox *tox, uint32_t conference_number, uint
 {
     State *state = (State *)user_data;
 
-    fprintf(stderr, "handle_conference_message(#%d, %d, %d, %d, uint8_t[%u], _)\n",
+    fprintf(stderr, "handle_conference_message(#%u, %u, %u, %d, uint8_t[%u], _)\n",
             state->id, conference_number, peer_number, type, (unsigned)length);
 
-    fprintf(stderr, "tox%d got message: %s\n", state->id, (const char *)message);
+    fprintf(stderr, "tox%u got message: %s\n", state->id, (const char *)message);
     state->received = true;
 }
 
@@ -74,7 +74,7 @@ static void handle_conference_peer_list_changed(Tox *tox, uint32_t conference_nu
 {
     State *state = (State *)user_data;
 
-    fprintf(stderr, "handle_conference_peer_list_changed(#%d, %d, _)\n",
+    fprintf(stderr, "handle_conference_peer_list_changed(#%u, %u, _)\n",
             state->id, conference_number);
 
     TOX_ERR_CONFERENCE_PEER_QUERY err;
@@ -85,7 +85,7 @@ static void handle_conference_peer_list_changed(Tox *tox, uint32_t conference_nu
         exit(EXIT_FAILURE);
     }
 
-    fprintf(stderr, "tox%d has %d peers online\n", state->id, count);
+    fprintf(stderr, "tox%u has %u peers online\n", state->id, count);
     state->peers = count;
 }
 
@@ -194,7 +194,7 @@ int main(void)
         state1.conference = tox_conference_new(tox1, &err);
         state1.joined = true;
         ck_assert_msg(err == TOX_ERR_CONFERENCE_NEW_OK, "failed to create a conference: err = %d", err);
-        fprintf(stderr, "Created conference: id=%d\n", state1.conference);
+        fprintf(stderr, "Created conference: id = %u\n", state1.conference);
     }
 
     {
diff --git a/auto_tests/encryptsave_test.c b/auto_tests/encryptsave_test.c
index 41a4ed5c..bf7988e2 100644
--- a/auto_tests/encryptsave_test.c
+++ b/auto_tests/encryptsave_test.c
@@ -72,7 +72,7 @@ static void test_save_friend(void)
     VLA(uint8_t, enc_data, size2);
     TOX_ERR_ENCRYPTION error1;
     bool ret = tox_pass_encrypt(data, size, (const uint8_t *)"correcthorsebatterystaple", 25, enc_data, &error1);
-    ck_assert_msg(ret, "failed to encrypted save: %u", error1);
+    ck_assert_msg(ret, "failed to encrypted save: %d", error1);
     ck_assert_msg(tox_is_data_encrypted(enc_data), "magic number missing");
 
     struct Tox_Options *options = tox_options_new(nullptr);
@@ -81,16 +81,16 @@ static void test_save_friend(void)
 
     TOX_ERR_NEW err2;
     Tox *tox3 = tox_new_log(options, &err2, nullptr);
-    ck_assert_msg(err2 == TOX_ERR_NEW_LOAD_ENCRYPTED, "wrong error! %u. should fail with %u", err2,
+    ck_assert_msg(err2 == TOX_ERR_NEW_LOAD_ENCRYPTED, "wrong error! %d. should fail with %d", err2,
                   TOX_ERR_NEW_LOAD_ENCRYPTED);
     ck_assert_msg(tox3 == nullptr, "tox_new with error should return NULL");
     VLA(uint8_t, dec_data, size);
     TOX_ERR_DECRYPTION err3;
     ret = tox_pass_decrypt(enc_data, size2, (const uint8_t *)"correcthorsebatterystaple", 25, dec_data, &err3);
-    ck_assert_msg(ret, "failed to decrypt save: %u", err3);
+    ck_assert_msg(ret, "failed to decrypt save: %d", err3);
     tox_options_set_savedata_data(options, dec_data, size);
     tox3 = tox_new_log(options, &err2, nullptr);
-    ck_assert_msg(err2 == TOX_ERR_NEW_OK, "failed to load from decrypted data: %u", err2);
+    ck_assert_msg(err2 == TOX_ERR_NEW_OK, "failed to load from decrypted data: %d", err2);
     uint8_t address2[TOX_PUBLIC_KEY_SIZE];
     ret = tox_friend_get_public_key(tox3, 0, address2, nullptr);
     ck_assert_msg(ret, "no friends!");
@@ -107,15 +107,15 @@ static void test_save_friend(void)
     size2 = size + TOX_PASS_ENCRYPTION_EXTRA_LENGTH;
     VLA(uint8_t, encdata2, size2);
     ret = tox_pass_key_encrypt(key, data2, size, encdata2, &error1);
-    ck_assert_msg(ret, "failed to key encrypt %u", error1);
+    ck_assert_msg(ret, "failed to key encrypt %d", error1);
     ck_assert_msg(tox_is_data_encrypted(encdata2), "magic number the second missing");
 
     VLA(uint8_t, out1, size);
     VLA(uint8_t, out2, size);
     ret = tox_pass_decrypt(encdata2, size2, (const uint8_t *)pw, pwlen, out1, &err3);
-    ck_assert_msg(ret, "failed to pw decrypt %u", err3);
+    ck_assert_msg(ret, "failed to pw decrypt %d", err3);
     ret = tox_pass_key_decrypt(key, encdata2, size2, out2, &err3);
-    ck_assert_msg(ret, "failed to key decrypt %u", err3);
+    ck_assert_msg(ret, "failed to key decrypt %d", err3);
     ck_assert_msg(memcmp(out1, out2, size) == 0, "differing output data");
 
     // and now with the code in use (I only bothered with manually to debug this, and it seems a waste
@@ -143,37 +143,37 @@ static void test_keys(void)
     TOX_ERR_DECRYPTION decerr;
     TOX_ERR_KEY_DERIVATION keyerr;
     Tox_Pass_Key *key = tox_pass_key_derive((const uint8_t *)"123qweasdzxc", 12, &keyerr);
-    ck_assert_msg(key != nullptr, "generic failure 1: %u", keyerr);
+    ck_assert_msg(key != nullptr, "generic failure 1: %d", keyerr);
     const uint8_t *string = (const uint8_t *)"No Patrick, mayonnaise is not an instrument."; // 44
 
     uint8_t encrypted[44 + TOX_PASS_ENCRYPTION_EXTRA_LENGTH];
     bool ret = tox_pass_key_encrypt(key, string, 44, encrypted, &encerr);
-    ck_assert_msg(ret, "generic failure 2: %u", encerr);
+    ck_assert_msg(ret, "generic failure 2: %d", encerr);
 
     uint8_t encrypted2[44 + TOX_PASS_ENCRYPTION_EXTRA_LENGTH];
     ret = tox_pass_encrypt(string, 44, (const uint8_t *)"123qweasdzxc", 12, encrypted2, &encerr);
-    ck_assert_msg(ret, "generic failure 3: %u", encerr);
+    ck_assert_msg(ret, "generic failure 3: %d", encerr);
 
     uint8_t out1[44 + TOX_PASS_ENCRYPTION_EXTRA_LENGTH];
     uint8_t out2[44 + TOX_PASS_ENCRYPTION_EXTRA_LENGTH];
 
     ret = tox_pass_key_decrypt(key, encrypted, 44 + TOX_PASS_ENCRYPTION_EXTRA_LENGTH, out1, &decerr);
-    ck_assert_msg(ret, "generic failure 4: %u", decerr);
+    ck_assert_msg(ret, "generic failure 4: %d", decerr);
     ck_assert_msg(memcmp(out1, string, 44) == 0, "decryption 1 failed");
 
     ret = tox_pass_decrypt(encrypted2, 44 + TOX_PASS_ENCRYPTION_EXTRA_LENGTH, (const uint8_t *)"123qweasdzxc", 12, out2,
                            &decerr);
-    ck_assert_msg(ret, "generic failure 5: %u", decerr);
+    ck_assert_msg(ret, "generic failure 5: %d", decerr);
     ck_assert_msg(memcmp(out2, string, 44) == 0, "decryption 2 failed");
 
     ret = tox_pass_decrypt(encrypted2, 44 + TOX_PASS_ENCRYPTION_EXTRA_LENGTH, nullptr, 0, out2, &decerr);
     ck_assert_msg(!ret, "Decrypt succeeded with wrong pass");
-    ck_assert_msg(decerr != TOX_ERR_DECRYPTION_FAILED, "Bad error code %u", decerr);
+    ck_assert_msg(decerr != TOX_ERR_DECRYPTION_FAILED, "Bad error code %d", decerr);
 
     // test that pass_decrypt can decrypt things from pass_key_encrypt
     ret = tox_pass_decrypt(encrypted, 44 + TOX_PASS_ENCRYPTION_EXTRA_LENGTH, (const uint8_t *)"123qweasdzxc", 12, out1,
                            &decerr);
-    ck_assert_msg(ret, "generic failure 6: %u", decerr);
+    ck_assert_msg(ret, "generic failure 6: %d", decerr);
     ck_assert_msg(memcmp(out1, string, 44) == 0, "decryption 3 failed");
 
     uint8_t salt[TOX_PASS_SALT_LENGTH];
@@ -181,7 +181,7 @@ static void test_keys(void)
     ck_assert_msg(tox_get_salt(encrypted, salt, &salt_err), "couldn't get salt");
     ck_assert_msg(salt_err == TOX_ERR_GET_SALT_OK, "get_salt returned an error");
     Tox_Pass_Key *key2 = tox_pass_key_derive_with_salt((const uint8_t *)"123qweasdzxc", 12, salt, &keyerr);
-    ck_assert_msg(key2 != nullptr, "generic failure 7: %u", keyerr);
+    ck_assert_msg(key2 != nullptr, "generic failure 7: %d", keyerr);
     ck_assert_msg(0 == memcmp(key, key2, TOX_PASS_KEY_LENGTH + TOX_PASS_SALT_LENGTH), "salt comparison failed");
     tox_pass_key_free(key2);
     tox_pass_key_free(key);
diff --git a/auto_tests/file_transfer_test.c b/auto_tests/file_transfer_test.c
index 9af339e5..63dc3fed 100644
--- a/auto_tests/file_transfer_test.c
+++ b/auto_tests/file_transfer_test.c
@@ -173,7 +173,7 @@ static void file_transfer_test(void)
     uint8_t address[TOX_ADDRESS_SIZE];
     tox_self_get_address(tox2, address);
     uint32_t test = tox_friend_add(tox3, address, (const uint8_t *)"Gentoo", 7, nullptr);
-    ck_assert_msg(test == 0, "Failed to add friend error code: %i", test);
+    ck_assert_msg(test == 0, "Failed to add friend error code: %u", test);
 
     uint8_t dhtKey[TOX_PUBLIC_KEY_SIZE];
     tox_self_get_dht_id(tox1, dhtKey);
diff --git a/auto_tests/friend_request_test.c b/auto_tests/friend_request_test.c
index 1bcc05a7..73f9248c 100644
--- a/auto_tests/friend_request_test.c
+++ b/auto_tests/friend_request_test.c
@@ -61,7 +61,7 @@ static void test_friend_request(void)
     tox_self_get_address(tox2, address);
 
     const uint32_t test = tox_friend_add(tox1, address, (const uint8_t *)FR_MESSAGE, sizeof(FR_MESSAGE), nullptr);
-    ck_assert_msg(test == 0, "failed to add friend error code: %i", test);
+    ck_assert_msg(test == 0, "failed to add friend error code: %u", test);
 
     while (tox_friend_get_connection_status(tox1, 0, nullptr) != TOX_CONNECTION_UDP ||
             tox_friend_get_connection_status(tox2, 0, nullptr) != TOX_CONNECTION_UDP) {
diff --git a/auto_tests/network_test.c b/auto_tests/network_test.c
index 78f41195..7cfba1c0 100644
--- a/auto_tests/network_test.c
+++ b/auto_tests/network_test.c
@@ -104,20 +104,20 @@ START_TEST(test_ip_equal)
     ip_reset(&ip2);
 
     res = ip_equal(nullptr, nullptr);
-    ck_assert_msg(res == 0, "ip_equal(NULL, NULL): expected result 0, got %u.", res);
+    ck_assert_msg(res == 0, "ip_equal(NULL, NULL): expected result 0, got %d.", res);
 
     res = ip_equal(&ip1, nullptr);
-    ck_assert_msg(res == 0, "ip_equal(PTR, NULL): expected result 0, got %u.", res);
+    ck_assert_msg(res == 0, "ip_equal(PTR, NULL): expected result 0, got %d.", res);
 
     res = ip_equal(nullptr, &ip1);
-    ck_assert_msg(res == 0, "ip_equal(NULL, PTR): expected result 0, got %u.", res);
+    ck_assert_msg(res == 0, "ip_equal(NULL, PTR): expected result 0, got %d.", res);
 
     ip1.family = net_family_ipv4;
     ip1.ip.v4.uint32 = net_htonl(0x7F000001);
 
     res = ip_equal(&ip1, &ip2);
     ck_assert_msg(res == 0, "ip_equal( {TOX_AF_INET, 127.0.0.1}, {TOX_AF_UNSPEC, 0} ): "
-                  "expected result 0, got %u.", res);
+                  "expected result 0, got %d.", res);
 
     ip2.family = net_family_ipv4;
     ip2.ip.v4.uint32 = net_htonl(0x7F000001);
@@ -130,7 +130,7 @@ START_TEST(test_ip_equal)
 
     res = ip_equal(&ip1, &ip2);
     ck_assert_msg(res == 0, "ip_equal( {TOX_AF_INET, 127.0.0.1}, {TOX_AF_INET, 127.0.0.2} ): "
-                  "expected result 0, got %u.", res);
+                  "expected result 0, got %d.", res);
 
     ip2.family = net_family_ipv6;
     ip2.ip.v6.uint32[0] = 0;
@@ -148,7 +148,7 @@ START_TEST(test_ip_equal)
     IP6 ip6_loopback = get_ip6_loopback();
     memcpy(&ip2.ip.v6, &ip6_loopback, sizeof(IP6));
     res = ip_equal(&ip1, &ip2);
-    ck_assert_msg(res == 0, "ip_equal( {TOX_AF_INET, 127.0.0.1}, {TOX_AF_INET6, ::1} ): expected result 0, got %u.", res);
+    ck_assert_msg(res == 0, "ip_equal( {TOX_AF_INET, 127.0.0.1}, {TOX_AF_INET6, ::1} ): expected result 0, got %d.", res);
 
     memcpy(&ip1, &ip2, sizeof(IP));
     res = ip_equal(&ip1, &ip2);
@@ -156,7 +156,7 @@ START_TEST(test_ip_equal)
 
     ip2.ip.v6.uint8[15]++;
     res = ip_equal(&ip1, &ip2);
-    ck_assert_msg(res == 0, "ip_equal( {TOX_AF_INET6, ::1}, {TOX_AF_INET6, ::2} ): expected result 0, got %u.", res);
+    ck_assert_msg(res == 0, "ip_equal( {TOX_AF_INET6, ::1}, {TOX_AF_INET6, ::2} ): expected result 0, got %d.", res);
 }
 END_TEST
 
diff --git a/auto_tests/save_load_test.c b/auto_tests/save_load_test.c
index 90d0263f..7d5672c7 100644
--- a/auto_tests/save_load_test.c
+++ b/auto_tests/save_load_test.c
@@ -30,7 +30,7 @@ static void tox_connection_status(Tox *tox, TOX_CONNECTION connection_status, vo
         ck_abort_msg("Tox went offline");
     }
 
-    ck_assert_msg(connection_status == TOX_CONNECTION_UDP, "wrong status %u", connection_status);
+    ck_assert_msg(connection_status == TOX_CONNECTION_UDP, "wrong status %d", connection_status);
 
     connected_t1 = connection_status;
 }
diff --git a/auto_tests/tox_many_tcp_test.c b/auto_tests/tox_many_tcp_test.c
index 7ce2c9a5..b8343f74 100644
--- a/auto_tests/tox_many_tcp_test.c
+++ b/auto_tests/tox_many_tcp_test.c
@@ -63,7 +63,7 @@ START_TEST(test_many_clients_tcp)
         uint8_t dpk[TOX_PUBLIC_KEY_SIZE];
         tox_self_get_dht_id(toxes[0], dpk);
         TOX_ERR_BOOTSTRAP error = TOX_ERR_BOOTSTRAP_OK;
-        ck_assert_msg(tox_add_tcp_relay(toxes[i], TOX_LOCALHOST, TCP_RELAY_PORT, dpk, &error), "add relay error, %i, %i", i,
+        ck_assert_msg(tox_add_tcp_relay(toxes[i], TOX_LOCALHOST, TCP_RELAY_PORT, dpk, &error), "add relay error, %u, %d", i,
                       error);
         uint16_t first_port = tox_self_get_udp_port(toxes[0], nullptr);
         ck_assert_msg(tox_bootstrap(toxes[i], TOX_LOCALHOST, first_port, dpk, nullptr), "Bootstrap error");
diff --git a/testing/av_test.c b/testing/av_test.c
index 87a01871..a36d0a00 100644
--- a/testing/av_test.c
+++ b/testing/av_test.c
@@ -212,12 +212,12 @@ static void t_toxav_receive_audio_frame_cb(ToxAV *av, uint32_t friend_number,
 static void t_toxav_audio_bit_rate_cb(ToxAV *av, uint32_t friend_number,
                                       uint32_t audio_bit_rate, void *user_data)
 {
-    printf("Suggested bit rate: audio: %d\n", audio_bit_rate);
+    printf("Suggested bit rate: audio: %u\n", audio_bit_rate);
 }
 static void t_toxav_video_bit_rate_cb(ToxAV *av, uint32_t friend_number,
                                       uint32_t video_bit_rate, void *user_data)
 {
-    printf("Suggested bit rate: video: %d\n", video_bit_rate);
+    printf("Suggested bit rate: video: %u\n", video_bit_rate);
 }
 static void t_accept_friend_request_cb(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length,
                                        void *userdata)