Revamp the API once again

Another look at the current API showed some inconsistencies, rectified
in this commit:

libevdev_kernel_*: modify the underlying kernel device
libevdev_event_type_*: something with an event type
libevdev_event_code_*: something with an event code
libevdev_event_*: struct input_event-related functions (i.e. not device-related)
libevdev_property_*: something with a property
libevdev_*: anything applying to a device

Hopefully that's the last API change. Current symbols deprecated and aliased.

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
Acked-by: Benjamin Tissoires <benjamin.tissoires@gmail.com>

3 files changed, 95 insertions, 95 deletions

diff --git a/test/test-event-names.c b/test/test-event-names.c
index e7d92bb..57e8e7a 100644
--- a/test/test-event-names.c
+++ b/test/test-event-names.c
@@ -25,48 +25,48 @@
 
 START_TEST(test_limits)
 {
-	ck_assert(libevdev_get_event_type_name(EV_MAX + 1) == NULL);
-	ck_assert(libevdev_get_event_code_name(EV_ABS, ABS_MAX + 1) == NULL);
-	ck_assert(libevdev_get_event_code_name(EV_REL, REL_MAX + 1) == NULL);
-	ck_assert(libevdev_get_event_code_name(EV_KEY, KEY_MAX + 1) == NULL);
-	ck_assert(libevdev_get_event_code_name(EV_LED, LED_MAX + 1) == NULL);
-	ck_assert(libevdev_get_event_code_name(EV_SW, SW_MAX + 1) == NULL);
-	ck_assert(libevdev_get_event_code_name(EV_MSC, MSC_MAX + 1) == NULL);
-	ck_assert(libevdev_get_event_code_name(EV_SND, SND_MAX + 1) == NULL);
-	ck_assert(libevdev_get_event_code_name(EV_REP, REP_MAX + 1) == NULL);
-	ck_assert(libevdev_get_event_code_name(EV_FF, FF_MAX + 1) == NULL);
-	ck_assert(libevdev_get_event_code_name(EV_MAX + 1, 0) == NULL);
+	ck_assert(libevdev_event_type_get_name(EV_MAX + 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_ABS, ABS_MAX + 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_REL, REL_MAX + 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_KEY, KEY_MAX + 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_LED, LED_MAX + 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_SW, SW_MAX + 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_MSC, MSC_MAX + 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_SND, SND_MAX + 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_REP, REP_MAX + 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_FF, FF_MAX + 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_MAX + 1, 0) == NULL);
 }
 END_TEST
 
 START_TEST(test_type_name)
 {
-	ck_assert_str_eq(libevdev_get_event_type_name(EV_SYN), "EV_SYN");
-	ck_assert_str_eq(libevdev_get_event_type_name(EV_REL), "EV_REL");
-	ck_assert_str_eq(libevdev_get_event_type_name(EV_ABS), "EV_ABS");
-	ck_assert_str_eq(libevdev_get_event_type_name(EV_MSC), "EV_MSC");
-	ck_assert_str_eq(libevdev_get_event_type_name(EV_SW),  "EV_SW");
-	ck_assert_str_eq(libevdev_get_event_type_name(EV_LED), "EV_LED");
-	ck_assert_str_eq(libevdev_get_event_type_name(EV_SND), "EV_SND");
-	ck_assert_str_eq(libevdev_get_event_type_name(EV_REP), "EV_REP");
-	ck_assert_str_eq(libevdev_get_event_type_name(EV_FF),  "EV_FF");
-	ck_assert_str_eq(libevdev_get_event_type_name(EV_PWR), "EV_PWR");
-	ck_assert_str_eq(libevdev_get_event_type_name(EV_FF_STATUS), "EV_FF_STATUS");
-	ck_assert_str_eq(libevdev_get_event_type_name(EV_MAX), "EV_MAX");
+	ck_assert_str_eq(libevdev_event_type_get_name(EV_SYN), "EV_SYN");
+	ck_assert_str_eq(libevdev_event_type_get_name(EV_REL), "EV_REL");
+	ck_assert_str_eq(libevdev_event_type_get_name(EV_ABS), "EV_ABS");
+	ck_assert_str_eq(libevdev_event_type_get_name(EV_MSC), "EV_MSC");
+	ck_assert_str_eq(libevdev_event_type_get_name(EV_SW),  "EV_SW");
+	ck_assert_str_eq(libevdev_event_type_get_name(EV_LED), "EV_LED");
+	ck_assert_str_eq(libevdev_event_type_get_name(EV_SND), "EV_SND");
+	ck_assert_str_eq(libevdev_event_type_get_name(EV_REP), "EV_REP");
+	ck_assert_str_eq(libevdev_event_type_get_name(EV_FF),  "EV_FF");
+	ck_assert_str_eq(libevdev_event_type_get_name(EV_PWR), "EV_PWR");
+	ck_assert_str_eq(libevdev_event_type_get_name(EV_FF_STATUS), "EV_FF_STATUS");
+	ck_assert_str_eq(libevdev_event_type_get_name(EV_MAX), "EV_MAX");
 }
 END_TEST
 
 START_TEST(test_code_abs_name)
 {
 	/* pick out a few only */
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_ABS, ABS_X), "ABS_X");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_ABS, ABS_Y), "ABS_Y");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_X), "ABS_X");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_Y), "ABS_Y");
 
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_ABS, ABS_MT_SLOT), "ABS_MT_SLOT");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_ABS, ABS_MISC), "ABS_MISC");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_ABS, ABS_MAX), "ABS_MAX");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_MT_SLOT), "ABS_MT_SLOT");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_MISC), "ABS_MISC");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_MAX), "ABS_MAX");
 
-	ck_assert(libevdev_get_event_code_name(EV_ABS, ABS_MAX - 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_ABS, ABS_MAX - 1) == NULL);
 
 }
 END_TEST
@@ -74,12 +74,12 @@ END_TEST
 START_TEST(test_code_rel_name)
 {
 	/* pick out a few only */
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_REL, REL_X), "REL_X");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_REL, REL_Y), "REL_Y");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_REL, REL_MISC), "REL_MISC");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_REL, REL_MAX), "REL_MAX");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_X), "REL_X");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_Y), "REL_Y");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_MISC), "REL_MISC");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_MAX), "REL_MAX");
 
-	ck_assert(libevdev_get_event_code_name(EV_REL, REL_MAX - 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_REL, REL_MAX - 1) == NULL);
 
 }
 END_TEST
@@ -87,34 +87,34 @@ END_TEST
 START_TEST(test_code_key_name)
 {
 	/* pick out a few only */
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, KEY_RESERVED), "KEY_RESERVED");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, KEY_ESC), "KEY_ESC");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, KEY_1), "KEY_1");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, KEY_2), "KEY_2");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, KEY_UNKNOWN), "KEY_UNKNOWN");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_RESERVED), "KEY_RESERVED");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_ESC), "KEY_ESC");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_1), "KEY_1");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_2), "KEY_2");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_UNKNOWN), "KEY_UNKNOWN");
 
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, BTN_0), "BTN_0");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, BTN_LEFT), "BTN_LEFT");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, BTN_TRIGGER), "BTN_TRIGGER");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, BTN_A), "BTN_A");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, BTN_TOOL_PEN), "BTN_TOOL_PEN");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_0), "BTN_0");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_LEFT), "BTN_LEFT");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TRIGGER), "BTN_TRIGGER");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_A), "BTN_A");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TOOL_PEN), "BTN_TOOL_PEN");
 
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, KEY_TOUCHPAD_TOGGLE), "KEY_TOUCHPAD_TOGGLE");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, BTN_TRIGGER_HAPPY), "BTN_TRIGGER_HAPPY1");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_TOUCHPAD_TOGGLE), "KEY_TOUCHPAD_TOGGLE");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TRIGGER_HAPPY), "BTN_TRIGGER_HAPPY1");
 
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, KEY_MAX), "KEY_MAX");
-	ck_assert(libevdev_get_event_code_name(EV_KEY, KEY_MAX - 1) == NULL);
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_MAX), "KEY_MAX");
+	ck_assert(libevdev_event_code_get_name(EV_KEY, KEY_MAX - 1) == NULL);
 
 	/* special cases that resolve to something else */
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, KEY_HANGUEL), "KEY_HANGEUL");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, KEY_SCREENLOCK), "KEY_COFFEE");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, BTN_MISC), "BTN_0");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, BTN_MOUSE), "BTN_LEFT");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, BTN_JOYSTICK), "BTN_TRIGGER");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, BTN_GAMEPAD), "BTN_A");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, BTN_DIGI), "BTN_TOOL_PEN");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, BTN_WHEEL), "BTN_GEAR_DOWN");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_KEY, BTN_TRIGGER_HAPPY), "BTN_TRIGGER_HAPPY1");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_HANGUEL), "KEY_HANGEUL");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_SCREENLOCK), "KEY_COFFEE");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_MISC), "BTN_0");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_MOUSE), "BTN_LEFT");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_JOYSTICK), "BTN_TRIGGER");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_GAMEPAD), "BTN_A");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_DIGI), "BTN_TOOL_PEN");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_WHEEL), "BTN_GEAR_DOWN");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TRIGGER_HAPPY), "BTN_TRIGGER_HAPPY1");
 
 }
 END_TEST
@@ -122,11 +122,11 @@ END_TEST
 START_TEST(test_code_led_name)
 {
 	/* pick out a few only */
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_LED, LED_NUML), "LED_NUML");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_LED, LED_KANA), "LED_KANA");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_LED, LED_MAX), "LED_MAX");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_LED, LED_NUML), "LED_NUML");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_LED, LED_KANA), "LED_KANA");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_LED, LED_MAX), "LED_MAX");
 
-	ck_assert(libevdev_get_event_code_name(EV_LED, LED_MAX - 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_LED, LED_MAX - 1) == NULL);
 
 }
 END_TEST
@@ -134,11 +134,11 @@ END_TEST
 START_TEST(test_code_snd_name)
 {
 	/* pick out a few only */
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_SND, SND_CLICK), "SND_CLICK");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_SND, SND_TONE), "SND_TONE");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_SND, SND_MAX), "SND_MAX");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_SND, SND_CLICK), "SND_CLICK");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_SND, SND_TONE), "SND_TONE");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_SND, SND_MAX), "SND_MAX");
 
-	ck_assert(libevdev_get_event_code_name(EV_SND, SND_MAX - 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_SND, SND_MAX - 1) == NULL);
 
 }
 END_TEST
@@ -146,14 +146,14 @@ END_TEST
 START_TEST(test_code_msc_name)
 {
 	/* pick out a few only */
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_MSC, MSC_SERIAL), "MSC_SERIAL");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_MSC, MSC_RAW), "MSC_RAW");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_SERIAL), "MSC_SERIAL");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_RAW), "MSC_RAW");
 #ifdef MSC_TIMESTAMP
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_MSC, MSC_TIMESTAMP), "MSC_TIMESTAMP");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_TIMESTAMP), "MSC_TIMESTAMP");
 #endif
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_MSC, MSC_MAX), "MSC_MAX");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_MAX), "MSC_MAX");
 
-	ck_assert(libevdev_get_event_code_name(EV_MSC, MSC_MAX - 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_MSC, MSC_MAX - 1) == NULL);
 
 }
 END_TEST
@@ -161,12 +161,12 @@ END_TEST
 START_TEST(test_code_sw_name)
 {
 	/* pick out a few only */
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_SW, SW_LID), "SW_LID");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_SW, SW_RFKILL_ALL), "SW_RFKILL_ALL");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_SW, SW_LINEIN_INSERT), "SW_LINEIN_INSERT");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_SW, SW_MAX), "SW_MAX");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_LID), "SW_LID");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_RFKILL_ALL), "SW_RFKILL_ALL");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_LINEIN_INSERT), "SW_LINEIN_INSERT");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_MAX), "SW_MAX");
 
-	ck_assert(libevdev_get_event_code_name(EV_SW, SW_MAX - 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_SW, SW_MAX - 1) == NULL);
 
 }
 END_TEST
@@ -174,22 +174,22 @@ END_TEST
 START_TEST(test_code_ff_name)
 {
 	/* pick out a few only */
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_FF, FF_STATUS_STOPPED), "FF_STATUS_STOPPED");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_FF, FF_FRICTION), "FF_FRICTION");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_FF, FF_CUSTOM), "FF_CUSTOM");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_FF, FF_MAX), "FF_MAX");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_STATUS_STOPPED), "FF_STATUS_STOPPED");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_FRICTION), "FF_FRICTION");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_CUSTOM), "FF_CUSTOM");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_MAX), "FF_MAX");
 
-	ck_assert(libevdev_get_event_code_name(EV_FF, FF_MAX - 1) == NULL);
+	ck_assert(libevdev_event_code_get_name(EV_FF, FF_MAX - 1) == NULL);
 
 }
 END_TEST
 
 START_TEST(test_code_syn_name)
 {
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_SYN, SYN_REPORT), "SYN_REPORT");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_SYN, SYN_CONFIG), "SYN_CONFIG");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_SYN, SYN_MT_REPORT), "SYN_MT_REPORT");
-	ck_assert_str_eq(libevdev_get_event_code_name(EV_SYN, SYN_DROPPED), "SYN_DROPPED");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_REPORT), "SYN_REPORT");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_CONFIG), "SYN_CONFIG");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_MT_REPORT), "SYN_MT_REPORT");
+	ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_DROPPED), "SYN_DROPPED");
 
 	/* there is no SYN_MAX */
 }
@@ -210,12 +210,12 @@ END_TEST
 
 START_TEST(test_event_type_max)
 {
-	ck_assert_int_eq(libevdev_get_event_type_max(EV_ABS), ABS_MAX);
-	ck_assert_int_eq(libevdev_get_event_type_max(EV_REL), REL_MAX);
-	ck_assert_int_eq(libevdev_get_event_type_max(EV_KEY), KEY_MAX);
+	ck_assert_int_eq(libevdev_event_type_get_max(EV_ABS), ABS_MAX);
+	ck_assert_int_eq(libevdev_event_type_get_max(EV_REL), REL_MAX);
+	ck_assert_int_eq(libevdev_event_type_get_max(EV_KEY), KEY_MAX);
 
-	ck_assert_int_eq(libevdev_get_event_type_max(EV_MAX - 1), -1);
-	ck_assert_int_eq(libevdev_get_event_type_max(EV_MAX + 1), -1);
+	ck_assert_int_eq(libevdev_event_type_get_max(EV_MAX - 1), -1);
+	ck_assert_int_eq(libevdev_event_type_get_max(EV_MAX + 1), -1);
 
 }
 END_TEST
@@ -251,7 +251,7 @@ START_TEST(test_event_code)
 		if (i == ev.type || i == EV_SYN)
 			continue;
 
-		for (j = 0; j < libevdev_get_event_type_max(i); i++) {
+		for (j = 0; j < libevdev_event_type_get_max(i); i++) {
 			ck_assert_int_eq(libevdev_is_event_code(&ev, i, j), 0);
 		}
 	}
diff --git a/test/test-libevdev-has-event.c b/test/test-libevdev-has-event.c
index ed10140..242f991 100644
--- a/test/test-libevdev-has-event.c
+++ b/test/test-libevdev-has-event.c
@@ -56,7 +56,7 @@ START_TEST(test_has_ev_bit)
 					*evbit, 0,
 					-1);
 		ck_assert_msg(rc == 0, "%s: Failed to create device with: %s",
-				libevdev_get_event_type_name(*evbit),
+				libevdev_event_type_get_name(*evbit),
 				strerror(-rc));
 
 		ck_assert_msg(libevdev_has_event_type(dev, EV_SYN), "for event type %d\n", *evbit);
@@ -123,7 +123,7 @@ START_TEST(test_event_codes)
 			continue;
 		}
 
-		max = libevdev_get_event_type_max(*evbit);
+		max = libevdev_event_type_get_max(*evbit);
 
 		for (code = 1; code < max; code += 10) {
 			if (*evbit == EV_ABS) {
@@ -167,7 +167,7 @@ START_TEST(test_event_code_limits)
 			continue;
 		}
 
-		max = libevdev_get_event_type_max(*evbit);
+		max = libevdev_event_type_get_max(*evbit);
 		ck_assert(max != -1);
 
 		if (*evbit == EV_ABS) {
diff --git a/test/test-uinput.c b/test/test-uinput.c
index e7546d1..2e9d3cd 100644
--- a/test/test-uinput.c
+++ b/test/test-uinput.c
@@ -65,7 +65,7 @@ START_TEST(test_uinput_create_device)
 	ck_assert_int_eq(rc, 0);
 
 	for (type = 0; type < EV_CNT; type++) {
-		int max = libevdev_get_event_type_max(type);
+		int max = libevdev_event_type_get_max(type);
 		if (max == -1)
 			continue;
 
@@ -144,7 +144,7 @@ START_TEST(test_uinput_create_device_from_fd)
 	ck_assert_int_eq(rc, 0);
 
 	for (type = 0; type < EV_CNT; type++) {
-		int max = libevdev_get_event_type_max(type);
+		int max = libevdev_event_type_get_max(type);
 		if (max == -1)
 			continue;