fdo-mirrors/wireplumber
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/wireplumber.git synced 2025-12-20 08:50:04 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
wireplumber/tests/wp/state.c

218 lines
6.9 KiB
C
Raw Permalink Normal View History

lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
/* WirePlumber
*
* Copyright © 2020 Collabora Ltd.
* @author Julian Bouzas <julian.bouzas@collabora.com>
*
* SPDX-License-Identifier: MIT
*/
log: implement a log topics system, like pipewire The intention is to make checks for enabled log topics faster. Every topic has its own structure that is statically defined in the file where the logs are printed from. The structure is initialized transparently when it is first used and it contains all the log level flags for the levels that this topic should print messages. It is then checked on the wp_log() macro before printing the message. Topics from SPA/PipeWire are also handled natively, so messages are printed directly without checking if the topic is enabled, since the PipeWire and SPA macros do the checking themselves. Messages coming from GLib are checked inside the handler. An internal WpLogFields object is used to manage the state of each log message, populating all the fields appropriately from the place they are coming from (wp_log, spa_log, glib log), formatting the message and then printing it. For printing to the journald, we still use the glib message handler, converting all the needed fields to GLogField on demand. That message handler does not do any checks for the topic or the level, so we can just call it to send the message.
2023-05-16 11:51:29 +03:00
#include "../common/test-log.h"
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
static void
test_state_basic (void)
{
state: remove support for groups and propagate save errors There is no real use for groups in our API. Just use the name of the file as the default group and be done with it... Storing multiple groups with this API is problematic because it forces flushing the file to disk multiple times, one for each group, and it's just more performant if we use a prefix in the keys to implement some form of logical separation. This commit also makes the GKeyFile a temporary object. As we always load the file from the file system in _load() and we always replace its contents with a new dictionary in _save(), there is no point in keeping the keyfile's internal data structures stored in memory. Save errors are now also propagated to adhere to the programming practices of GObject
2021-06-04 18:22:48 +03:00
g_autoptr (GError) error = NULL;
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
g_autoptr (WpState) state = wp_state_new ("basic");
g_assert_nonnull (state);
g_assert_cmpstr (wp_state_get_name (state), ==, "basic");
g_assert_true (g_str_has_suffix (wp_state_get_location (state), "basic"));
/* Save */
{
g_autoptr (WpProperties) props = wp_properties_new_empty ();
wp_properties_set (props, "key1", "value1");
wp_properties_set (props, "key2", "value2");
wp_properties_set (props, "key3", "value3");
state: remove support for groups and propagate save errors There is no real use for groups in our API. Just use the name of the file as the default group and be done with it... Storing multiple groups with this API is problematic because it forces flushing the file to disk multiple times, one for each group, and it's just more performant if we use a prefix in the keys to implement some form of logical separation. This commit also makes the GKeyFile a temporary object. As we always load the file from the file system in _load() and we always replace its contents with a new dictionary in _save(), there is no point in keeping the keyfile's internal data structures stored in memory. Save errors are now also propagated to adhere to the programming practices of GObject
2021-06-04 18:22:48 +03:00
g_assert_true (wp_state_save (state, props, &error));
g_assert_no_error (error);
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
}
/* Load */
{
state: remove support for groups and propagate save errors There is no real use for groups in our API. Just use the name of the file as the default group and be done with it... Storing multiple groups with this API is problematic because it forces flushing the file to disk multiple times, one for each group, and it's just more performant if we use a prefix in the keys to implement some form of logical separation. This commit also makes the GKeyFile a temporary object. As we always load the file from the file system in _load() and we always replace its contents with a new dictionary in _save(), there is no point in keeping the keyfile's internal data structures stored in memory. Save errors are now also propagated to adhere to the programming practices of GObject
2021-06-04 18:22:48 +03:00
g_autoptr (WpProperties) props = wp_state_load (state);
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
g_assert_nonnull (props);
g_assert_cmpstr (wp_properties_get (props, "key1"), ==, "value1");
g_assert_cmpstr (wp_properties_get (props, "key2"), ==, "value2");
g_assert_cmpstr (wp_properties_get (props, "key2"), ==, "value2");
g_assert_null (wp_properties_get (props, "invalid"));
}
/* Re-Save */
{
g_autoptr (WpProperties) props = wp_properties_new_empty ();
wp_properties_set (props, "new-key", "new-value");
state: remove support for groups and propagate save errors There is no real use for groups in our API. Just use the name of the file as the default group and be done with it... Storing multiple groups with this API is problematic because it forces flushing the file to disk multiple times, one for each group, and it's just more performant if we use a prefix in the keys to implement some form of logical separation. This commit also makes the GKeyFile a temporary object. As we always load the file from the file system in _load() and we always replace its contents with a new dictionary in _save(), there is no point in keeping the keyfile's internal data structures stored in memory. Save errors are now also propagated to adhere to the programming practices of GObject
2021-06-04 18:22:48 +03:00
g_assert_true (wp_state_save (state, props, &error));
g_assert_no_error (error);
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
}
/* Re-Load */
{
state: remove support for groups and propagate save errors There is no real use for groups in our API. Just use the name of the file as the default group and be done with it... Storing multiple groups with this API is problematic because it forces flushing the file to disk multiple times, one for each group, and it's just more performant if we use a prefix in the keys to implement some form of logical separation. This commit also makes the GKeyFile a temporary object. As we always load the file from the file system in _load() and we always replace its contents with a new dictionary in _save(), there is no point in keeping the keyfile's internal data structures stored in memory. Save errors are now also propagated to adhere to the programming practices of GObject
2021-06-04 18:22:48 +03:00
g_autoptr (WpProperties) props = wp_state_load (state);
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
g_assert_nonnull (props);
g_assert_cmpstr (wp_properties_get (props, "new-key"), ==, "new-value");
g_assert_null (wp_properties_get (props, "key1"));
g_assert_null (wp_properties_get (props, "key2"));
g_assert_null (wp_properties_get (props, "key3"));
}
wp_state_clear (state);
/* Load empty */
{
state: remove support for groups and propagate save errors There is no real use for groups in our API. Just use the name of the file as the default group and be done with it... Storing multiple groups with this API is problematic because it forces flushing the file to disk multiple times, one for each group, and it's just more performant if we use a prefix in the keys to implement some form of logical separation. This commit also makes the GKeyFile a temporary object. As we always load the file from the file system in _load() and we always replace its contents with a new dictionary in _save(), there is no point in keeping the keyfile's internal data structures stored in memory. Save errors are now also propagated to adhere to the programming practices of GObject
2021-06-04 18:22:48 +03:00
g_autoptr (WpProperties) props = wp_state_load (state);
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
g_assert_nonnull (props);
g_assert_null (wp_properties_get (props, "new-key"));
g_assert_null (wp_properties_get (props, "key1"));
g_assert_null (wp_properties_get (props, "key2"));
g_assert_null (wp_properties_get (props, "key3"));
}
wp_state_clear (state);
}
static void
test_state_empty (void)
{
state: remove support for groups and propagate save errors There is no real use for groups in our API. Just use the name of the file as the default group and be done with it... Storing multiple groups with this API is problematic because it forces flushing the file to disk multiple times, one for each group, and it's just more performant if we use a prefix in the keys to implement some form of logical separation. This commit also makes the GKeyFile a temporary object. As we always load the file from the file system in _load() and we always replace its contents with a new dictionary in _save(), there is no point in keeping the keyfile's internal data structures stored in memory. Save errors are now also propagated to adhere to the programming practices of GObject
2021-06-04 18:22:48 +03:00
g_autoptr (GError) error = NULL;
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
g_autoptr (WpState) state = wp_state_new ("empty");
g_assert_nonnull (state);
/* Save */
{
g_autoptr (WpProperties) props = wp_properties_new_empty ();
wp_properties_set (props, "key", "value");
state: remove support for groups and propagate save errors There is no real use for groups in our API. Just use the name of the file as the default group and be done with it... Storing multiple groups with this API is problematic because it forces flushing the file to disk multiple times, one for each group, and it's just more performant if we use a prefix in the keys to implement some form of logical separation. This commit also makes the GKeyFile a temporary object. As we always load the file from the file system in _load() and we always replace its contents with a new dictionary in _save(), there is no point in keeping the keyfile's internal data structures stored in memory. Save errors are now also propagated to adhere to the programming practices of GObject
2021-06-04 18:22:48 +03:00
g_assert_true (wp_state_save (state, props, &error));
g_assert_no_error (error);
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
}
/* Load */
{
state: remove support for groups and propagate save errors There is no real use for groups in our API. Just use the name of the file as the default group and be done with it... Storing multiple groups with this API is problematic because it forces flushing the file to disk multiple times, one for each group, and it's just more performant if we use a prefix in the keys to implement some form of logical separation. This commit also makes the GKeyFile a temporary object. As we always load the file from the file system in _load() and we always replace its contents with a new dictionary in _save(), there is no point in keeping the keyfile's internal data structures stored in memory. Save errors are now also propagated to adhere to the programming practices of GObject
2021-06-04 18:22:48 +03:00
g_autoptr (WpProperties) props = wp_state_load (state);
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
g_assert_nonnull (props);
g_assert_cmpstr (wp_properties_get (props, "key"), ==, "value");
}
/* Save empty */
{
g_autoptr (WpProperties) props = wp_properties_new_empty ();
state: remove support for groups and propagate save errors There is no real use for groups in our API. Just use the name of the file as the default group and be done with it... Storing multiple groups with this API is problematic because it forces flushing the file to disk multiple times, one for each group, and it's just more performant if we use a prefix in the keys to implement some form of logical separation. This commit also makes the GKeyFile a temporary object. As we always load the file from the file system in _load() and we always replace its contents with a new dictionary in _save(), there is no point in keeping the keyfile's internal data structures stored in memory. Save errors are now also propagated to adhere to the programming practices of GObject
2021-06-04 18:22:48 +03:00
g_assert_true (wp_state_save (state, props, &error));
g_assert_no_error (error);
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
}
/* Load empty */
{
state: remove support for groups and propagate save errors There is no real use for groups in our API. Just use the name of the file as the default group and be done with it... Storing multiple groups with this API is problematic because it forces flushing the file to disk multiple times, one for each group, and it's just more performant if we use a prefix in the keys to implement some form of logical separation. This commit also makes the GKeyFile a temporary object. As we always load the file from the file system in _load() and we always replace its contents with a new dictionary in _save(), there is no point in keeping the keyfile's internal data structures stored in memory. Save errors are now also propagated to adhere to the programming practices of GObject
2021-06-04 18:22:48 +03:00
g_autoptr (WpProperties) props = wp_state_load (state);
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
g_assert_nonnull (props);
g_assert_null (wp_properties_get (props, "key"));
}
wp_state_clear (state);
}
static void
test_state_spaces (void)
{
state: remove support for groups and propagate save errors There is no real use for groups in our API. Just use the name of the file as the default group and be done with it... Storing multiple groups with this API is problematic because it forces flushing the file to disk multiple times, one for each group, and it's just more performant if we use a prefix in the keys to implement some form of logical separation. This commit also makes the GKeyFile a temporary object. As we always load the file from the file system in _load() and we always replace its contents with a new dictionary in _save(), there is no point in keeping the keyfile's internal data structures stored in memory. Save errors are now also propagated to adhere to the programming practices of GObject
2021-06-04 18:22:48 +03:00
g_autoptr (GError) error = NULL;
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
g_autoptr (WpState) state = wp_state_new ("spaces");
g_assert_nonnull (state);
/* Save */
{
g_autoptr (WpProperties) props = wp_properties_new_empty ();
wp_properties_set (props, "key", "value with spaces");
state: remove support for groups and propagate save errors There is no real use for groups in our API. Just use the name of the file as the default group and be done with it... Storing multiple groups with this API is problematic because it forces flushing the file to disk multiple times, one for each group, and it's just more performant if we use a prefix in the keys to implement some form of logical separation. This commit also makes the GKeyFile a temporary object. As we always load the file from the file system in _load() and we always replace its contents with a new dictionary in _save(), there is no point in keeping the keyfile's internal data structures stored in memory. Save errors are now also propagated to adhere to the programming practices of GObject
2021-06-04 18:22:48 +03:00
g_assert_true (wp_state_save (state, props, &error));
g_assert_no_error (error);
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
}
/* Load */
{
state: remove support for groups and propagate save errors There is no real use for groups in our API. Just use the name of the file as the default group and be done with it... Storing multiple groups with this API is problematic because it forces flushing the file to disk multiple times, one for each group, and it's just more performant if we use a prefix in the keys to implement some form of logical separation. This commit also makes the GKeyFile a temporary object. As we always load the file from the file system in _load() and we always replace its contents with a new dictionary in _save(), there is no point in keeping the keyfile's internal data structures stored in memory. Save errors are now also propagated to adhere to the programming practices of GObject
2021-06-04 18:22:48 +03:00
g_autoptr (WpProperties) props = wp_state_load (state);
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
g_assert_nonnull (props);
g_assert_cmpstr (wp_properties_get (props, "key"), ==, "value with spaces");
}
wp_state_clear (state);
}
state: escape invalid key file characters
2021-06-29 10:13:47 -04:00
static void
test_state_escaped (void)
{
g_autoptr (GError) error = NULL;
g_autoptr (WpState) state = wp_state_new ("escaped");
g_assert_nonnull (state);
/* Save */
{
g_autoptr (WpProperties) props = wp_properties_new_empty ();
wp_properties_set (props, "[]", "v0");
wp_properties_set (props, "[ ]", "v1");
wp_properties_set (props, "[=]", "v2");
wp_properties_set (props, " [=]", "v3");
wp_properties_set (props, "[=] ", "v4");
wp_properties_set (props, " [=] ", "v5");
wp_properties_set (props, " [ =] ", "v6");
wp_properties_set (props, " [= ] ", "v7");
wp_properties_set (props, " [ = ] ", "v8");
wp_properties_set (props, " [", "v9");
wp_properties_set (props, "[ ", "v10");
wp_properties_set (props, " [ ", "v11");
wp_properties_set (props, " ]", "v12");
wp_properties_set (props, "] ", "v13");
wp_properties_set (props, " ] ", "v14");
wp_properties_set (props, " ", "v15");
wp_properties_set (props, "=", "v16");
wp_properties_set (props, "\\", "v17");
wp_properties_set (props, "\\[", "v18");
wp_properties_set (props, "\\a", "v19");
wp_properties_set (props, "\\\\", "v20");
wp_properties_set (props, "[][", "][]");
g_assert_true (wp_state_save (state, props, &error));
g_assert_no_error (error);
}
/* Load */
{
g_autoptr (WpProperties) props = wp_state_load (state);
g_assert_nonnull (props);
g_assert_cmpstr (wp_properties_get (props, "[]"), ==, "v0");
g_assert_cmpstr (wp_properties_get (props, "[ ]"), ==, "v1");
g_assert_cmpstr (wp_properties_get (props, "[=]"), ==, "v2");
g_assert_cmpstr (wp_properties_get (props, " [=]"), ==, "v3");
g_assert_cmpstr (wp_properties_get (props, "[=] "), ==, "v4");
g_assert_cmpstr (wp_properties_get (props, " [=] "), ==, "v5");
g_assert_cmpstr (wp_properties_get (props, " [ =] "), ==, "v6");
g_assert_cmpstr (wp_properties_get (props, " [= ] "), ==, "v7");
g_assert_cmpstr (wp_properties_get (props, " [ = ] "), ==, "v8");
g_assert_cmpstr (wp_properties_get (props, " ["), ==, "v9");
g_assert_cmpstr (wp_properties_get (props, "[ "), ==, "v10");
g_assert_cmpstr (wp_properties_get (props, " [ "), ==, "v11");
g_assert_cmpstr (wp_properties_get (props, " ]"), ==, "v12");
g_assert_cmpstr (wp_properties_get (props, "] "), ==, "v13");
g_assert_cmpstr (wp_properties_get (props, " ] "), ==, "v14");
g_assert_cmpstr (wp_properties_get (props, " "), ==, "v15");
g_assert_cmpstr (wp_properties_get (props, "="), ==, "v16");
g_assert_cmpstr (wp_properties_get (props, "\\"), ==, "v17");
g_assert_cmpstr (wp_properties_get (props, "\\["), ==, "v18");
g_assert_cmpstr (wp_properties_get (props, "\\a"), ==, "v19");
g_assert_cmpstr (wp_properties_get (props, "\\\\"), ==, "v20");
g_assert_cmpstr (wp_properties_get (props, "[]["), ==, "][]");
}
tests: state: remove the "escaped" state file at the end of the test
2021-08-19 10:39:49 +03:00
wp_state_clear (state);
state: escape invalid key file characters
2021-06-29 10:13:47 -04:00
}
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
int
main (int argc, char *argv[])
{
g_test_init (&argc, &argv, NULL);
g_log_set_writer_func (wp_log_writer_default, NULL, NULL);
g_test_add_func ("/wp/state/basic", test_state_basic);
g_test_add_func ("/wp/state/empty", test_state_empty);
g_test_add_func ("/wp/state/spaces", test_state_spaces);
state: escape invalid key file characters
2021-06-29 10:13:47 -04:00
g_test_add_func ("/wp/state/escaped", test_state_escaped);
lib: add new WpState API to save and load data from files
2020-10-14 14:36:12 -04:00
return g_test_run ();
}
Reference in a new issue Copy permalink