diff --git a/tools/ratbagctl.in b/tools/ratbagctl.in
index 37d035c4..1ec50d62 100755
--- a/tools/ratbagctl.in
+++ b/tools/ratbagctl.in
@@ -603,15 +603,8 @@ def dpi(string):
         return (int_x, int_y)
 
 
-# note: 'hidrawX' is assumed at the end of each command
+# note: 'hidrawX' is assumed before each command
 parser_def = [
-    {
-        of_type: command,
-        name: 'list',
-        help_str: 'List supported devices (does not take a device argument)',
-        func: list_devices,
-        group: 'General',
-    },
     {
         of_type: command,
         name: 'info',
@@ -1159,8 +1152,6 @@ class RatbagParser(object):
     def store_function(self, parser):
         if self.func is not None:
             parser.set_defaults(func=self.func)
-            if 'list' not in self.name:
-                parser.add_argument("device", metavar='hidrawX')
 
     def _add_to_subparsers(self, parent, input_string, ns):
         raise ParseError("please implement _add_to_subparsers on {}".format(type(self)))
@@ -1217,7 +1208,7 @@ class RatbagParserSwitch(RatbagParser):
                 # N_access subtree of the command
                 return self.N_access._sub_parse(self, input_string, ns)
 
-        parser = argparse.ArgumentParser(prog="{} {}".format(sys.argv[0], self.name),
+        parser = argparse.ArgumentParser(prog="{} <device> {}".format(sys.argv[0], self.name),
                                          description=self.help,
                                          add_help=False)
 
@@ -1248,7 +1239,7 @@ class RatbagParserNAccess(RatbagParserSwitch):
         self.metavar = metavar
 
     def _sub_parse(self, parent, input_string, ns):
-        parser = argparse.ArgumentParser(prog="{} {}".format(sys.argv[0], parent.name),
+        parser = argparse.ArgumentParser(prog="{} <device> {}".format(sys.argv[0], parent.name),
                                          add_help=False)
         parser.add_argument(self.name, help=self.help, type=int)
         # create a new subparser to handle all commands
@@ -1277,17 +1268,14 @@ class RatbagParserSet(RatbagParserSwitch):
         parser.set_defaults(subparse=self.sub_parse)
 
     def _sub_parse(self, input_string, ns):
-        parser = argparse.ArgumentParser(prog="{} {}".format(sys.argv[0], self.name),
+        parser = argparse.ArgumentParser(prog="{} <device> {}".format(sys.argv[0], self.name),
                                          add_help=False)
         # create a new subparser to handle all commands
         subs = parser.add_subparsers(title="COMMANDS", help=None)
         for e in self.switch:
             e.add_to_subparsers(subs)
-        if len(input_string) == 3:
+        if len(input_string) == 2:
             self.store_function(parser)
-        elif len(input_string) == 2:
-            # missing device argument
-            parser.add_argument("device", metavar='hidrawX')
         else:
             parser.set_defaults(subparse=self.sub_parse)
         return parser
@@ -1397,9 +1385,26 @@ class RatbagParserRoot(object):
         if ns.help:
             return ns
 
-        subs = self.parser.add_subparsers(title="COMMANDS")
+        # retrieve the device and remove it from the command processing
+        self.parser.add_argument('device_or_list', action="store")
+        ns, rest = self.parser.parse_known_args(rest)
 
-        subparser = self.parser
+        if ns.device_or_list == 'list':
+            if rest:
+                self.parser.error("extra arguments: '{}'".format(" ".join(rest)))
+            ns.func = list_devices
+            return ns
+
+        ns.device = ns.device_or_list
+
+        # we need a new parser or 'device_or_list' will eat all of our commands
+        command_parser = argparse.ArgumentParser(description="command parser",
+                                                 prog="{} <device>".format(sys.argv[0]),
+                                                 add_help=False)
+
+        subs = command_parser.add_subparsers(title="COMMANDS")
+
+        subparser = command_parser
 
         for child in self.children:
             child.add_to_subparsers(subs)
@@ -1409,6 +1414,8 @@ class RatbagParserRoot(object):
         while rest and subparser:
             old_rest = rest
             ns, rest = subparser.parse_known_args(rest, namespace=ns)
+            if hasattr(ns, func):
+                break
             if old_rest == rest:
                 break
             if ns.subparse:
@@ -1420,7 +1427,8 @@ class RatbagParserRoot(object):
         return ns
 
     def print_help(self):
-        print("usage: {} [OPTIONS] {{COMMAND}} ... /dev/hidrawX\n".format(self.parser.prog))
+        print("usage: {} [OPTIONS] list".format(self.parser.prog))
+        print("       {} [OPTIONS] <device> {{COMMAND}} ...\n".format(self.parser.prog))
         print(self.parser.description)
         print("""
 Common options:
@@ -1430,6 +1438,9 @@ Common options:
     --help, -h                  show this help and exit""")
         if self.want_keepalive:
             print("    --keepalive                 do not terminate ratbagd after the processing")
+        print("""
+General Commands:
+  list                                List supported devices (does not take a device argument)""")
         for c in self.children:
             c.print_help(None)
         print("""
diff --git a/tools/ratbagctl.test.in b/tools/ratbagctl.test.in
index b05e6e8f..1881ba1b 100755
--- a/tools/ratbagctl.test.in
+++ b/tools/ratbagctl.test.in
@@ -70,6 +70,10 @@ class TestRatbagCtl(unittest.TestCase):
             cmd.func(ratbagd, cmd)
         except SystemExit as e:
             returncode = e.code
+        except AttributeError as e:
+            returncode = 2
+        except argparse.ArgumentTypeError as e:
+            returncode = 2
         output = sys.stdout.getvalue()
         error = sys.stderr.getvalue()
         sys.stdout = stdout
@@ -105,28 +109,29 @@ class TestRatbagCtl(unittest.TestCase):
 
     @classmethod
     def setProfile(cls, profile):
-        cls.run_ratbagctl("Profile active set {} test_device".format(profile))
+        cls.run_ratbagctl("test_device Profile active set {}".format(profile))
 
 
 class TestRatbagCtlList(TestRatbagCtl):
     def test_list(self):
         r = self.launch_good_test("list")
         self.assertIn('test_device', r)
+        self.launch_fail_test("test_device list")
         self.launch_fail_test("list test_device")
 
 
 class TestRatbagCtlInfo(TestRatbagCtl):
     def test_info(self):
-        self.launch_good_test("info test_device")
-        self.launch_fail_test("info test_device X")
+        self.launch_good_test("test_device info")
+        self.launch_fail_test("test_device info X")
         self.launch_fail_test("info X")
 
 
 class TestRatbagCtlName(TestRatbagCtl):
     def test_get(self):
-        r = self.launch_good_test("name test_device")
+        r = self.launch_good_test("test_device name")
         self.assertEqual(r, 'Test device')
-        self.launch_fail_test("name test_device X")
+        self.launch_fail_test("test_device name X")
         self.launch_fail_test("name X")
 
 
@@ -140,76 +145,76 @@ class TestRatbagCtlProfile(TestRatbagCtl):
 
     def test_profile_name_get(self):
         command = "profile 1 name get"
-        r = self.launch_good_test(command + " test_device")
+        r = self.launch_good_test("test_device " + command)
         self.assertEqual(r, 'test profile 2')
         self.launch_fail_test(command)
-        self.launch_fail_test(command + " X test_device")
-        self.launch_fail_test("profile name get test_device")
+        self.launch_fail_test("test_device " + command + " X")
+        self.launch_fail_test("test_device profile name get")
 
     def test_profile_name_set(self):
-        r = self.launch_good_test("profile 1 name get test_device")
+        r = self.launch_good_test("test_device profile 1 name get")
         self.assertEqual(r, 'test profile 2')
-        self.launch_good_test("profile 1 name set banana test_device")
-        r = self.launch_good_test("profile 1 name get test_device")
+        self.launch_good_test("test_device profile 1 name set banana")
+        r = self.launch_good_test("test_device profile 1 name get")
         self.assertEqual(r, 'banana')
         # profile 0 doesn't have the capability RATBAG_PROFILE_CAP_WRITABLE_NAME
-        self.launch_fail_with_exception_test("profile 0 name set kiwi test_device", toolbox.RatbagErrorCapability)
+        self.launch_fail_with_exception_test("test_device profile 0 name set kiwi", toolbox.RatbagErrorCapability)
         # better be safe than sorry, checking that the previous actually failed :)
-        r = self.launch_good_test("profile 0 name get test_device")
+        r = self.launch_good_test("test_device profile 0 name get")
         self.assertNotEqual(r, 'kiwi')
         self.launch_fail_test("profile 1 name set blah")
-        self.launch_fail_test("profile 1 name set blah X test_device")
-        self.launch_fail_test("profile name set blah test_device")
+        self.launch_fail_test("test_device profile 1 name set blah X")
+        self.launch_fail_test("test_device profile name set blah")
 
     def test_profile_active_get(self):
         command = "profile active get"
-        r = self.launch_good_test(command + " test_device")
+        r = self.launch_good_test("test_device " + command)
         self.assertEqual(int(r), 0)
         self.launch_fail_test(command)
-        self.launch_fail_test(command + " X test_device")
+        self.launch_fail_test("test_device " + command + " X")
 
     def test_profile_active_set(self):
         command = "profile active set"
-        r = self.launch_good_test(command + " 1 test_device")
+        r = self.launch_good_test("test_device " + command + " 1")
         self.assertEqual(r, '')
-        r = self.launch_good_test("profile active get test_device")
+        r = self.launch_good_test("test_device profile active get")
         self.assertEqual(int(r), 1)
         self.launch_fail_test(command)
-        self.launch_fail_test(command + " X test_device")
-        self.launch_fail_test(command + " 1 test_device X")
+        self.launch_fail_test("test_device " + command + " X")
+        self.launch_fail_test("test_device " + command + " 1 X")
 
     def test_profile_n(self):
-        r0 = self.launch_good_test("Profile 0 get test_device")
-        r1 = self.launch_good_test("Profile 1 get test_device")
+        r0 = self.launch_good_test("test_device Profile 0 get")
+        r1 = self.launch_good_test("test_device Profile 1 get")
         self.assertNotEqual(r0, r1)
         self.launch_fail_test("Profile 0 get")
-        self.launch_fail_test("Profile 0 test_device")
-        self.launch_fail_test("Profile 0 get test_device X")
-        self.launch_fail_test("Profile 10 get test_device")
+        self.launch_fail_test("test_device Profile 0")
+        self.launch_fail_test("test_device Profile 0 get X")
+        self.launch_fail_test("test_device Profile 10 get")
 
     def test_profile_enable(self):
-        r = self.launch_good_test("profile 0 get test_device")
+        r = self.launch_good_test("test_device profile 0 get")
         self.assertNotIn('disabled', r)
-        r = self.launch_good_test("profile 3 get test_device")
+        r = self.launch_good_test("test_device profile 3 get")
         self.assertIn('disabled', r)
-        self.launch_good_test("profile 3 enable test_device")
-        r = self.launch_good_test("profile 3 get test_device")
+        self.launch_good_test("test_device profile 3 enable")
+        r = self.launch_good_test("test_device profile 3 get")
         self.assertNotIn('Profile 3: (disabled)', r)
         self.launch_fail_test("profile enable")
-        self.launch_fail_test("profile X enable test_device")
-        self.launch_fail_test("profile 1 enable test_device X")
-        self.launch_fail_test("profile 10 enable test_device")
+        self.launch_fail_test("test_device profile X enable")
+        self.launch_fail_test("test_device profile 1 enable X")
+        self.launch_fail_test("test_device profile 10 enable")
 
     def test_profile_disable(self):
-        r = self.launch_good_test("profile 2 get test_device")
+        r = self.launch_good_test("test_device profile 2 get")
         self.assertNotIn('disabled', r)
-        self.launch_good_test("profile 2 disable test_device")
-        r = self.launch_good_test("profile 2 get test_device")
+        self.launch_good_test("test_device profile 2 disable")
+        r = self.launch_good_test("test_device profile 2 get")
         self.assertEqual('Profile 2: (disabled)', r)
         self.launch_fail_test("profile disable")
-        self.launch_fail_test("profile X disable test_device")
-        self.launch_fail_test("profile 1 disable test_device X")
-        self.launch_fail_test("profile 10 disable test_device")
+        self.launch_fail_test("test_device profile X disable")
+        self.launch_fail_test("test_device profile 1 disable X")
+        self.launch_fail_test("test_device profile 10 disable")
 
 
 class TestRatbagCtlResolution(TestRatbagCtl):
@@ -220,53 +225,51 @@ class TestRatbagCtlResolution(TestRatbagCtl):
 
     def test_resolution_active_get(self):
         command = "Resolution active get"
-        r = self.launch_good_test(command + " test_device")
+        r = self.launch_good_test("test_device " + command)
         self.assertEqual(int(r), 2)
-        self.launch_fail_test(command + " X test_device")
-        self.launch_fail_test(command + " 10 test_device")
-        self.launch_fail_test(command + " test_device x")
+        self.launch_fail_test("test_device " + command + " X")
+        self.launch_fail_test("test_device " + command + " 10")
 
     def test_resolution_active_set(self):
         command = "Resolution active set"
-        r = self.launch_good_test("Resolution active get test_device")
+        r = self.launch_good_test("test_device Resolution active get")
         self.assertEqual(int(r), 2)
-        r = self.launch_good_test(command + " 0 test_device")
+        r = self.launch_good_test("test_device " + command + " 0")
         self.assertEqual(r, '')
-        r = self.launch_good_test("Resolution active get test_device")
+        r = self.launch_good_test("test_device Resolution active get")
         self.assertEqual(int(r), 0)
         self.launch_fail_test(command)
-        self.launch_fail_test(command + " X test_device")
-        self.launch_fail_test(command + " 1 test_device X")
+        self.launch_fail_test("test_device " + command + " X")
+        self.launch_fail_test("test_device " + command + " 1 X")
 
     def test_resolution_n_get(self):
-        r = self.launch_good_test("Resolution 1 get test_device")
+        r = self.launch_good_test("test_device Resolution 1 get")
         self.assertEqual(r, "1: 1200x1300dpi @ 2000Hz (default)")
-        self.launch_fail_test("Resolution 10 get test_device")
-        self.launch_fail_test("Resolution 1 get test_device X")
+        self.launch_fail_test("test_device Resolution 10 get")
+        self.launch_fail_test("test_device Resolution 1 get X")
         self.launch_fail_test("Resolution 1 get X")
 
     def test_profile_resolution(self):
-        r = self.launch_good_test("Profile 2 Resolution 2 get test_device")
+        r = self.launch_good_test("test_device Profile 2 Resolution 2 get")
         self.assertEqual(r, "2: 2300x2400dpi @ 3000Hz")
 
     def test_resolution_default_get(self):
         command = "Resolution default get"
-        r = self.launch_good_test(command + " test_device")
+        r = self.launch_good_test("test_device " + command)
         self.assertEqual(int(r), 1)
-        self.launch_fail_test(command + " X test_device")
-        self.launch_fail_test(command + " 10 test_device")
-        self.launch_fail_test(command + " test_device x")
+        self.launch_fail_test("test_device " + command + " X")
+        self.launch_fail_test("test_device " + command + " 10")
 
     def test_resolution_default_set(self):
         command = "Resolution default set"
-        self.launch_good_test(command + " 2 test_device")
-        r = self.launch_good_test("Resolution default get test_device")
+        self.launch_good_test("test_device " + command + " 2")
+        r = self.launch_good_test("test_device Resolution default get")
         self.assertEqual(int(r), 2)
         self.launch_fail_test(command)
-        self.launch_fail_test(command + " X test_device")
-        self.launch_fail_test(command + " 1 test_device X")
+        self.launch_fail_test("test_device " + command + " X")
+        self.launch_fail_test("test_device " + command + " 1 X")
         # Reset for other tests
-        self.launch_good_test(command + " 1 test_device")
+        self.launch_good_test("test_device " + command + " 1")
 
 
 class TestRatbagCtlDPI(TestRatbagCtl):
@@ -277,66 +280,66 @@ class TestRatbagCtlDPI(TestRatbagCtl):
 
     def test_dpi_get(self):
         command = "DPI get"
-        r = self.launch_good_test(command + " test_device")
+        r = self.launch_good_test("test_device " + command)
         self.assertEqual(int(r[:-3]), 200)  # drop 'dpi' suffix
         self.setProfile(1)
-        r = self.launch_good_test(command + " test_device")
+        r = self.launch_good_test("test_device " + command)
         self.assertEqual(r, "1300x1400dpi")
         self.launch_fail_test(command)
-        self.launch_fail_test(command + " 1 test_device")
-        self.launch_fail_test(command + " test_device X")
+        self.launch_fail_test("test_device " + command + " 1")
+        self.launch_fail_test("test_device " + command + " X")
 
     def test_dpi_get_all(self):
         dpi_list = "50 100 150 200 250 300 350 400 450 500 550 600 650 700 750 800 850 900 950 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900 2000 2100 2200 2300 2400 2500 2600 2800 3000 3200 3400 3600 3800 4000 4200 4400 4600 4800 5000"
         command = "DPI get-all"
-        r = self.launch_good_test(command + " test_device")
+        r = self.launch_good_test("test_device " + command)
         self.assertEqual(r, dpi_list)
         self.setProfile(1)
-        r = self.launch_good_test(command + " test_device")
+        r = self.launch_good_test("test_device " + command)
         self.assertEqual(r, dpi_list)
 
     def test_dpi_set(self):
         command = "DPI set"
         self.setProfile(0)
-        r = self.launch_good_test("DPI get test_device")
+        r = self.launch_good_test("test_device DPI get ")
         res = int(r[:-3]) + 50  # drop 'dpi' suffix
-        r = self.launch_good_test(command + " {} test_device".format(res))
+        r = self.launch_good_test("test_device " + command + " {}".format(res))
         self.assertEqual(r, '')
-        r = self.launch_good_test("DPI get test_device")
+        r = self.launch_good_test("test_device DPI get")
         self.assertEqual(int(r[:-3]), res)  # drop 'dpi' suffix
         self.launch_fail_test(command)
-        self.launch_fail_test(command + " X test_device")
-        self.launch_fail_test(command + " 100 test_device X")
+        self.launch_fail_test("test_device " + command + " X")
+        self.launch_fail_test("test_device " + command + " 100 X")
 
     def test_dpi_set_xy(self):
         command = "DPI set"
         self.setProfile(2)
-        r = self.launch_good_test("DPI get test_device")
+        r = self.launch_good_test("test_device DPI get")
         self.assertEqual(r, "2100x2200dpi")
-        self.launch_good_test(command + " 1350x1450 test_device")
-        r = self.launch_good_test("DPI get test_device")
+        self.launch_good_test("test_device " + command + " 1350x1450")
+        r = self.launch_good_test("test_device DPI get")
         self.assertEqual(r, "1350x1450dpi")
-        self.launch_good_test(command + " 2350x2450dpi test_device")
-        r = self.launch_good_test("DPI get test_device")
+        self.launch_good_test("test_device " + command + " 2350x2450dpi")
+        r = self.launch_good_test("test_device DPI get")
         self.assertEqual(r, "2350x2450dpi")
-        self.launch_good_test(command + " 2350 test_device")
-        r = self.launch_good_test("DPI get test_device")
+        self.launch_good_test("test_device " + command + " 2350")
+        r = self.launch_good_test("test_device DPI get")
         self.assertEqual(r, "2350x2350dpi")
-        self.launch_fail_test(command + " 2350dpi test_device")
+        self.launch_fail_test("test_device " + command + " 2350dpi")
         self.launch_fail_test(command)
-        self.launch_fail_test(command + " X test_device")
-        self.launch_fail_test(command + " 100 test_device X")
+        self.launch_fail_test("test_device " + command + " X")
+        self.launch_fail_test("test_device " + command + " 100 X")
 
     def test_prefix_dpi(self):
         self.setProfile(0)
-        r = self.launch_good_test("Profile 1 DPI get test_device")
+        r = self.launch_good_test("test_device Profile 1 DPI get")
         self.assertEqual(r, "1300x1400dpi")
-        r = self.launch_good_test("Profile 1 Resolution 1 DPI get test_device")
+        r = self.launch_good_test("test_device Profile 1 Resolution 1 DPI get")
         self.assertEqual(r, "1200x1300dpi")
-        r = self.launch_good_test("Resolution 2 DPI get test_device")
+        r = self.launch_good_test("test_device Resolution 2 DPI get")
         self.assertEqual(int(r[:-3]), 300)  # drop 'dpi' suffix
-        self.launch_fail_test("Profile 1 Profile 1 DPI get test_device")
-        self.launch_fail_test("Profile 1 Resolution 1 Resolution 2 DPI get test_device")
+        self.launch_fail_test("test_device Profile 1 Profile 1 DPI get")
+        self.launch_fail_test("test_device Profile 1 Resolution 1 Resolution 2 DPI get")
 
 
 class TestRatbagCtlReportRate(TestRatbagCtl):
@@ -347,42 +350,42 @@ class TestRatbagCtlReportRate(TestRatbagCtl):
 
     def test_rate_get(self):
         command = "rate get"
-        r = self.launch_good_test(command + " test_device")
+        r = self.launch_good_test("test_device " + command)
         self.assertEqual(int(r), 1000)
         self.launch_fail_test(command)
-        self.launch_fail_test(command + " 1 test_device")
-        self.launch_fail_test(command + " test_device X")
+        self.launch_fail_test("test_device " + command + " 1")
+        self.launch_fail_test("test_device " + command + " X")
 
     def test_rate_get_all(self):
         rate_list = "500 1000"
         command = "rate get-all"
-        r = self.launch_good_test(command + " test_device")
+        r = self.launch_good_test("test_device " + command)
         self.assertEqual(r, rate_list)
         self.setProfile(1)
-        r = self.launch_good_test(command + " test_device")
+        r = self.launch_good_test("test_device " + command)
         self.assertEqual(r, rate_list)
 
     def test_rate_set(self):
         command = "rate set"
-        r = self.launch_good_test("rate get test_device")
+        r = self.launch_good_test("test_device rate get")
         res = int(r) + 500
-        r = self.launch_good_test(command + " {} test_device".format(res))
+        r = self.launch_good_test("test_device " + command + " {}".format(res))
         self.assertEqual(r, '')
-        r = self.launch_good_test("rate get test_device")
+        r = self.launch_good_test("test_device rate get")
         self.assertEqual(int(r), res)
         self.launch_fail_test(command)
-        self.launch_fail_test(command + " X test_device")
-        self.launch_fail_test(command + " 100 test_device X")
+        self.launch_fail_test("test_device " + command + " X")
+        self.launch_fail_test("test_device " + command + " 100 X")
 
     def test_prefix_rate(self):
-        r = self.launch_good_test("Profile 1 rate get test_device")
+        r = self.launch_good_test("test_device Profile 1 rate get")
         self.assertEqual(int(r), 2000)
-        r = self.launch_good_test("Profile 1 Resolution 1 rate get test_device")
+        r = self.launch_good_test("test_device Profile 1 Resolution 1 rate get")
         self.assertEqual(int(r), 2000)
-        r = self.launch_good_test("Resolution 2 rate get test_device")
+        r = self.launch_good_test("test_device Resolution 2 rate get")
         self.assertEqual(int(r), 1000)
-        self.launch_fail_test("Profile 1 Profile 1 rate get test_device")
-        self.launch_fail_test("Profile 1 Resolution 1 Resolution 2 rate get test_device")
+        self.launch_fail_test("test_device Profile 1 Profile 1 rate get")
+        self.launch_fail_test("test_device Profile 1 Resolution 1 Resolution 2 rate get")
 
 
 class TestRatbagCtlButton(TestRatbagCtl):
@@ -393,82 +396,82 @@ class TestRatbagCtlButton(TestRatbagCtl):
 
     def test_button_count(self):
         command = "button count"
-        r = self.launch_good_test(command + " test_device")
+        r = self.launch_good_test("test_device " + command)
         self.assertEqual(int(r), 4)
         self.launch_fail_test(command)
-        self.launch_fail_test(command + " 1 test_device")
-        self.launch_fail_test(command + " test_device X")
+        self.launch_fail_test("test_device " + command + " 1")
+        self.launch_fail_test("test_device " + command + " X")
 
     def test_button_n_get(self):
         self.setProfile(0)
-        r = self.launch_good_test("button 0 get test_device")
+        r = self.launch_good_test("test_device button 0 get")
         self.assertEqual(r, "Button: 0 is mapped to 'button 0'")
-        r = self.launch_good_test("button 1 get test_device")
+        r = self.launch_good_test("test_device button 1 get")
         self.assertEqual(r, "Button: 1 is mapped to UNKNOWN")
-        r = self.launch_good_test("button 2 get test_device")
+        r = self.launch_good_test("test_device button 2 get")
         self.assertEqual(r, "Button: 2 is mapped to 'profile-cycle-up'")
-        r = self.launch_good_test("button 3 get test_device")
+        r = self.launch_good_test("test_device button 3 get")
         self.assertEqual(r, "Button: 3 is mapped to macro '↕B 300ms'")
-        self.launch_fail_test("button 1 get 10 test_device")
-        self.launch_fail_test("button 10 get test_device")
-        self.launch_fail_test("button 1 get test_device X")
+        self.launch_fail_test("test_device button 1 get 10")
+        self.launch_fail_test("test_device button 10 get")
+        self.launch_fail_test("test_device button 1 get X")
 
     def test_button_n_action_get(self):
         self.setProfile(0)
-        r = self.launch_good_test("button 0 action get test_device")
+        r = self.launch_good_test("test_device button 0 action get")
         self.assertEqual(r, "Button: 0 is mapped to 'button 0'")
-        self.launch_fail_test("button 1 action get 10 test_device")
-        self.launch_fail_test("button 10 action get test_device")
-        self.launch_fail_test("button 1 action get test_device X")
+        self.launch_fail_test("test_device button 1 action get 10")
+        self.launch_fail_test("test_device button 10 action get")
+        self.launch_fail_test("test_device button 1 action get X")
 
     def test_button_n_action_set_button(self):
         self.setProfile(2)
         command = "button 2 action set button"
-        r = self.launch_good_test("button 2 action get test_device")
+        r = self.launch_good_test("test_device button 2 action get")
         self.assertEqual(r, "Button: 2 is mapped to 'button 2'")
-        r = self.launch_good_test(command + " 1 test_device")
+        r = self.launch_good_test("test_device " + command + " 1")
         self.assertEqual(r, '')
-        r = self.launch_good_test("button 2 action get test_device")
+        r = self.launch_good_test("test_device button 2 action get")
         self.assertEqual(r, "Button: 2 is mapped to 'button 1'")
         self.launch_fail_test(command)
-        self.launch_fail_test(command + " X test_device")
-        self.launch_fail_test(command + " 100 test_device X")
+        self.launch_fail_test("test_device " + command + " X")
+        self.launch_fail_test("test_device " + command + " 100 X")
 
     def test_button_n_action_set_special(self):
         self.setProfile(2)
         command = "button 0 action set special "
-        r = self.launch_good_test("button 0 action get test_device")
+        r = self.launch_good_test("test_device button 0 action get")
         self.assertEqual(r, "Button: 0 is mapped to 'profile-cycle-up'")
-        r = self.launch_good_test(command + " second-mode test_device")
+        r = self.launch_good_test("test_device " + command + " second-mode")
         self.assertEqual(r, '')
-        r = self.launch_good_test("button 0 action get test_device")
+        r = self.launch_good_test("test_device button 0 action get")
         self.assertEqual(r, "Button: 0 is mapped to 'second-mode'")
         self.launch_fail_test(command)
-        self.launch_fail_test(command + " X test_device")
-        self.launch_fail_test(command + " 100 test_device X")
+        self.launch_fail_test("test_device " + command + " X")
+        self.launch_fail_test("test_device " + command + " 100 X")
 
     def test_button_n_action_set_macro(self):
         command = "button 2 action set macro "
-        self.launch_good_test(command + '+KEY_B KEY_A -KEY_B KEY_C test_device')
-        r = self.launch_good_test("button 2 get test_device")
+        self.launch_good_test("test_device " + command + '+KEY_B KEY_A -KEY_B KEY_C')
+        r = self.launch_good_test("test_device button 2 get")
         self.assertEqual(r, "Button: 2 is mapped to macro '↓B ↕A ↑B ↕C'")
-        self.launch_good_test(command + 't100 t200 test_device')
-        r = self.launch_good_test("button 2 get test_device")
+        self.launch_good_test("test_device " + command + 't100 t200')
+        r = self.launch_good_test("test_device button 2 get")
         self.assertEqual(r, "Button: 2 is mapped to macro '100ms 200ms'")
-        self.launch_good_test(command + 'KeY_z test_device')
-        r = self.launch_good_test("button 2 get test_device")
+        self.launch_good_test("test_device " + command + 'KeY_z')
+        r = self.launch_good_test("test_device button 2 get")
         self.assertEqual(r, "Button: 2 is mapped to macro '↕Z'")
-        self.launch_good_test(command + ' test_device')
-        r = self.launch_good_test("button 2 get test_device")
+        self.launch_good_test("test_device " + command)
+        r = self.launch_good_test("test_device button 2 get")
         self.assertEqual(r, "Button: 2 is mapped to macro 'None'")
         self.launch_fail_test(command)
-        self.launch_fail_test(command + " KEY_A test_device X")
+        self.launch_fail_test("test_device " + command + " KEY_A X")
 
     def test_prefix_button(self):
-        r = self.launch_good_test("Profile 2 Button 3 get test_device")
+        r = self.launch_good_test("test_device Profile 2 Button 3 get")
         self.assertEqual(r, "Button: 3 is mapped to 'button 3'")
-        self.launch_fail_test("Profile 2 Profile 2 Button 3 get test_device")
-        self.launch_fail_test("Profile 2 Resolution 2 Button 3 get test_device")
+        self.launch_fail_test("test_device Profile 2 Profile 2 Button 3 get")
+        self.launch_fail_test("test_device Profile 2 Resolution 2 Button 3 get")
 
 
 class TestRatbagCtlLED(TestRatbagCtl):
@@ -479,107 +482,103 @@ class TestRatbagCtlLED(TestRatbagCtl):
 
     def test_led_n_get(self):
         self.setProfile(0)
-        r = self.launch_good_test("led 0 get test_device")
+        r = self.launch_good_test("test_device led 0 get")
         self.assertEqual(r, "LED: 0, depth: rgb, mode: off")
-        r = self.launch_good_test("led 1 get test_device")
+        r = self.launch_good_test("test_device led 1 get")
         self.assertEqual(r, "LED: 1, depth: rgb, mode: on, color: ff0000")
-        r = self.launch_good_test("led 2 get test_device")
+        r = self.launch_good_test("test_device led 2 get")
         self.assertEqual(r, "LED: 2, depth: rgb, mode: cycle, duration: 333, brightness: 40")
-        self.launch_fail_test("led 0 get 10 test_device")
-        self.launch_fail_test("led 10 get test_device")
-        self.launch_fail_test("led 0 get test_device X")
+        self.launch_fail_test("test_device led 0 get 10")
+        self.launch_fail_test("test_device led 10 get")
+        self.launch_fail_test("test_device led 0 get X")
 
     def test_led_n_set_mode(self):
         self.setProfile(0)
-        r = self.launch_good_test("led 0 get test_device")
+        r = self.launch_good_test("test_device led 0 get")
         self.assertEqual(r, "LED: 0, depth: rgb, mode: off")
-        r = self.launch_good_test("led 0 set mode cycle test_device")
+        r = self.launch_good_test("test_device led 0 set mode cycle")
         self.assertEqual(r, '')
-        r = self.launch_good_test("led 0 get test_device")
+        r = self.launch_good_test("test_device led 0 get")
         self.assertEqual(r, "LED: 0, depth: rgb, mode: cycle, duration: 1000, brightness: 20")
-        self.launch_fail_test("led 0 set mode bicycle test_device")
-        self.launch_fail_test("led 0 set mode test_device")
-        self.launch_fail_test("led 0 set mode cycle test_device X")
-        self.launch_fail_test("led 0 set mode cycle X test_device")
+        self.launch_fail_test("test_device led 0 set mode bicycle")
+        self.launch_fail_test("test_device led 0 set mode")
+        self.launch_fail_test("test_device led 0 set mode cycle X")
 
     def test_led_n_set_color(self):
         self.setProfile(0)
-        r = self.launch_good_test("led 1 get test_device")
+        r = self.launch_good_test("test_device led 1 get")
         self.assertEqual(r, "LED: 1, depth: rgb, mode: on, color: ff0000")
-        r = self.launch_good_test("led 1 set color 00ff00 test_device")
+        r = self.launch_good_test("test_device led 1 set color 00ff00")
         self.assertEqual(r, '')
-        r = self.launch_good_test("led 1 get test_device")
+        r = self.launch_good_test("test_device led 1 get")
         self.assertEqual(r, "LED: 1, depth: rgb, mode: on, color: 00ff00")
-        r = self.launch_good_test("led 1 set color 0x0000ff test_device")
+        r = self.launch_good_test("test_device led 1 set color 0x0000ff")
         self.assertEqual(r, '')
-        r = self.launch_good_test("led 1 get test_device")
+        r = self.launch_good_test("test_device led 1 get")
         self.assertEqual(r, "LED: 1, depth: rgb, mode: on, color: 0000ff")
-        self.launch_fail_test("led 1 set color g0ff00 test_device")
-        self.launch_fail_test("led 1 set color test_device")
-        self.launch_fail_test("led 1 set color 00ff00 test_device X")
-        self.launch_fail_test("led 1 set color 00ff00 X test_device")
+        self.launch_fail_test("test_device led 1 set color g0ff00")
+        self.launch_fail_test("test_device led 1 set color")
+        self.launch_fail_test("test_device led 1 set color 00ff00 X")
 
     def test_led_n_set_duration(self):
         self.setProfile(0)
-        r = self.launch_good_test("led 2 get test_device")
+        r = self.launch_good_test("test_device led 2 get")
         self.assertEqual(r, "LED: 2, depth: rgb, mode: cycle, duration: 333, brightness: 40")
-        r = self.launch_good_test("led 2 set duration 10 test_device")
+        r = self.launch_good_test("test_device led 2 set duration 10")
         self.assertEqual(r, '')
-        r = self.launch_good_test("led 2 get test_device")
+        r = self.launch_good_test("test_device led 2 get")
         self.assertEqual(r, "LED: 2, depth: rgb, mode: cycle, duration: 10, brightness: 40")
-        self.launch_fail_test("led 2 set duration this_is_not_an_int test_device")
-        self.launch_fail_test("led 2 set duration test_device")
-        self.launch_fail_test("led 2 set duration 100 test_device X")
-        self.launch_fail_test("led 2 set duration 100 X test_device")
+        self.launch_fail_test("test_device led 2 set duration this_is_not_an_int")
+        self.launch_fail_test("test_device led 2 set duration")
+        self.launch_fail_test("test_device led 2 set duration 100 X")
 
     def test_led_n_set_brightness(self):
         self.setProfile(2)
-        r = self.launch_good_test("led 1 get test_device")
+        r = self.launch_good_test("test_device led 1 get")
         self.assertEqual(r, "LED: 1, depth: rgb, mode: cycle, duration: 333, brightness: 40")
-        r = self.launch_good_test("led 1 set brightness 100 test_device")
+        r = self.launch_good_test("test_device led 1 set brightness 100")
         self.assertEqual(r, '')
-        r = self.launch_good_test("led 1 get test_device")
+        r = self.launch_good_test("test_device led 1 get")
         self.assertEqual(r, "LED: 1, depth: rgb, mode: cycle, duration: 333, brightness: 100")
-        self.launch_fail_test("led 1 set brightness this_is_not_an_int test_device")
-        self.launch_fail_test("led 1 set brightness test_device")
-        self.launch_fail_test("led 1 set brightness 100 test_device X")
-        self.launch_fail_test("led 1 set brightness 100 X test_device")
-        self.launch_fail_test("led 1 set brightness this_is_not_an_int test_device")
-        self.launch_fail_test("led 1 set brightness 256 test_device")
-        self.launch_fail_test("led 1 set brightness -10 test_device")
+        self.launch_fail_test("test_device led 1 set brightness this_is_not_an_int")
+        self.launch_fail_test("test_device led 1 set brightness")
+        self.launch_fail_test("test_device led 1 set brightness 100 X")
+        self.launch_fail_test("test_device led 1 set brightness this_is_not_an_int")
+        self.launch_fail_test("test_device led 1 set brightness 256")
+        self.launch_fail_test("test_device led 1 set brightness -10")
 
     def test_led_n_set_combination(self):
         self.setProfile(2)
-        r = self.launch_good_test("led 0 get test_device")
+        r = self.launch_good_test("test_device led 0 get")
         self.assertEqual(r, "LED: 0, depth: rgb, mode: on, color: ff0000")
-        r = self.launch_good_test("led 0 set mode cycle brightness 100 test_device")
-        r = self.launch_good_test("led 0 get test_device")
+        r = self.launch_good_test("test_device led 0 set mode cycle brightness 100")
+        r = self.launch_good_test("test_device led 0 get")
         self.assertEqual(r, "LED: 0, depth: rgb, mode: cycle, duration: 1000, brightness: 100")
-        r = self.launch_good_test("led 0 set mode cycle duration 100 brightness 255 test_device")
-        r = self.launch_good_test("led 0 get test_device")
+        r = self.launch_good_test("test_device led 0 set mode cycle duration 100 brightness 255")
+        r = self.launch_good_test("test_device led 0 get")
         self.assertEqual(r, "LED: 0, depth: rgb, mode: cycle, duration: 100, brightness: 255")
-        r = self.launch_good_test("led 0 set mode on color 00ff00 test_device")
-        r = self.launch_good_test("led 0 get test_device")
+        r = self.launch_good_test("test_device led 0 set mode on color 00ff00")
+        r = self.launch_good_test("test_device led 0 get")
         self.assertEqual(r, "LED: 0, depth: rgb, mode: on, color: 00ff00")
-        r = self.launch_good_test("led 0 set duration 100 brightness 200 mode cycle test_device")
-        r = self.launch_good_test("led 0 get test_device")
+        r = self.launch_good_test("test_device led 0 set duration 100 brightness 200 mode cycle")
+        r = self.launch_good_test("test_device led 0 get")
         self.assertEqual(r, "LED: 0, depth: rgb, mode: cycle, duration: 100, brightness: 200")
-        r = self.launch_good_test("led 0 set duration 100 brightness 200 mode cycle brightness 100 test_device")
-        r = self.launch_good_test("led 0 get test_device")
+        r = self.launch_good_test("test_device led 0 set duration 100 brightness 200 mode cycle brightness 100")
+        r = self.launch_good_test("test_device led 0 get")
         self.assertEqual(r, "LED: 0, depth: rgb, mode: cycle, duration: 100, brightness: 100")
-        self.launch_fail_test("led 0 set brightness 10 mode bicycle test_device")
+        self.launch_fail_test("test_device led 0 set brightness 10 mode bicycle")
 
     def test_prefix_led(self):
         self.setProfile(2)
-        r = self.launch_good_test("Profile 1 Led 1 get test_device")
+        r = self.launch_good_test("test_device Profile 1 Led 1 get")
         self.assertEqual(r, "LED: 1, depth: rgb, mode: off")
-        self.launch_fail_test("Profile 1 Profile 2 Led 1 get test_device")
-        self.launch_fail_test("Profile 1 Resolution 2 Led 1 get test_device")
+        self.launch_fail_test("test_device Profile 1 Profile 2 Led 1 get")
+        self.launch_fail_test("test_device Profile 1 Resolution 2 Led 1 get")
 
     def test_led_capabilities(self):
-        r = self.launch_good_test("led 0 capabilities test_device")
+        r = self.launch_good_test("test_device led 0 capabilities")
         self.assertEqual(r, "Modes: breathing, cycle, off, on")
-        r = self.launch_good_test("led 1 capabilities test_device")
+        r = self.launch_good_test("test_device led 1 capabilities")
         self.assertEqual(r, "Modes: breathing, cycle, off, on")