   end
 
   test "point", %{shim: shim} do
-    :ok = shim_fun_ok(shim, %{x: 100, y: 200, z: 300})
+    :ok = simulate_syscall(shim, %{x: 100, y: 200, z: 300})
 
     assert %{x: 100, y: 200, z: 300} =
              SysCalls.point(TestSysCalls, "Peripheral", 1)
 
     assert_receive {:point, ["Peripheral", 1]}
 
-    :ok = shim_fun_error(shim, "point error")
+    :ok = simulate_syscall_error(shim, "point error")
 
     assert {:error, "point error"} ==
              SysCalls.point(TestSysCalls, "Peripheral", 1)
   end
 
+  test "point groups", %{shim: shim} do
+    :ok = simulate_syscall(shim, %{x: 100, y: 200, z: 300})
+
+    assert %{x: 100, y: 200, z: 300} =
+             SysCalls.point(TestSysCalls, "Peripheral", 1)
+
+    assert_receive {:point, ["Peripheral", 1]}
+
+    :ok = simulate_syscall_error(shim, "point error")
+
+    assert {:error, "point error"} ==
+             SysCalls.point(TestSysCalls, "Peripheral", 1)
+  end
+
   test "move_absolute", %{shim: shim} do
-    :ok = shim_fun_ok(shim)
+    :ok = simulate_syscall(shim)
     assert :ok = SysCalls.move_absolute(TestSysCalls, 1, 2, 3, 4)
     assert_receive {:move_absolute, [1, 2, 3, 4]}
 
-    :ok = shim_fun_error(shim, "move failed!")
+    :ok = simulate_syscall_error(shim, "move failed!")
 
     assert {:error, "move failed!"} ==
              SysCalls.move_absolute(TestSysCalls, 1, 2, 3, 4)
   end
 
   test "get current positions", %{shim: shim} do
-    :ok = shim_fun_ok(shim, 100.00)
+    :ok = simulate_syscall(shim, 100.00)
     assert 100.00 = SysCalls.get_current_x(TestSysCalls)
     assert 100.00 = SysCalls.get_current_y(TestSysCalls)
     assert 100.00 = SysCalls.get_current_z(TestSysCalls)

    assert_receive {:get_current_y, []}
    assert_receive {:get_current_z, []}

    :ok = shim_fun_error(shim, "firmware error")

    assert {:error, "firmware error"} == SysCalls.get_current_x(TestSysCalls)
    assert {:error, "firmware error"} == SysCalls.get_current_y(TestSysCalls)

    assert_receive {:write_pin, [%{type: "boxled", id: 4}, 0, 1]}
    assert_receive {:write_pin, [%{type: "boxled", id: 3}, 1, 123]}

    :ok = simulate_syscall_error(shim, "firmware error")

    assert {:error, "firmware error"} ==
             SysCalls.write_pin(TestSysCalls, 1, 0, 1)
  end

  test "read_pin", %{shim: shim} do
    :ok = simulate_syscall(shim, 1)
    assert 1 == SysCalls.read_pin(TestSysCalls, 10, 0)
    assert 1 == SysCalls.read_pin(TestSysCalls, 77, nil)
    assert_receive {:read_pin, [10, 0]}
    assert_receive {:read_pin, [77, nil]}

    :ok = simulate_syscall_error(shim, "firmware error")

    assert {:error, "firmware error"} == SysCalls.read_pin(TestSysCalls, 1, 0)
  end

  test "wait", %{shim: shim} do
    :ok = simulate_syscall(shim)
    assert :ok = SysCalls.wait(TestSysCalls, 1000)
    assert_receive {:wait, [1000]}
  end

  test "named_pin", %{shim: shim} do
    # Peripheral and Sensor are on the Arduino
    :ok = simulate_syscall(shim, 44)
    assert 44 == SysCalls.named_pin(TestSysCalls, "Peripheral", 5)
    assert 44 == SysCalls.named_pin(TestSysCalls, "Sensor", 1999)

    # BoxLed is on the GPIO
    :ok = simulate_syscall(shim, %{type: "BoxLed", id: 3})

    assert %{type: "BoxLed", id: 3} ==
             SysCalls.named_pin(TestSysCalls, "BoxLed", 3)

    :ok = simulate_syscall(shim, %{type: "BoxLed", id: 4})

    assert %{type: "BoxLed", id: 4} ==
             SysCalls.named_pin(TestSysCalls, "BoxLed", 4)
