static void test_govirt_http(void)
{
OvirtProxy *proxy;
OvirtApi *api;
GError *error = NULL;
GovirtMockHttpd *httpd;
httpd = govirt_mock_httpd_new(GOVIRT_HTTPS_PORT);
govirt_mock_httpd_disable_tls(httpd, TRUE);
govirt_mock_httpd_add_request(httpd, "GET", "/ovirt-engine/api", "<api></api>");
govirt_mock_httpd_start(httpd);
g_setenv("GOVIRT_DISABLE_HTTPS", "1", TRUE);
g_test_expect_message("libgovirt", G_LOG_LEVEL_WARNING,
"Using plain text HTTP connection");
g_test_expect_message("libgovirt", G_LOG_LEVEL_CRITICAL,
"ovirt_proxy_set_api_from_xml: assertion 'vms != NULL' failed");
proxy = ovirt_proxy_new("localhost:" G_STRINGIFY(GOVIRT_HTTPS_PORT));
api = ovirt_proxy_fetch_api(proxy, &error);
g_test_assert_expected_messages();
g_assert_nonnull(api);
g_assert_no_error(error);
g_object_unref(proxy);
g_unsetenv("GOVIRT_DISABLE_HTTPS");
govirt_mock_httpd_stop(httpd);
}
/* Test g_warn macros */
static void
test_warnings (void)
{
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"*test_warnings*should not be reached*");
g_warn_if_reached ();
g_test_assert_expected_messages ();
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"*test_warnings*runtime check failed*");
g_warn_if_fail (FALSE);
g_test_assert_expected_messages ();
}
static void
do_infinite_auth_test (void)
{
SoupSession *session;
SoupMessage *msg;
char *uri;
int timeout;
SOUP_TEST_SKIP_IF_NO_APACHE;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
g_signal_connect (session, "authenticate",
G_CALLBACK (infinite_authenticate), NULL);
uri = g_strconcat (base_uri, "Basic/realm1/", NULL);
msg = soup_message_new ("GET", uri);
g_free (uri);
timeout = g_timeout_add (500, infinite_cancel, session);
g_test_expect_message ("libsoup", G_LOG_LEVEL_WARNING,
"*stuck in infinite loop*");
soup_session_send_message (session, msg);
g_test_assert_expected_messages ();
soup_test_assert (msg->status_code != SOUP_STATUS_CANCELLED,
"Got stuck in loop");
soup_test_assert_message_status (msg, SOUP_STATUS_UNAUTHORIZED);
g_source_remove (timeout);
soup_test_session_abort_unref (session);
g_object_unref (msg);
}
static void
test_not_callback_simple (void)
{
g_test_expect_message("Grilo", G_LOG_LEVEL_WARNING,
"*Source 'test-source-lua-errors' is broken, as the finishing callback was not called for*");
execute_resolve_test (TEST_NOT_CALLBACK_SIMPLE);
}
static void test_govirt_https_ca(void)
{
OvirtProxy *proxy;
OvirtApi *api;
GError *error = NULL;
GovirtMockHttpd *httpd;
httpd = govirt_mock_httpd_new(GOVIRT_HTTPS_PORT);
govirt_mock_httpd_add_request(httpd, "GET", "/ovirt-engine/api", "<api></api>");
govirt_mock_httpd_start(httpd);
g_setenv("GOVIRT_NO_SSL_STRICT", "1", TRUE);
g_test_expect_message("libgovirt", G_LOG_LEVEL_WARNING,
"Disabling strict checking of SSL certificates");
g_test_expect_message("libgovirt", G_LOG_LEVEL_CRITICAL,
"ovirt_proxy_set_api_from_xml: assertion 'vms != NULL' failed");
proxy = ovirt_proxy_new("localhost:" G_STRINGIFY(GOVIRT_HTTPS_PORT));
api = ovirt_proxy_fetch_api(proxy, &error);
g_test_assert_expected_messages();
g_assert_nonnull(api);
g_assert_no_error(error);
g_object_unref(proxy);
g_unsetenv("GOVIRT_NO_SSL_STRICT");
g_test_expect_message("libgovirt", G_LOG_LEVEL_WARNING,
"Error while getting collection: Unacceptable TLS certificate");
proxy = ovirt_proxy_new("localhost:" G_STRINGIFY(GOVIRT_HTTPS_PORT));
api = ovirt_proxy_fetch_api(proxy, &error);
g_test_assert_expected_messages();
g_assert_null(api);
g_assert_error(error, REST_PROXY_ERROR, REST_PROXY_ERROR_SSL);
g_assert_cmpstr(error->message, ==, "Unacceptable TLS certificate");
g_clear_error(&error);
g_test_expect_message("libgovirt", G_LOG_LEVEL_CRITICAL,
"ovirt_proxy_set_api_from_xml: assertion 'vms != NULL' failed");
ovirt_proxy_set_mock_ca(proxy);
api = ovirt_proxy_fetch_api(proxy, &error);
g_test_assert_expected_messages();
g_assert_nonnull(api);
g_assert_no_error(error);
g_clear_object(&proxy);
govirt_mock_httpd_stop(httpd);
}
void test_aes_encrypt(void)
{
MegaAesKey* k = mega_aes_key_new_from_binary(KEY_BINARY);
g_assert(mega_aes_key_is_loaded(k));
guchar plain[64] = {0}, cipher[64] = {0}, plain_dec[64] = {0};
mega_aes_key_encrypt_raw(k, plain, cipher, 64);
mega_aes_key_decrypt_raw(k, cipher, plain_dec, 64);
g_assert(memcmp(plain, plain_dec, 64) == 0);
g_assert(memcmp(plain, cipher, 64) != 0);
// VALID use of UBase64 funcs
gchar* cipher_ubase64 = mega_aes_key_encrypt(k, plain, 16);
g_assert_cmpstr(cipher_ubase64, ==, "muj9ArNAKIoOe7_w8LpU1g");
GBytes* plain_bytes = mega_aes_key_decrypt(k, cipher_ubase64);
g_assert_cmpuint(g_bytes_get_size(plain_bytes), ==, 16);
g_assert(memcmp(g_bytes_get_data(plain_bytes, NULL), plain, 16) == 0);
// INVALID use of UBase64 funcs
g_test_expect_message(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*(len % 16) == 0*failed*");
gchar* non_multiple_of_16 = mega_aes_key_encrypt(k, plain, 18);
g_test_assert_expected_messages();
g_assert(non_multiple_of_16 == NULL);
g_test_expect_message(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*len > 0*failed*");
gchar* zero_length = mega_aes_key_encrypt(k, plain, 0);
g_test_assert_expected_messages();
g_assert(zero_length == NULL);
GBytes* invalid_key_ubase64 = mega_aes_key_decrypt(k, KEY_INVALID);
g_assert(invalid_key_ubase64 == NULL);
GBytes* null_key_ubase64 = mega_aes_key_decrypt(k, KEY_NULL);
g_assert(null_key_ubase64 == NULL);
}
static void test_govirt_list_duplicate_vms(void)
{
OvirtProxy *proxy;
OvirtApi *api;
OvirtCollection *vms;
OvirtResource *vm;
GError *error = NULL;
GovirtMockHttpd *httpd;
const char *vms_body = "<vms> \
<vm href=\"api/vms/uuid0\" id=\"uuid0\"> \
<name>vm0</name> \
</vm> \
<vm href=\"api/vms/uuid1\" id=\"uuid1\"> \
<name>vm0</name> \
</vm> \
</vms>";
httpd = govirt_mock_httpd_new(GOVIRT_HTTPS_PORT);
govirt_mock_httpd_add_request(httpd, "GET", "/ovirt-engine/api",
"<api><link href=\"/ovirt-engine/api/vms\" rel=\"vms\"/></api>");
govirt_mock_httpd_add_request(httpd, "GET", "/ovirt-engine/api/vms", vms_body);
govirt_mock_httpd_start(httpd);
proxy = ovirt_proxy_new("localhost:" G_STRINGIFY(GOVIRT_HTTPS_PORT));
ovirt_proxy_set_mock_ca(proxy);
api = ovirt_proxy_fetch_api(proxy, &error);
g_test_assert_expected_messages();
g_assert_nonnull(api);
g_assert_no_error(error);
g_test_expect_message("libgovirt", G_LOG_LEVEL_MESSAGE,
"'vm' resource with the same name ('vm0') already exists");
vms = ovirt_api_get_vms(api);
ovirt_collection_fetch(vms, proxy, &error);
g_test_assert_expected_messages();
g_assert_no_error(error);
vm = ovirt_collection_lookup_resource(vms, "vm0");
g_assert_nonnull(vm);
g_object_unref(vm);
g_object_unref(proxy);
govirt_mock_httpd_stop(httpd);
}
static void
test_resolve_metrolyrics_bad_request (void)
{
GrlSource *source;
guint i;
struct {
gchar *title;
gchar *artist;
gchar *lyrics_file;
} audios[] = {
{ "GNOME", "grilo framework", NULL },
};
source = test_lua_factory_get_source (METROLYRICS_ID, METROLYRICS_OPS);
for (i = 0; i < G_N_ELEMENTS (audios); i++) {
gchar *lyrics;
g_test_expect_message("Grilo", G_LOG_LEVEL_WARNING, "*Can't fetch element*");
lyrics = get_lyrics (source, audios[i].artist, audios[i].title);
g_assert_null (lyrics);
}
}
void test_aes_construction(void)
{
MegaAesKey *k, *ek;
// VALID USES:
// create empty key, check that it is not laoded
k = mega_aes_key_new();
g_assert(MEGA_IS_AES_KEY(k));
g_assert(!mega_aes_key_is_loaded(k));
g_object_unref(k);
// create key from UBase64
k = mega_aes_key_new_from_ubase64(KEY_UBASE64);
g_assert(MEGA_IS_AES_KEY(k));
g_assert(mega_aes_key_is_loaded(k));
g_assert_cmpstr(KEY_UBASE64, ==, mega_aes_key_get_ubase64(k));
g_object_unref(k);
// create key from Binary data (use as dec_key below)
ek = mega_aes_key_new_from_binary(KEY_BINARY);
g_assert(MEGA_IS_AES_KEY(ek));
g_assert(mega_aes_key_is_loaded(ek));
g_assert(memcmp(KEY_BINARY, mega_aes_key_get_binary(ek), 16) == 0);
g_assert_cmpstr(KEY_UBASE64, ==, mega_aes_key_get_ubase64(ek));
// create key from encrypted UBase64
k = mega_aes_key_new_from_enc_ubase64(KEY_UBASE64, ek);
g_assert(MEGA_IS_AES_KEY(k));
g_assert(mega_aes_key_is_loaded(k));
g_assert_cmpstr(KEY_UBASE64, ==, mega_aes_key_get_enc_ubase64(k, ek));
g_object_unref(k);
// create key from encrypted Binary data
k = mega_aes_key_new_from_enc_binary(KEY_BINARY, ek);
g_assert(MEGA_IS_AES_KEY(k));
g_assert(mega_aes_key_is_loaded(k));
g_assert(memcmp(KEY_BINARY, mega_aes_key_get_enc_binary(k, ek), 16) == 0);
g_object_unref(k);
g_object_unref(ek);
// INVALID USES
k = mega_aes_key_new_from_ubase64(KEY_LONG);
g_assert(MEGA_IS_AES_KEY(k));
g_assert(!mega_aes_key_is_loaded(k));
g_object_unref(k);
k = mega_aes_key_new_from_ubase64(KEY_SHORT);
g_assert(MEGA_IS_AES_KEY(k));
g_assert(!mega_aes_key_is_loaded(k));
g_object_unref(k);
k = mega_aes_key_new_from_ubase64(KEY_INVALID);
g_assert(MEGA_IS_AES_KEY(k));
g_assert(!mega_aes_key_is_loaded(k));
g_object_unref(k);
k = mega_aes_key_new_from_ubase64(KEY_NULL);
g_assert(MEGA_IS_AES_KEY(k));
g_assert(!mega_aes_key_is_loaded(k));
g_object_unref(k);
g_test_expect_message(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*data != NULL*");
k = mega_aes_key_new_from_ubase64(NULL);
g_test_assert_expected_messages();
g_assert(MEGA_IS_AES_KEY(k));
g_assert(!mega_aes_key_is_loaded(k));
g_object_unref(k);
}
static void test_coroutine_simple(void)
{
struct coroutine *self = coroutine_self();
struct coroutine co = {
.stack_size = 16 << 20,
.entry = co_entry_42,
};
gpointer result;
g_assert(coroutine_self_is_main());
coroutine_init(&co);
result = coroutine_yieldto(&co, GINT_TO_POINTER(42));
g_assert_cmpint(GPOINTER_TO_INT(result), ==, 0x42);
g_test_expect_message(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*!to->exited*");
coroutine_yieldto(&co, GINT_TO_POINTER(42));
g_test_assert_expected_messages();
g_assert(self == coroutine_self());
g_assert(coroutine_self_is_main());
}
static gpointer co_entry_two(gpointer data)
{
struct coroutine *self = coroutine_self();
struct coroutine co = {
.stack_size = 16 << 20,
.entry = co_entry_check_self,
};
g_assert(!coroutine_self_is_main());
coroutine_init(&co);
coroutine_yieldto(&co, &co);
g_assert(self == coroutine_self());
return NULL;
}
static void test_coroutine_two(void)
{
struct coroutine *self = coroutine_self();
struct coroutine co = {
.stack_size = 16 << 20,
.entry = co_entry_two,
};
coroutine_init(&co);
coroutine_yieldto(&co, NULL);
g_assert(self == coroutine_self());
}
static gpointer co_entry_yield(gpointer data)
{
gpointer val;
g_assert(data == NULL);
val = coroutine_yield(GINT_TO_POINTER(1));
g_assert_cmpint(GPOINTER_TO_INT(val), ==, 2);
g_assert(!coroutine_self_is_main());
val = coroutine_yield(GINT_TO_POINTER(3));
g_assert_cmpint(GPOINTER_TO_INT(val), ==, 4);
return NULL;
}
static void test_coroutine_yield(void)
{
struct coroutine *self = coroutine_self();
struct coroutine co = {
.stack_size = 16 << 20,
.entry = co_entry_yield,
};
gpointer val;
coroutine_init(&co);
val = coroutine_yieldto(&co, NULL);
g_assert(self == coroutine_self());
g_assert_cmpint(GPOINTER_TO_INT(val), ==, 1);
val = coroutine_yieldto(&co, GINT_TO_POINTER(2));
g_assert(self == coroutine_self());
g_assert_cmpint(GPOINTER_TO_INT(val), ==, 3);
val = coroutine_yieldto(&co, GINT_TO_POINTER(4));
g_assert(self == coroutine_self());
g_assert(val == NULL);
g_test_expect_message(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*!to->exited*");
coroutine_yieldto(&co, GINT_TO_POINTER(42));
g_test_assert_expected_messages();
}
int main(int argc, char* argv[])
{
g_test_init(&argc, &argv, NULL);
g_test_add_func("/coroutine/simple", test_coroutine_simple);
g_test_add_func("/coroutine/two", test_coroutine_two);
g_test_add_func("/coroutine/yield", test_coroutine_yield);
return g_test_run ();
}
static void
test_callback_after_end_of_operation (void)
{
g_test_expect_message("Grilo", G_LOG_LEVEL_WARNING, "*Can't retrieve current operation*");
execute_resolve_test (TEST_CALLBACK_ON_FINISHED_OP);
}
static void
test_wifi_wpa_psk (const char *detail,
OptType key_type,
const char *key_data,
const unsigned char *expected,
size_t expected_size)
{
NMConnection *connection;
NMSettingConnection *s_con;
NMSettingWireless *s_wifi;
NMSettingWirelessSecurity *s_wsec;
NMSettingIPConfig *s_ip4;
NMSupplicantConfig *config;
GHashTable *hash;
char *uuid;
gboolean success;
GError *error = NULL;
GBytes *ssid;
const unsigned char ssid_data[] = { 0x54, 0x65, 0x73, 0x74, 0x20, 0x53, 0x53, 0x49, 0x44 };
const char *bssid_str = "11:22:33:44:55:66";
connection = nm_simple_connection_new ();
/* Connection setting */
s_con = (NMSettingConnection *) nm_setting_connection_new ();
nm_connection_add_setting (connection, NM_SETTING (s_con));
uuid = nm_utils_uuid_generate ();
g_object_set (s_con,
NM_SETTING_CONNECTION_ID, "Test Wifi WEP Key",
NM_SETTING_CONNECTION_UUID, uuid,
NM_SETTING_CONNECTION_AUTOCONNECT, TRUE,
NM_SETTING_CONNECTION_TYPE, NM_SETTING_WIRELESS_SETTING_NAME,
NULL);
g_free (uuid);
/* Wifi setting */
s_wifi = (NMSettingWireless *) nm_setting_wireless_new ();
nm_connection_add_setting (connection, NM_SETTING (s_wifi));
ssid = g_bytes_new (ssid_data, sizeof (ssid_data));
g_object_set (s_wifi,
NM_SETTING_WIRELESS_SSID, ssid,
NM_SETTING_WIRELESS_BSSID, bssid_str,
NM_SETTING_WIRELESS_MODE, "infrastructure",
NM_SETTING_WIRELESS_BAND, "bg",
NULL);
g_bytes_unref (ssid);
/* Wifi Security setting */
s_wsec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new ();
nm_connection_add_setting (connection, NM_SETTING (s_wsec));
g_object_set (s_wsec,
NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "wpa-psk",
NM_SETTING_WIRELESS_SECURITY_PSK, key_data,
NULL);
nm_setting_wireless_security_add_proto (s_wsec, "wpa");
nm_setting_wireless_security_add_proto (s_wsec, "rsn");
nm_setting_wireless_security_add_pairwise (s_wsec, "tkip");
nm_setting_wireless_security_add_pairwise (s_wsec, "ccmp");
nm_setting_wireless_security_add_group (s_wsec, "tkip");
nm_setting_wireless_security_add_group (s_wsec, "ccmp");
/* IP4 setting */
s_ip4 = (NMSettingIPConfig *) nm_setting_ip4_config_new ();
nm_connection_add_setting (connection, NM_SETTING (s_ip4));
g_object_set (s_ip4, NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO, NULL);
ASSERT (nm_connection_verify (connection, &error) == TRUE,
detail, "failed to verify connection: %s",
(error && error->message) ? error->message : "(unknown)");
config = nm_supplicant_config_new ();
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'ssid' value 'Test SSID'*");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'scan_ssid' value '1'*");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'bssid' value '11:22:33:44:55:66'*");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'freq_list' value *");
success = nm_supplicant_config_add_setting_wireless (config, s_wifi, 0);
ASSERT (success == TRUE,
detail, "failed to add wireless setting to supplicant config.");
g_test_assert_expected_messages ();
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'key_mgmt' value 'WPA-PSK'");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'psk' value *");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'proto' value 'WPA RSN'");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'pairwise' value 'TKIP CCMP'");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'group' value 'TKIP CCMP'");
success = nm_supplicant_config_add_setting_wireless_security (config,
s_wsec,
NULL,
"376aced7-b28c-46be-9a62-fcdf072571da");
ASSERT (success == TRUE,
detail, "failed to add wireless security to supplicant config.");
g_test_assert_expected_messages ();
hash = nm_supplicant_config_get_hash (config);
ASSERT (hash != NULL,
detail, "failed to hash supplicant config options.");
validate_opt (detail, hash, "scan_ssid", TYPE_INT, GINT_TO_POINTER (1), -1);
validate_opt (detail, hash, "ssid", TYPE_BYTES, ssid_data, sizeof (ssid_data));
validate_opt (detail, hash, "bssid", TYPE_KEYWORD, bssid_str, -1);
validate_opt (detail, hash, "key_mgmt", TYPE_KEYWORD, "WPA-PSK", -1);
validate_opt (detail, hash, "proto", TYPE_KEYWORD, "WPA RSN", -1);
validate_opt (detail, hash, "pairwise", TYPE_KEYWORD, "TKIP CCMP", -1);
validate_opt (detail, hash, "group", TYPE_KEYWORD, "TKIP CCMP", -1);
validate_opt (detail, hash, "psk", key_type, expected, expected_size);
g_object_unref (connection);
}
static void
test_wifi_open (void)
{
NMConnection *connection;
NMSettingConnection *s_con;
NMSettingWireless *s_wifi;
NMSettingIPConfig *s_ip4;
NMSupplicantConfig *config;
GHashTable *hash;
char *uuid;
gboolean success;
GError *error = NULL;
GBytes *ssid;
const unsigned char ssid_data[] = { 0x54, 0x65, 0x73, 0x74, 0x20, 0x53, 0x53, 0x49, 0x44 };
const char *bssid_str = "11:22:33:44:55:66";
connection = nm_simple_connection_new ();
/* Connection setting */
s_con = (NMSettingConnection *) nm_setting_connection_new ();
nm_connection_add_setting (connection, NM_SETTING (s_con));
uuid = nm_utils_uuid_generate ();
g_object_set (s_con,
NM_SETTING_CONNECTION_ID, "Test Wifi Open",
NM_SETTING_CONNECTION_UUID, uuid,
NM_SETTING_CONNECTION_AUTOCONNECT, TRUE,
NM_SETTING_CONNECTION_TYPE, NM_SETTING_WIRELESS_SETTING_NAME,
NULL);
g_free (uuid);
/* Wifi setting */
s_wifi = (NMSettingWireless *) nm_setting_wireless_new ();
nm_connection_add_setting (connection, NM_SETTING (s_wifi));
ssid = g_bytes_new (ssid_data, sizeof (ssid_data));
g_object_set (s_wifi,
NM_SETTING_WIRELESS_SSID, ssid,
NM_SETTING_WIRELESS_BSSID, bssid_str,
NM_SETTING_WIRELESS_MODE, "infrastructure",
NM_SETTING_WIRELESS_BAND, "bg",
NULL);
g_bytes_unref (ssid);
/* IP4 setting */
s_ip4 = (NMSettingIPConfig *) nm_setting_ip4_config_new ();
nm_connection_add_setting (connection, NM_SETTING (s_ip4));
g_object_set (s_ip4, NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO, NULL);
ASSERT (nm_connection_verify (connection, &error) == TRUE,
"wifi-open", "failed to verify connection: %s",
(error && error->message) ? error->message : "(unknown)");
config = nm_supplicant_config_new ();
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'ssid' value 'Test SSID'*");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'scan_ssid' value '1'*");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'bssid' value '11:22:33:44:55:66'*");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'freq_list' value *");
success = nm_supplicant_config_add_setting_wireless (config, s_wifi, 0);
ASSERT (success == TRUE,
"wifi-open", "failed to add wireless setting to supplicant config.");
g_test_assert_expected_messages ();
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'key_mgmt' value 'NONE'");
success = nm_supplicant_config_add_no_security (config);
ASSERT (success == TRUE,
"wifi-open", "failed to add wireless security to supplicant config.");
g_test_assert_expected_messages ();
hash = nm_supplicant_config_get_hash (config);
ASSERT (hash != NULL,
"wifi-open", "failed to hash supplicant config options.");
validate_opt ("wifi-open", hash, "scan_ssid", TYPE_INT, GINT_TO_POINTER (1), -1);
validate_opt ("wifi-open", hash, "ssid", TYPE_BYTES, ssid_data, sizeof (ssid_data));
validate_opt ("wifi-open", hash, "bssid", TYPE_KEYWORD, bssid_str, -1);
validate_opt ("wifi-open", hash, "key_mgmt", TYPE_KEYWORD, "NONE", -1);
g_object_unref (connection);
}
