static void testWebContextSecurityFileXHR(WebViewTest* test, gconstpointer)
{
GUniquePtr<char> fileURL(g_strdup_printf("file://%s/simple.html", Test::getResourcesDir(Test::WebKit2Resources).data()));
test->loadURI(fileURL.get());
test->waitUntilLoadFinished();
GUniquePtr<char> jsonURL(g_strdup_printf("file://%s/simple.json", Test::getResourcesDir().data()));
GUniquePtr<char> xhr(g_strdup_printf("var xhr = new XMLHttpRequest; xhr.open(\"GET\", \"%s\"); xhr.send();", jsonURL.get()));
// By default file access is not allowed, this will fail with a cross-origin error.
GUniqueOutPtr<GError> error;
WebKitJavascriptResult* javascriptResult = test->runJavaScriptAndWaitUntilFinished(xhr.get(), &error.outPtr());
g_assert(!javascriptResult);
g_assert_error(error.get(), WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_SCRIPT_FAILED);
// Allow file access from file URLs.
webkit_settings_set_allow_file_access_from_file_urls(webkit_web_view_get_settings(test->m_webView), TRUE);
test->loadURI(fileURL.get());
test->waitUntilLoadFinished();
javascriptResult = test->runJavaScriptAndWaitUntilFinished(xhr.get(), &error.outPtr());
g_assert(javascriptResult);
g_assert(!error);
// It isn't still possible to load file from an HTTP URL.
test->loadURI(kServer->getURIForPath("/").data());
test->waitUntilLoadFinished();
javascriptResult = test->runJavaScriptAndWaitUntilFinished(xhr.get(), &error.outPtr());
g_assert(!javascriptResult);
g_assert_error(error.get(), WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_SCRIPT_FAILED);
webkit_settings_set_allow_file_access_from_file_urls(webkit_web_view_get_settings(test->m_webView), FALSE);
}
void
test_flickr_error (void)
{
RestXmlParser *parser;
RestXmlNode *root;
GError *error;
const char test_1[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
"<rsp stat=\"ok\"><auth></auth></rsp>";
const char test_2[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
"<foobar/>";
const char test_3[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
"<rsp stat=\"fail\"><err code=\"108\" msg=\"Invalid frob\" /></rsp>";
parser = rest_xml_parser_new ();
root = rest_xml_parser_parse_from_data (parser, test_1, sizeof (test_1) - 1);
error = NULL;
flickr_proxy_is_successful (root, &error);
g_assert_no_error (error);
rest_xml_node_unref (root);
error = NULL;
root = rest_xml_parser_parse_from_data (parser, test_2, sizeof (test_2) - 1);
flickr_proxy_is_successful (root, &error);
g_assert_error (error, FLICKR_PROXY_ERROR, 0);
g_error_free (error);
rest_xml_node_unref (root);
error = NULL;
root = rest_xml_parser_parse_from_data (parser, test_3, sizeof (test_3) - 1);
flickr_proxy_is_successful (root, &error);
g_assert_error (error, FLICKR_PROXY_ERROR, 108);
g_error_free (error);
rest_xml_node_unref (root);
}
static void
test_create_bad_config(void)
{
struct election_manager_s *m = NULL;
GError *err;
struct replication_config_s cfg0 = { NULL, _get_peers, _get_vers,
NULL, ELECTION_MODE_NONE};
err = election_manager_create(&cfg0, &m);
g_assert_error(err, GQ(), ERRCODE_PARAM);
g_clear_error(&err);
struct replication_config_s cfg1 = { _get_id, NULL, _get_vers,
NULL, ELECTION_MODE_NONE};
err = election_manager_create(&cfg1, &m);
g_assert_error(err, GQ(), ERRCODE_PARAM);
g_clear_error(&err);
struct replication_config_s cfg2 = { _get_id, _get_peers, NULL,
NULL, ELECTION_MODE_NONE};
err = election_manager_create(&cfg2, &m);
g_assert_error(err, GQ(), ERRCODE_PARAM);
g_clear_error(&err);
struct replication_config_s cfg3 = { _get_id, _get_peers, _get_vers,
NULL, ELECTION_MODE_NONE+3};
err = election_manager_create(&cfg3, &m);
g_assert_error(err, GQ(), ERRCODE_PARAM);
g_clear_error(&err);
}
static void
test_resource (void)
{
const gchar *path;
GError *error = NULL;
GdkPixbuf *pixbuf, *ref;
path = g_test_get_filename (G_TEST_DIST, "icc-profile.png", NULL);
ref = gdk_pixbuf_new_from_file (path, &error);
g_assert_no_error (error);
pixbuf = gdk_pixbuf_new_from_resource ("/test/resource/icc-profile.png", &error);
g_assert_no_error (error);
g_assert (pixbuf_equal (pixbuf, ref));
g_object_unref (pixbuf);
pixbuf = gdk_pixbuf_new_from_resource ("/test/resource/icc-profile.pixdata", &error);
g_assert_no_error (error);
g_assert (pixdata_equal (pixbuf, ref));
g_object_unref (pixbuf);
pixbuf = gdk_pixbuf_new_from_resource ("/no/such/resource", &error);
g_assert (pixbuf == NULL);
g_assert_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
g_clear_error (&error);
pixbuf = gdk_pixbuf_new_from_resource ("resource:///test/resource/icc-profile.png", &error);
g_assert (pixbuf == NULL);
g_assert_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
g_clear_error (&error);
g_object_unref (ref);
}
static void testWebContextURIScheme(URISchemeTest* test, gconstpointer)
{
test->registerURISchemeHandler("foo", kBarHTML, strlen(kBarHTML), "text/html");
test->loadURI("foo:blank");
test->waitUntilLoadFinished();
size_t mainResourceDataSize = 0;
const char* mainResourceData = test->mainResourceData(mainResourceDataSize);
g_assert_cmpint(mainResourceDataSize, ==, strlen(kBarHTML));
g_assert(!strncmp(mainResourceData, kBarHTML, mainResourceDataSize));
test->registerURISchemeHandler("echo", kEchoHTMLFormat, -1, "text/html");
test->loadURI("echo:hello-world");
test->waitUntilLoadFinished();
GUniquePtr<char> echoHTML(g_strdup_printf(kEchoHTMLFormat, webkit_uri_scheme_request_get_path(test->m_uriSchemeRequest.get())));
mainResourceDataSize = 0;
mainResourceData = test->mainResourceData(mainResourceDataSize);
g_assert_cmpint(mainResourceDataSize, ==, strlen(echoHTML.get()));
g_assert(!strncmp(mainResourceData, echoHTML.get(), mainResourceDataSize));
test->loadURI("echo:with#fragment");
test->waitUntilLoadFinished();
g_assert_cmpstr(webkit_uri_scheme_request_get_path(test->m_uriSchemeRequest.get()), ==, "with");
g_assert_cmpstr(webkit_uri_scheme_request_get_uri(test->m_uriSchemeRequest.get()), ==, "echo:with#fragment");
echoHTML.reset(g_strdup_printf(kEchoHTMLFormat, webkit_uri_scheme_request_get_path(test->m_uriSchemeRequest.get())));
mainResourceDataSize = 0;
mainResourceData = test->mainResourceData(mainResourceDataSize);
g_assert_cmpint(mainResourceDataSize, ==, strlen(echoHTML.get()));
g_assert(!strncmp(mainResourceData, echoHTML.get(), mainResourceDataSize));
test->registerURISchemeHandler("nomime", kBarHTML, -1, 0);
test->m_loadEvents.clear();
test->loadURI("nomime:foo-bar");
test->waitUntilLoadFinished();
g_assert(test->m_loadEvents.contains(LoadTrackingTest::ProvisionalLoadFailed));
test->registerURISchemeHandler("empty", 0, 0, "text/html");
test->m_loadEvents.clear();
test->loadURI("empty:nothing");
test->waitUntilLoadFinished();
g_assert(!test->m_loadEvents.contains(LoadTrackingTest::ProvisionalLoadFailed));
g_assert(!test->m_loadEvents.contains(LoadTrackingTest::LoadFailed));
test->registerURISchemeHandler("error", 0, 0, 0);
test->m_loadEvents.clear();
test->loadURI("error:error");
test->waitUntilLoadFinished();
g_assert(test->m_loadEvents.contains(LoadTrackingTest::ProvisionalLoadFailed));
g_assert(test->m_loadFailed);
g_assert_error(test->m_error.get(), g_quark_from_string(errorDomain), errorCode);
g_assert_cmpstr(test->m_error->message, ==, errorMessage);
test->registerURISchemeHandler("closed", 0, 0, 0);
test->m_loadEvents.clear();
test->loadURI("closed:input-stream");
test->waitUntilLoadFinished();
g_assert(test->m_loadEvents.contains(LoadTrackingTest::ProvisionalLoadFailed));
g_assert(test->m_loadFailed);
g_assert_error(test->m_error.get(), G_IO_ERROR, G_IO_ERROR_CLOSED);
}
static void
get_system_language (void)
{
GwLanguage *language;
GError *error;
gboolean system_language_set;
/* Set a random language if host system has none set */
system_language_set = gw_get_system_language (NULL, NULL);
/* Create the language */
error = NULL;
language = gw_language_new_sync (NULL, NULL, &error);
if (!system_language_set)
{
g_assert_error (error, GW_LANGUAGE_ERROR, GW_LANGUAGE_ERROR_INVALID);
g_assert_null (language);
}
else
{
g_message ("Language: %s", gw_language_get_language_code (language));
g_assert_nonnull (language);
g_assert_no_error (error);
g_clear_object (&language);
}
g_clear_object (&language);
}
static void
post_auth_recv_stanza (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
WockyStanza *stanza;
GError *e = NULL;
/* ignore all stanza until close */
stanza = wocky_xmpp_connection_recv_stanza_finish (
WOCKY_XMPP_CONNECTION (source), result, &e);
if (stanza != NULL)
{
g_object_unref (stanza);
wocky_xmpp_connection_recv_stanza_async (
WOCKY_XMPP_CONNECTION (source), NULL,
post_auth_recv_stanza, user_data);
}
else
{
g_assert_error (e, WOCKY_XMPP_CONNECTION_ERROR,
WOCKY_XMPP_CONNECTION_ERROR_CLOSED);
g_error_free (e);
run_done = TRUE;
g_main_loop_quit (mainloop);
}
}
static void
test_invalid_bareword (gconstpointer user_data)
{
const char *json = user_data;
GError *error = NULL;
JsonParser *parser;
gboolean res;
parser = json_parser_new ();
g_assert (JSON_IS_PARSER (parser));
if (g_test_verbose ())
g_print ("invalid data: '%s'...", json);
res = json_parser_load_from_data (parser, json, -1, &error);
g_assert (!res);
g_assert_error (error, JSON_PARSER_ERROR, JSON_PARSER_ERROR_INVALID_BAREWORD);
if (g_test_verbose ())
g_print ("expected error: %s\n", error->message);
g_clear_error (&error);
g_object_unref (parser);
}
static void
system_language_loaded_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GwLanguage *language;
GMainLoop *mainloop;
GError *error;
gboolean system_language_set;
/* Set a random language if host system has none set */
system_language_set = gw_get_system_language (NULL, NULL);
error = NULL;
mainloop = user_data;
language = gw_language_new_finish (res, &error);
if (!system_language_set)
{
g_assert_error (error, GW_LANGUAGE_ERROR, GW_LANGUAGE_ERROR_INVALID);
g_assert_null (language);
}
else
{
g_message ("Language: %s", gw_language_get_language_code (language));
g_assert_nonnull (language);
g_assert_no_error (error);
g_clear_object (&language);
}
g_main_loop_quit (mainloop);
}
static void
_round_lock(sqlx_cache_t *cache)
{
hashstr_t *hn0 = NULL, *hn1 = NULL;
HASHSTR_ALLOCA(hn0, name0);
HASHSTR_ALLOCA(hn1, name1);
gint id0;
GError *err = sqlx_cache_open_and_lock_base(cache, hn0, &id0);
g_assert_no_error (err);
for (int i=0; i<5 ;i++) {
gint id = g_random_int();
err = sqlx_cache_open_and_lock_base(cache, hn0, &id);
g_assert_no_error (err);
g_assert_cmpint(id0, ==, id);
}
for (int i=0; i<6 ;i++) {
err = sqlx_cache_unlock_and_close_base(cache, id0, FALSE);
g_assert_no_error (err);
}
err = sqlx_cache_unlock_and_close_base(cache, id0, FALSE);
g_assert_error (err, GQ(), CODE_INTERNAL_ERROR);
g_clear_error (&err);
for (int i=0; i<5 ;i++) {
gint id = g_random_int ();
err = sqlx_cache_open_and_lock_base(cache, hn1, &id);
g_assert_no_error (err);
err = sqlx_cache_unlock_and_close_base(cache, id, FALSE);
g_assert_no_error (err);
}
}
static void test_cr_metadata_locate_and_load_xml(void)
{
test_helper_check_keys(TEST_REPO_00, CR_HT_KEY_HASH, REPO_SIZE_00, REPO_HASH_KEYS_00);
test_helper_check_keys(TEST_REPO_00, CR_HT_KEY_NAME, REPO_SIZE_00, REPO_NAME_KEYS_00);
test_helper_check_keys(TEST_REPO_00, CR_HT_KEY_FILENAME, REPO_SIZE_00, REPO_FILENAME_KEYS_00);
test_helper_check_keys(TEST_REPO_01, CR_HT_KEY_HASH, REPO_SIZE_01, REPO_HASH_KEYS_01);
test_helper_check_keys(TEST_REPO_01, CR_HT_KEY_NAME, REPO_SIZE_01, REPO_NAME_KEYS_01);
test_helper_check_keys(TEST_REPO_01, CR_HT_KEY_FILENAME, REPO_SIZE_01, REPO_FILENAME_KEYS_01);
test_helper_check_keys(TEST_REPO_02, CR_HT_KEY_HASH, REPO_SIZE_02, REPO_HASH_KEYS_02);
test_helper_check_keys(TEST_REPO_02, CR_HT_KEY_NAME, REPO_SIZE_02, REPO_NAME_KEYS_02);
test_helper_check_keys(TEST_REPO_02, CR_HT_KEY_FILENAME, REPO_SIZE_02, REPO_FILENAME_KEYS_02);
#ifdef WITH_LIBMODULEMD
test_helper_check_keys(TEST_REPO_03, CR_HT_KEY_HASH, REPO_SIZE_03, REPO_HASH_KEYS_03);
test_helper_check_keys(TEST_REPO_03, CR_HT_KEY_NAME, REPO_SIZE_03, REPO_NAME_KEYS_03);
test_helper_check_keys(TEST_REPO_03, CR_HT_KEY_FILENAME, REPO_SIZE_03, REPO_FILENAME_KEYS_03);
#else
/* If we don't have libmodulemd support, this should fail to locate and
* return CRE_MODULEMD
*/
struct cr_MetadataLocation *ml;
g_autoptr (GError) err = NULL;
ml = cr_locate_metadata(TEST_REPO_03, TRUE, &err);
g_assert_error (err, CREATEREPO_C_ERROR, CRE_MODULEMD);
#endif /* WITH_LIBMODULEMD */
}
void TestNewForUser() {
gchar *policy1_path = CacheTestGetDataPath("policy1.conf");
gchar *policy2_path = CacheTestGetDataPath("policy2.conf");
gchar *policy_paths [] = {policy1_path, policy2_path, NULL};
GError *error = NULL;
CachePolicy *policy = NULL;
policy = CachePolicyNewForUser("janedoe", policy_paths, &error);
g_assert_no_error(error);
g_assert(policy);
g_assert_cmpint(5, ==, policy->max_tries);
CachePolicyUnref(policy);
policy = CachePolicyNewForUser("johndoe", policy_paths, &error);
g_assert_no_error(error);
g_assert(policy);
g_assert_cmpint(0, ==, policy->max_tries);
CachePolicyUnref(policy);
policy = CachePolicyNewForUser("nope", policy_paths, &error);
g_assert(!policy);
g_assert_error(error, CACHE_POLICY_ERROR, CACHE_POLICY_UNKNOWN_USER_ERROR);
g_error_free(error);
g_free(policy1_path);
g_free(policy2_path);
}
static void
test_notnull (void)
{
GomAdapter *adapter;
GomRepository *repository;
GList *object_types;
ItemResource *item;
GError *error = NULL;
adapter = gom_adapter_new();
gom_adapter_open_sync(adapter, ":memory:", &error);
g_assert_no_error(error);
repository = gom_repository_new(adapter);
object_types = g_list_prepend(NULL, GINT_TO_POINTER(ITEM_TYPE_RESOURCE));
gom_repository_automatic_migrate_sync(repository, 1, object_types, &error);
g_assert_no_error(error);
/* Insert an item without a name */
item = g_object_new (ITEM_TYPE_RESOURCE, "repository", repository,
"email", "*****@*****.**",
NULL);
gom_resource_save_sync(GOM_RESOURCE(item), &error);
g_assert_error(error, GOM_ERROR, GOM_ERROR_COMMAND_SQLITE);
g_assert (strstr (error->message, "NOT NULL") != NULL);
g_assert (strstr (error->message, "items.name") != NULL);
g_clear_error(&error);
g_object_unref(item);
/* Try inserting an item without an email */
item = g_object_new (ITEM_TYPE_RESOURCE, "repository", repository,
"name", "gom",
NULL);
gom_resource_save_sync(GOM_RESOURCE(item), &error);
g_assert_error(error, GOM_ERROR, GOM_ERROR_COMMAND_SQLITE);
g_assert (strstr (error->message, "NOT NULL") != NULL);
g_assert (strstr (error->message, "items.email") != NULL);
g_clear_error(&error);
g_object_unref(item);
gom_adapter_close_sync(adapter, &error);
g_assert_no_error(error);
g_object_unref(repository);
g_object_unref(adapter);
}
static void onSnapshotReady(WebKitWebView* web_view, GAsyncResult* res, WebViewTest* test)
{
GOwnPtr<GError> error;
test->m_surface = webkit_web_view_get_snapshot_finish(web_view, res, &error.outPtr());
g_assert(!test->m_surface || !error.get());
if (error)
g_assert_error(error.get(), WEBKIT_SNAPSHOT_ERROR, WEBKIT_SNAPSHOT_ERROR_FAILED_TO_CREATE);
test->quitMainLoop();
}
static void
run_test (gconstpointer user_data)
{
TestSaslAuthServer *server;
WockyTestStream *stream;
test_t *test = (test_t *) user_data;
stream = g_object_new (WOCKY_TYPE_TEST_STREAM, NULL);
server = test_sasl_auth_server_new (stream->stream0, test->mech,
test->username, test->password, test->servername, test->problem, TRUE);
authenticated = FALSE;
run_done = FALSE;
current_test = test;
xmpp_connection = stream->stream1;
conn = wocky_xmpp_connection_new (xmpp_connection);
wocky_xmpp_connection_send_open_async (conn,
test->servername, NULL, "1.0", NULL, NULL,
NULL, stream_open_sent, test);
if (!run_done)
{
g_main_loop_run (mainloop);
}
if (sasl != NULL)
{
g_object_unref (sasl);
sasl = NULL;
}
test_sasl_auth_server_stop (server);
g_object_unref (server);
g_object_unref (stream);
g_object_unref (conn);
if (test->domain == 0)
{
g_assert (authenticated);
g_assert_no_error (error);
}
else
{
g_assert (!authenticated);
g_assert_error (error, test->domain, test->code);
}
if (error != NULL)
g_error_free (error);
error = NULL;
}
void TestSetValue() {
CachePolicy *policy = CachePolicyNew();
GError *error = NULL;
g_assert_cmpint(0, ==, policy->max_tries);
g_assert(CachePolicySetValue(policy, "tries", "5", &error));
g_assert_no_error(error);
g_assert_cmpint(5, ==, policy->max_tries);
g_assert(!CachePolicySetValue(policy, "tries", "nope", &error));
g_assert_error(error, CACHE_POLICY_ERROR, CACHE_POLICY_INVALID_VALUE_ERROR);
g_assert_cmpint(5, ==, policy->max_tries);
g_error_free(error);
error = NULL;
g_assert_cmpint(0, ==, policy->refresh_before);
g_assert(CachePolicySetValue(policy, "refresh", "2d", &error));
g_assert_no_error(error);
g_assert_cmpint(2*G_TIME_SPAN_DAY, ==, policy->refresh_before);
g_assert(!CachePolicySetValue(policy, "refresh", "5days", &error));
g_assert_error(error, CACHE_POLICY_ERROR, CACHE_POLICY_INVALID_VALUE_ERROR);
g_assert_cmpint(2*G_TIME_SPAN_DAY, ==, policy->refresh_before);
g_error_free(error);
error = NULL;
g_assert_cmpint(0, ==, policy->renew_after);
g_assert(CachePolicySetValue(policy, "renew", "1w", &error));
g_assert_no_error(error);
g_assert_cmpint(7*G_TIME_SPAN_DAY, ==, policy->renew_after);
g_assert_cmpint(0, ==, policy->expire_after);
g_assert(CachePolicySetValue(policy, "expire", "3w", &error));
g_assert_no_error(error);
g_assert_cmpint(3*7*G_TIME_SPAN_DAY, ==, policy->expire_after);
g_assert(!CachePolicySetValue(policy, "nope", "1", &error));
g_assert_error(error, CACHE_POLICY_ERROR, CACHE_POLICY_UNKNOWN_KEY_ERROR);
g_error_free(error);
CachePolicyUnref(policy);
}
static void
test_invalid_modules (Test *test, gconstpointer unused)
{
GckModule *invalid;
GError *error = NULL;
/* Shouldn't be able to load modules */
invalid = gck_module_initialize ("blah-blah-non-existant", NULL, &error);
g_assert_error (error, GCK_ERROR, (int)CKR_GCK_MODULE_PROBLEM);
g_assert (invalid == NULL);
g_clear_error (&error);
/* Shouldn't be able to load any file successfully */
invalid = gck_module_initialize ("/usr/lib/libm.so", NULL, &error);
g_assert_error (error, GCK_ERROR, (int)CKR_GCK_MODULE_PROBLEM);
g_assert (invalid == NULL);
g_clear_error (&error);
}
static void test_decode_nval(void)
{
GObexPacket *pkt;
GError *err = NULL;
pkt = g_obex_packet_decode(pkt_nval_len, sizeof(pkt_nval_len), 0,
G_OBEX_DATA_REF, &err);
g_assert_error(err, G_OBEX_ERROR, G_OBEX_ERROR_PARSE_ERROR);
g_assert(pkt == NULL);
g_error_free(err);
}
static void decode_header_nval(uint8_t *buf, size_t len)
{
GObexHeader *header;
size_t parsed;
GError *err = NULL;
header = g_obex_header_decode(buf, len, G_OBEX_DATA_REF, &parsed,
&err);
g_assert_error(err, G_OBEX_ERROR, G_OBEX_ERROR_PARSE_ERROR);
g_assert(header == NULL);
g_error_free(err);
}
static void
test_pipefrom_version(struct cfg_s *cfg0, struct cfg_s *cfg1, gint64 r)
{
gint64 worst = 0;
GTree *v0 = build_version(cfg0);
GTree *v1 = build_version(cfg1);
GError *err = version_validate_diff(v0, v1, &worst);
g_assert_error(err, GQD("sqliterepo"), CODE_PIPEFROM);
g_assert(r == worst);
g_tree_destroy(v0);
g_tree_destroy(v1);
}
static void
test_concurrent_version(struct cfg_s *cfg0, struct cfg_s *cfg1)
{
gint64 worst = 0;
GTree *v0 = build_version(cfg0);
GTree *v1 = build_version(cfg1);
GError *err = version_validate_diff(v0, v1, &worst);
g_assert_error(err, GQD("sqliterepo"), CODE_CONCURRENT);
g_assert(0 == worst);
g_tree_destroy(v0);
g_tree_destroy(v1);
}
static void checksum_test1(void)
{
RaucChecksum checksum = {};
GError *error = NULL;
checksum.type = 0;
checksum.digest = NULL;
g_assert_false(verify_checksum(&checksum, "test/install-content/appfs.img", &error));
g_assert_error(error, R_CHECKSUM_ERROR, R_CHECKSUM_ERROR_FAILED);
g_clear_error(&error);
checksum.type = G_CHECKSUM_SHA256;
checksum.digest = g_strdup(TEST_DIGEST_FAIL);
g_assert_false(verify_checksum(&checksum, "test/install-content/appfs.img", &error));
g_assert_error(error, R_CHECKSUM_ERROR, R_CHECKSUM_ERROR_SIZE_MISMATCH);
g_clear_error(&error);
checksum.size = 32768;
g_assert_false(verify_checksum(&checksum, "test/install-content/appfs.img", &error));
g_assert_error(error, R_CHECKSUM_ERROR, R_CHECKSUM_ERROR_DIGEST_MISMATCH);
g_clear_error(&error);
checksum.size = 0;
checksum.digest = g_strdup(TEST_DIGEST_GOOD);
g_assert_false(verify_checksum(&checksum, "test/install-content/appfs.img", &error));
g_assert_error(error, R_CHECKSUM_ERROR, R_CHECKSUM_ERROR_SIZE_MISMATCH);
g_clear_error(&error);
checksum.size = 32768;
g_assert_true(verify_checksum(&checksum, "test/install-content/appfs.img", &error));
g_assert_no_error(error);
g_assert_false(verify_checksum(&checksum, "tesinstall-content/rootfs.img", &error));
g_assert_error(error, G_FILE_ERROR, G_FILE_ERROR_NOENT);
g_clear_error(&error);
g_assert_false(verify_checksum(&checksum, "test/_MISSING_", &error));
g_assert_error(error, G_FILE_ERROR, G_FILE_ERROR_NOENT);
g_clear_error(&error);
g_clear_pointer(&checksum.digest, g_free);
checksum.size = 0;
g_assert_true(compute_checksum(&checksum, "test/install-content/appfs.img", &error));
g_assert_no_error(error);
g_assert_cmpstr(checksum.digest, ==, TEST_DIGEST_GOOD);
g_assert(checksum.size == 32768);
g_clear_pointer(&checksum.digest, g_free);
checksum.size = 0;
g_assert_false(compute_checksum(&checksum, "tesinstall-content/rootfs.img", &error));
g_assert_error(error, G_FILE_ERROR, G_FILE_ERROR_NOENT);
g_clear_error(&error);
g_assert_null(checksum.digest);
g_assert(checksum.size == 0);
}
static void testWebContextLanguages(WebViewTest* test, gconstpointer)
{
static const char* expectedDefaultLanguage = "en-US";
test->loadURI(kServer->getURIForPath("/").data());
test->waitUntilLoadFinished();
size_t mainResourceDataSize = 0;
const char* mainResourceData = test->mainResourceData(mainResourceDataSize);
g_assert_cmpuint(mainResourceDataSize, ==, strlen(expectedDefaultLanguage));
g_assert(!strncmp(mainResourceData, expectedDefaultLanguage, mainResourceDataSize));
GRefPtr<GPtrArray> languages = adoptGRef(g_ptr_array_new());
g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("en")));
g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("ES_es")));
g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("dE")));
g_ptr_array_add(languages.get(), 0);
webkit_web_context_set_preferred_languages(test->m_webContext.get(), reinterpret_cast<const char* const*>(languages->pdata));
static const char* expectedLanguages = "en, es-es;q=0.90, de;q=0.80";
test->loadURI(kServer->getURIForPath("/").data());
test->waitUntilLoadFinished();
mainResourceDataSize = 0;
mainResourceData = test->mainResourceData(mainResourceDataSize);
g_assert_cmpuint(mainResourceDataSize, ==, strlen(expectedLanguages));
g_assert(!strncmp(mainResourceData, expectedLanguages, mainResourceDataSize));
// When using the C locale, en-US should be used as default.
const char* cLanguage[] = { "C", nullptr };
webkit_web_context_set_preferred_languages(test->m_webContext.get(), cLanguage);
GUniqueOutPtr<GError> error;
WebKitJavascriptResult* javascriptResult = test->runJavaScriptAndWaitUntilFinished("Intl.DateTimeFormat().resolvedOptions().locale", &error.outPtr());
g_assert(javascriptResult);
g_assert(!error);
GUniquePtr<char> locale(WebViewTest::javascriptResultToCString(javascriptResult));
g_assert_cmpstr(locale.get(), ==, expectedDefaultLanguage);
// When using the POSIX locale, en-US should be used as default.
const char* posixLanguage[] = { "POSIX", nullptr };
webkit_web_context_set_preferred_languages(test->m_webContext.get(), posixLanguage);
javascriptResult = test->runJavaScriptAndWaitUntilFinished("Intl.DateTimeFormat().resolvedOptions().locale", &error.outPtr());
g_assert(javascriptResult);
g_assert(!error);
locale.reset(WebViewTest::javascriptResultToCString(javascriptResult));
g_assert_cmpstr(locale.get(), ==, expectedDefaultLanguage);
// An invalid locale should throw an exception.
const char* invalidLanguage[] = { "A", nullptr };
webkit_web_context_set_preferred_languages(test->m_webContext.get(), invalidLanguage);
javascriptResult = test->runJavaScriptAndWaitUntilFinished("Intl.DateTimeFormat().resolvedOptions().locale", &error.outPtr());
g_assert(!javascriptResult);
g_assert_error(error.get(), WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_SCRIPT_FAILED);
}
static void ssh_args(void) {
GError *err = NULL;
gchar *valid_args[] = {
"connecttimeout=5",
"KexAlgorithms=ssh",
"LogLevel=foo",
"hostkeyalgorithms=bar",
"compression =zlib",
"GSSAPIDelegateCredentials=asdf",
NULL
};
g_assert(! wsh_ssh_check_args(valid_args, &err));
g_assert_no_error(err);
gchar *invalid_args[] = {
"connecttimeout",
NULL,
};
g_assert(wsh_ssh_check_args(invalid_args, &err));
g_assert_error(err, WSH_SSH_ERROR, WSH_SSH_OPT_INVALID);
gchar *notsupp_args[] = {
"foo=5",
NULL
};
g_assert(wsh_ssh_check_args(notsupp_args, &err));
g_assert_error(err, WSH_SSH_ERROR, WSH_SSH_OPT_NOT_SUPPORTED);
gchar *no_args[] = {
NULL
};
g_assert(! wsh_ssh_check_args(no_args, &err));
}
void TestGetMissingEntry() {
CacheTestInitFiles();
CacheStorage *storage = CacheStorageNew("/mock");
g_assert(storage);
GError *error = NULL;
CacheEntry *entry = CacheStorageGetEntry(storage, "testuser", &error);
g_assert(!entry);
g_assert_error(error, CACHE_STORAGE_ERROR, CACHE_STORAGE_FILE_ERROR);
g_error_free(error);
CacheStorageUnref(storage);
}
void TestGetInvalidUsername() {
CacheTestInitFiles();
CacheStorage *storage = CacheStorageNew("/mock");
g_assert(storage);
GError *error = NULL;
CacheEntry *entry = CacheStorageGetEntry(storage, "../testuser", &error);
g_assert(!entry);
g_assert_error(error, CACHE_STORAGE_ERROR, CACHE_STORAGE_USERNAME_ERROR);
g_error_free(error);
CacheStorageUnref(storage);
}
static void
on_connected_cancelled (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
GSocketConnection *conn;
GError *error = NULL;
conn = g_socket_client_connect_to_uri_finish (G_SOCKET_CLIENT (source_object), result, &error);
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
g_assert_null (conn);
g_error_free (error);
g_main_loop_quit (user_data);
}
static void
test_remove_object_empty_uid (ETestServerFixture *fixture,
gconstpointer user_data)
{
ECalClient *cal_client;
GError *error = NULL;
g_test_bug ("697705");
cal_client = E_TEST_SERVER_UTILS_SERVICE (fixture, ECalClient);
e_cal_client_remove_object_sync (
cal_client, "", NULL, E_CAL_OBJ_MOD_ALL, NULL, &error);
g_assert_error (
error, E_CAL_CLIENT_ERROR,
E_CAL_CLIENT_ERROR_OBJECT_NOT_FOUND);
}
static void
test_connection_loss (void)
{
GDBusProxy *proxy;
GError *error;
error = NULL;
proxy = g_dbus_proxy_new_sync (c,
G_DBUS_PROXY_FLAGS_NONE,
NULL, /* GDBusInterfaceInfo */
"com.example.TestService", /* name */
"/com/example/TestObject", /* object path */
"com.example.Frob", /* interface */
NULL, /* GCancellable */
&error);
g_assert_no_error (error);
error = NULL;
g_dbus_proxy_call (proxy,
"Sleep",
g_variant_new ("(i)", 100 * 1000 /* msec */),
G_DBUS_CALL_FLAGS_NONE,
10 * 1000 /* msec */,
NULL, /* GCancellable */
sleep_cb,
&error);
/* Make sure we don't exit when the bus goes away */
g_dbus_connection_set_exit_on_close (c, FALSE);
/* Nuke the connection to the bus */
g_timeout_add (100 /* ms */, on_timeout, NULL);
g_main_loop_run (loop);
/* If we didn't act on connection-loss we'd be getting G_IO_ERROR_TIMEOUT
* generated locally. So if we get G_IO_ERROR_CLOSED it means that we
* are acting correctly on connection loss.
*/
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED);
g_assert (!g_dbus_error_is_remote_error (error));
g_clear_error (&error);
g_object_unref (proxy);
}
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);
}
