[commands] Support autorepeat in SBCommands

[wallace]

Summary

This adds support for commands created through the API to support autorepeat.
This covers the case of single word and multiword commands.

Comprehensive tests are included as well.

[clayborg]

LGTM. Pavel?

[jingham]

It's great to add this capability. But if you pass a nullptr, then the exact previous command will be repeated. That's sometimes what you want, but often not. For instance:

(lldb) source list -f foo -l 10
...
(lldb)<RET>

You DON'T want those same source lines to be dumped again.

The full solution would be to add an optional method to the Python class version of the command that returns the "repeat" command string. Then if that is implemented use the string it produces.

There are only a couple of commands (source list being one) that actually have to make up whole new command lines for the repeat command. For most of them - like disassemble - the command with no arguments does "continue from where you left off". So then the you return just your command name for the repeat command. Maybe there's some way to add this convention in without having to go whole hog on exposing the repeat string behavior.

[jingham]

For instance, maybe instead of passing in a bool, you could pass in the repeat command? So when you create the command, if you pass in None, you get no repeat, if you pass in "" you get the exact command line repeated, and if you pass in anything else, that will be the repeat command. Or maybe use an enum with "noRepeat, exactRepeat, commandNameRepeat"?

[wallace]

Very good idea!

[clayborg]

I was thinking if auto repeat was enabled that the DoExecute would just get called again with nothing and then the plug-in could maintain any repeat commands without needing to add anything... Glad you chimed in!

[clayborg]

The biggest issue is maintaining the API. We can't add anything to SBCommandPluginInterface

[labath]

In D77444#1962952, @clayborg wrote:

The biggest issue is maintaining the API. We can't add anything to SBCommandPluginInterface

If we're going to be adding a new inheritable class for this feature, I'd recommend adding about half a dozen or so dummy virtual methods to it so we reserve vtable space for future expansion.

lldb/test/API/api/auto-repeat-command/TestSBCommandAutoRepeat.py

1 ↗

(On Diff #254965)

Could you try making this a unit test (like the regular c++ unit tests)?

I know we have already have tests following this pattern, but that was because they were all written before we had googletest, and they all have a lot of problems I'm not keen on repeating.

[clayborg]

In D77444#1963354, @labath wrote:

In D77444#1962952, @clayborg wrote:

The biggest issue is maintaining the API. We can't add anything to SBCommandPluginInterface

If we're going to be adding a new inheritable class for this feature, I'd recommend adding about half a dozen or so dummy virtual methods to it so we reserve vtable space for future expansion.

I second that!

[wallace]

• Moved the test to gtest. It's much better this way and I learned gtest
• Changed the API. Some notes:

Within the scope of a subcommand, the subcommand doesn't know the parent's
command name. It only knows its own name and it doesn't have any referrence to
its parent. That makes it very difficult to implement an enum option for
eCommandNameRepeat, as @jingham suggested. The GetRepeatCommand signature also
doesn't provide useful info about the parsed arguments.

I took a look at the existing implementations for GetRepeatCommand, and it seems
that most of them just return nullptr, "", or the same command without flags.

I don't want to change any existing core command interpreter function, so I
think that a simple API that covers most of the cases is just providing nullptr
for repeating the same command, "" for not repeating, or a custom string for
any other case. If in the future anyone needs something very customized, a new
override could be created, but I don't think this will happen anytime soon.

Another option is to provide a callback function instead of a string, but I
don't know if it's too much.

[wallace]

nits

[labath]

Thank you for trying out gtest. I'm very happy that this is working out for you. The test looks fine -- just please move it to unittests/API (new folder) -- that's where it logically belongs as it's testing the API code (and it also avoids dangerous ODR violations resulting from linking in both liblldb and its constituent libraries).

It sounds like you and Jim have mostly agreed on the way this should be implemented. I'll let you two work out any kinks there.

lldb/unittests/Interpreter/TestAutoRepeat.cpp

26

The recommended llvm style for this is /*arg_name=*/value.

62

make a gtest assert out of this?

[labath]

BTW, in gtest tests, the prevailing convention is to name test .cpp files according to the name of the .cpp file under test. So, in this case, that would be something like unittests/API/SBCommandInterpreterTest.cpp. I wouldn't want to take that convention to the extreme and have 10kloc test files, but until we start having more of these tests, I think we can stick to that.

[jingham]

This looks good to me, except that instead of leaving all the other variants of AddCommand, they should funnel through the one that takes the most arguments. It was poor form to leave two around and more so now that there's three.

I'm beginning to think we need an SBAddCommandOptions or something like that so we don't need to add yet another variant next time we want to add some flags to a command. That is a nice-to-have, however. If you are done with this change, it's okay as it stands.

In retrospect, I think it would be better if the CommandInterpreter were to prepend the container commands to the repeat command string. It is bogus that multi-word commands have to know their hierarchy to emit a useful repeat command string.

Prepending the containing commands would mean that command A couldn't invoke a totally different command as its repeat command. But that seems like an odd thing to do anyway. And that way a command wouldn't have to know where it is situated in the command hierarchy for the repeat command to work. That makes your test ugly, but that's not your fault (it's probably some earlier version of me's decision).

lldb/source/API/SBCommandInterpreter.cpp

857

Instead of keeping these copies of AddCommand around, can you funnel all of them through the one that takes the auto_repeat command? That would reduce boilerplate and make adding the next thing easier...

[wallace]

address comments

[jingham]

LGTM

[labath]

lldb/unittests/API/CMakeLists.txt

2 ↗

(On Diff #256076)

Well.. this is now definitely going to get tested well. :P

While we do have some inconsistency where some test files put "Test" as a prefix and others as a suffix, we definitely don't need to have both in the same file. The Test suffix is a prevailing convention (792 vs. 62), so I recommend sticking to that.

lldb/include/lldb/API/SBCommandInterpreter.h

 //===-- SBCommandInterpreter.h ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
public:
   bool HasAliasOptions();
 
   lldb::SBProcess GetProcess();
 
   lldb::SBDebugger GetDebugger();
 
   lldb::SBCommand AddMultiwordCommand(const char *name, const char *help);
 
+  /// Add a new command to the lldb::CommandInterpreter.
+  ///
+  /// The new command won't support autorepeat. If you need this functionality,
+  /// use the override of this function that accepts the \a auto_repeat
+  /// parameter.
+  ///
+  /// \param[in] name
+  ///     The name of the command.
+  ///
+  /// \param[in] impl
+  ///     The handler of this command.
+  ///
+  /// \param[in] help
+  ///     The general description to show as part of the help message of this
+  ///     command.
+  ///
+  /// \return
+  ///     A lldb::SBCommand representing the newly created command.
   lldb::SBCommand AddCommand(const char *name,
                              lldb::SBCommandPluginInterface *impl,
                              const char *help);
 
+  /// Add a new command to the lldb::CommandInterpreter.
+  ///
+  /// The new command won't support autorepeat. If you need this functionality,
+  /// use the override of this function that accepts the \a auto_repeat
+  /// parameter.
+  ///
+  /// \param[in] name
+  ///     The name of the command.
+  ///
+  /// \param[in] impl
+  ///     The handler of this command.
+  ///
+  /// \param[in] help
+  ///     The general description to show as part of the help message of this
+  ///     command.
+  ///
+  /// \param[in] syntax
+  ///     The syntax to show as part of the help message of this command. This
+  ///     could include a description of the different arguments and flags this
+  ///     command accepts.
+  ///
+  /// \return
+  ///     A lldb::SBCommand representing the newly created command.
   lldb::SBCommand AddCommand(const char *name,
                              lldb::SBCommandPluginInterface *impl,
                              const char *help, const char *syntax);
 
+  /// Add a new command to the lldb::CommandInterpreter.
+  ///
+  /// \param[in] name
+  ///     The name of the command.
+  ///
+  /// \param[in] impl
+  ///     The handler of this command.
+  ///
+  /// \param[in] help
+  ///     The general description to show as part of the help message of this
+  ///     command.
+  ///
+  /// \param[in] syntax
+  ///     The syntax to show as part of the help message of this command. This
+  ///     could include a description of the different arguments and flags this
+  ///     command accepts.
+  ///
+  /// \param[in] auto_repeat_type
+  ///     Flag that controls whether to accept autorepeating or not.
+  ///     Autorepeating is triggered when the user presses Enter successively
+  ///     after executing a command.
+  ///
+  /// \return
+  ///     A lldb::SBCommand representing the newly created command.
+  lldb::SBCommand AddCommand(const char *name,
+                             lldb::SBCommandPluginInterface *impl,
+                             const char *help, const char *syntax,
+                             const char *auto_repeat_command);
+
   void SourceInitFileInHomeDirectory(lldb::SBCommandReturnObject &result);
 
   void
   SourceInitFileInCurrentWorkingDirectory(lldb::SBCommandReturnObject &result);
 
   lldb::ReturnStatus HandleCommand(const char *command_line,
                                    lldb::SBCommandReturnObject &result,
                                    bool add_to_history = false);
public:
 
   uint32_t GetFlags();
 
   void SetFlags(uint32_t flags);
 
   lldb::SBCommand AddMultiwordCommand(const char *name,
                                       const char *help = nullptr);
 
+  /// Add a new subcommand to the lldb::SBCommand.
+  ///
+  /// The new command won't support autorepeat. If you need this functionality,
+  /// use the override of this function that accepts the \a auto_repeat
+  /// parameter.
+  ///
+  /// \param[in] name
+  ///     The name of the command.
+  ///
+  /// \param[in] impl
+  ///     The handler of this command.
+  ///
+  /// \param[in] help
+  ///     The general description to show as part of the help message of this
+  ///     command.
+  ///
+  /// \return
+  ///     A lldb::SBCommand representing the newly created command.
   lldb::SBCommand AddCommand(const char *name,
                              lldb::SBCommandPluginInterface *impl,
                              const char *help = nullptr);
 
+  /// Add a new subcommand to the lldb::SBCommand.
+  ///
+  /// The new command won't support autorepeat. If you need this functionality,
+  /// use the override of this function that accepts the \a auto_repeat
+  /// parameter.
+  ///
+  /// \param[in] name
+  ///     The name of the command.
+  ///
+  /// \param[in] impl
+  ///     The handler of this command.
+  ///
+  /// \param[in] help
+  ///     The general description to show as part of the help message of this
+  ///     command.
+  ///
+  /// \param[in] syntax
+  ///     The syntax to show as part of the help message of this command. This
+  ///     could include a description of the different arguments and flags this
+  ///     command accepts.
+  ///
+  /// \return
+  ///     A lldb::SBCommand representing the newly created command.
   lldb::SBCommand AddCommand(const char *name,
                              lldb::SBCommandPluginInterface *impl,
                              const char *help, const char *syntax);
 
+  /// Add a new subcommand to the lldb::SBCommand.
+  ///
+  /// The new command won't support autorepeat. If you need this functionality,
+  /// use the override of this function that accepts the \a auto_repeat
+  /// parameter.
+  ///
+  /// \param[in] name
+  ///     The name of the command.
+  ///
+  /// \param[in] impl
+  ///     The handler of this command.
+  ///
+  /// \param[in] help
+  ///     The general description to show as part of the help message of this
+  ///     command.
+  ///
+  /// \param[in] syntax
+  ///     The syntax to show as part of the help message of this command. This
+  ///     could include a description of the different arguments and flags this
+  ///     command accepts.
+  ///
+  /// \param[in] auto_repeat_type
+  ///     Flag that controls whether to accept autorepeating or not.
+  ///     Autorepeating is triggered when the user presses Enter successively
+  ///     after executing a command.
+  ///
+  /// \return
+  ///     A lldb::SBCommand representing the newly created command.
+  lldb::SBCommand AddCommand(const char *name,
+                             lldb::SBCommandPluginInterface *impl,
+                             const char *help, const char *syntax,
+                             const char *auto_repeat_command);
+
 private:
   friend class SBDebugger;
   friend class SBCommandInterpreter;
 
   SBCommand(lldb::CommandObjectSP cmd_sp);
 
   lldb::CommandObjectSP m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBCOMMANDINTERPRETER_H

lldb/source/API/SBCommandInterpreter.cpp

 //===-- SBCommandInterpreter.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 
 class CommandPluginInterfaceImplementation : public CommandObjectParsed {
 public:
   CommandPluginInterfaceImplementation(CommandInterpreter &interpreter,
                                        const char *name,
                                        lldb::SBCommandPluginInterface *backend,
                                        const char *help = nullptr,
                                        const char *syntax = nullptr,
-                                       uint32_t flags = 0)
+                                       uint32_t flags = 0,
+                                       const char *auto_repeat_command = "")
       : CommandObjectParsed(interpreter, name, help, syntax, flags),
-        m_backend(backend) {}
+        m_backend(backend) {
+    m_auto_repeat_command =
+        auto_repeat_command == nullptr
+            ? llvm::None
+            : llvm::Optional<std::string>(auto_repeat_command);
+  }
 
   bool IsRemovable() const override { return true; }
 
+  /// More documentation is available in lldb::CommandObject::GetRepeatCommand,
+  /// but in short, if nullptr is returned, the previous command will be
+  /// repeated, and if an empty string is returned, no commands will be
+  /// executed.
+  const char *GetRepeatCommand(Args &current_command_args,
+                               uint32_t index) override {
+    if (!m_auto_repeat_command)
+      return nullptr;
+    else
+      return m_auto_repeat_command->c_str();
+  }
+
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     SBCommandReturnObject sb_return(result);
     SBCommandInterpreter sb_interpreter(&m_interpreter);
     SBDebugger debugger_sb(m_interpreter.GetDebugger().shared_from_this());
     bool ret = m_backend->DoExecute(
         debugger_sb, (char **)command.GetArgumentVector(), sb_return);
     return ret;
   }
   std::shared_ptr<lldb::SBCommandPluginInterface> m_backend;
+  llvm::Optional<std::string> m_auto_repeat_command;
 };
 
 SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
     : m_opaque_ptr(interpreter) {
   LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
                           (lldb_private::CommandInterpreter *), interpreter);
 
 }
new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
       *m_opaque_ptr, name, impl, help, syntax);
 
   if (new_command_sp &&
       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
     return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
   return LLDB_RECORD_RESULT(lldb::SBCommand());
 }
 
+lldb::SBCommand SBCommandInterpreter::AddCommand(
+    const char *name, lldb::SBCommandPluginInterface *impl, const char *help,
+    const char *syntax, const char *auto_repeat_command) {
+  LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
+                     (const char *, lldb::SBCommandPluginInterface *,
+                      const char *, const char *, const char *),
+                     name, impl, help, syntax, auto_repeat_command);
+
+  lldb::CommandObjectSP new_command_sp;
+  new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
+      *m_opaque_ptr, name, impl, help, syntax, 0 /*flags*/,
+      auto_repeat_command);
+
+  if (new_command_sp &&
+      m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
+    return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
+  return LLDB_RECORD_RESULT(lldb::SBCommand());
+}
+
 SBCommand::SBCommand() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommand); }
 
 SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {}
 
 bool SBCommand::IsValid() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid);
   return this->operator bool();
 }
lldb::SBCommand SBCommand::AddCommand(const char *name,
   lldb::CommandObjectSP new_command_sp;
   new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
       m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax);
   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
     return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
   return LLDB_RECORD_RESULT(lldb::SBCommand());
 }
 
+lldb::SBCommand SBCommand::AddCommand(const char *name,
+                                      lldb::SBCommandPluginInterface *impl,
+                                      const char *help, const char *syntax,
+                                      const char *auto_repeat_command) {
+  LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand,
+                     (const char *, lldb::SBCommandPluginInterface *,
+                      const char *, const char *, const char *),
+                     name, impl, help, syntax, auto_repeat_command);
+
+  if (!IsValid())
+    return LLDB_RECORD_RESULT(lldb::SBCommand());
+  if (!m_opaque_sp->IsMultiwordObject())
+    return LLDB_RECORD_RESULT(lldb::SBCommand());
+  lldb::CommandObjectSP new_command_sp;
+  new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
+      m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax,
+      0 /*flags*/, auto_repeat_command);
+  if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
+    return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
+  return LLDB_RECORD_RESULT(lldb::SBCommand());
+}
+
 uint32_t SBCommand::GetFlags() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBCommand, GetFlags);
 
   return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0);
 }
 
 void SBCommand::SetFlags(uint32_t flags) {
   LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags);
void RegisterMethods<SBCommandInterpreterRunOptions>(Registry &R) {
   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter,
                        AddMultiwordCommand, (const char *, const char *));
   LLDB_REGISTER_METHOD(
       lldb::SBCommand, SBCommandInterpreter, AddCommand,
       (const char *, lldb::SBCommandPluginInterface *, const char *));
   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
                        (const char *, lldb::SBCommandPluginInterface *,
                         const char *, const char *));
+  LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
+                       (const char *, lldb::SBCommandPluginInterface *,
+                        const char *, const char *, const char *));
   LLDB_REGISTER_CONSTRUCTOR(SBCommand, ());
   LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBCommand, operator bool, ());
   LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ());
   LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ());
   LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ());
   LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *));
   LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *));
   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
                        (const char *, const char *));
   LLDB_REGISTER_METHOD(
       lldb::SBCommand, SBCommand, AddCommand,
       (const char *, lldb::SBCommandPluginInterface *, const char *));
   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
                        (const char *, lldb::SBCommandPluginInterface *,
                         const char *, const char *));
+  LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
+                       (const char *, lldb::SBCommandPluginInterface *,
+                        const char *, const char *, const char *));
   LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ());
   LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t));
 }
 
 }
 }

lldb/unittests/Interpreter/CMakeLists.txt

 add_lldb_unittest(InterpreterTests
   TestCompletion.cpp
   TestOptionArgParser.cpp
+  TestAutoRepeat.cpp
 
   LINK_LIBS
+    liblldb
     lldbInterpreter
     lldbUtilityHelpers
   )

lldb/unittests/Interpreter/TestAutoRepeat.cpp

+//===-- TestAutoRepeat.cpp -----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===/
+
+#include "gtest/gtest.h"
+
+#include "lldb/API/SBCommandInterpreter.h"
+#include "lldb/API/SBCommandReturnObject.h"
+#include "lldb/API/SBDebugger.h"
+
+#include <cassert>
+#include <cstring>
+#include <string>
+
+using namespace lldb;
+
+class TestAutoRepeat : public testing::Test {
+protected:
+  void SetUp() override {
+    SBDebugger::Initialize();
+    m_dbg = SBDebugger::Create(false /*source_init_files*/);
+    m_interp = m_dbg.GetCommandInterpreter();
+  }
+
+  SBDebugger m_dbg;
+  SBCommandInterpreter m_interp;
+};
+
+class DummyCommand : public SBCommandPluginInterface {
+public:
+  DummyCommand(const char *message) : m_message(message) {}
+
+  bool DoExecute(SBDebugger dbg, char **command,
+                 SBCommandReturnObject &result) {
+    result.PutCString(m_message.c_str());
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return result.Succeeded();
+  }
+
+private:
+  std::string m_message;
+};
+
+TEST_F(TestAutoRepeat, SingleWordCommand) {
+  // We first test a command without autorepeat
+  DummyCommand dummy("It worked");
+  m_interp.AddCommand("dummy", &dummy, nullptr /*help*/);
+  {
+    SBCommandReturnObject result;
+    m_interp.HandleCommand("dummy", result, true /*add_to_history*/);
+    EXPECT_TRUE(result.Succeeded());
+    EXPECT_STREQ(result.GetOutput(), "It worked\n");
+  }
+  {
+    SBCommandReturnObject result;
+    m_interp.HandleCommand("", result);
+    assert(!result.Succeeded() &&
+           "The command should fail as a repeated command");
+    EXPECT_STREQ(result.GetError(), "error: No auto repeat.\n");
+  }
+
+  // Now we test a command with autorepeat
+  m_interp.AddCommand("dummy_with_autorepeat", &dummy, nullptr /*help*/,
+                      nullptr /*syntax*/, nullptr /*auto_repeat_command*/);
+  {
+    SBCommandReturnObject result;
+    m_interp.HandleCommand("dummy_with_autorepeat", result,
+                           true /*add_to_history*/);
+    EXPECT_TRUE(result.Succeeded());
+    EXPECT_STREQ(result.GetOutput(), "It worked\n");
+  }
+  {
+    SBCommandReturnObject result;
+    m_interp.HandleCommand("", result);
+    EXPECT_TRUE(result.Succeeded());
+    EXPECT_STREQ(result.GetOutput(), "It worked\n");
+  }
+}
+
+TEST_F(TestAutoRepeat, MultiWordCommand) {
+  auto command = m_interp.AddMultiwordCommand("multicommand", nullptr /*help*/);
+  // We first test a subcommand without autorepeat
+  DummyCommand subcommand("It worked again");
+  command.AddCommand("subcommand", &subcommand, nullptr /*help*/);
+  {
+    SBCommandReturnObject result;
+    m_interp.HandleCommand("multicommand subcommand", result,
+                           true /*add_to_history*/);
+    EXPECT_TRUE(result.Succeeded());
+    EXPECT_STREQ(result.GetOutput(), "It worked again\n");
+  }
+  {
+    SBCommandReturnObject result;
+    m_interp.HandleCommand("", result);
+    assert(!result.Succeeded() &&
+           "The command should fail as a repeated command");
+    EXPECT_STREQ(result.GetError(), "error: No auto repeat.\n");
+  }
+
+  // We first test a subcommand with autorepeat
+  command.AddCommand("subcommand_with_autorepeat", &subcommand,
+                     nullptr /*help*/, nullptr /*syntax*/,
+                     nullptr /*auto_repeat_command*/);
+  {
+    SBCommandReturnObject result;
+    m_interp.HandleCommand("multicommand subcommand_with_autorepeat", result,
+                           true /*add_to_history*/);
+    EXPECT_TRUE(result.Succeeded());
+    EXPECT_STREQ(result.GetOutput(), "It worked again\n");
+  }
+  {
+    SBCommandReturnObject result;
+    m_interp.HandleCommand("", result);
+    EXPECT_TRUE(result.Succeeded());
+    EXPECT_STREQ(result.GetOutput(), "It worked again\n");
+  }
+
+  DummyCommand subcommand2("It worked again 2");
+  // We now test a subcommand with autorepeat of the command name
+  command.AddCommand(
+      "subcommand_with_custom_autorepeat", &subcommand2, nullptr /*help*/,
+      nullptr /*syntax*/,
+      "multicommand subcommand_with_autorepeat" /*auto_repeat_command*/);
+  {
+    SBCommandReturnObject result;
+    m_interp.HandleCommand("multicommand subcommand_with_custom_autorepeat",
+                           result, true /*add_to_history*/);
+    EXPECT_TRUE(result.Succeeded());
+    EXPECT_STREQ(result.GetOutput(), "It worked again 2\n");
+  }
+  {
+    SBCommandReturnObject result;
+    m_interp.HandleCommand("", result);
+    EXPECT_TRUE(result.Succeeded());
+    EXPECT_STREQ(result.GetOutput(), "It worked again\n");
+  }
+}