blob: 07f95fcff2560623de0cb5449fba35a271079f2f [file]
// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/developer/debug/zxdb/console/command_parser.h"
#include <span>
#include <type_traits>
#include <gtest/gtest.h>
#include "src/developer/debug/zxdb/client/analytics_event.h"
#include "src/developer/debug/zxdb/common/err.h"
#include "src/developer/debug/zxdb/console/command.h"
#include "src/developer/debug/zxdb/console/nouns.h"
namespace zxdb {
namespace {
bool CompletionContains(const std::vector<std::string>& suggestions, const std::string& contains) {
return std::find(suggestions.begin(), suggestions.end(), contains) != suggestions.end();
}
TEST(CommandParser, Tokenizer) {
std::vector<CommandToken> output;
EXPECT_FALSE(TokenizeCommand("", &output).has_error());
EXPECT_TRUE(output.empty());
EXPECT_FALSE(TokenizeCommand(" ", &output).has_error());
EXPECT_TRUE(output.empty());
EXPECT_FALSE(TokenizeCommand("a", &output).has_error());
ASSERT_EQ(1u, output.size());
EXPECT_EQ(0u, output[0].offset);
EXPECT_EQ("a", output[0].str);
EXPECT_FALSE(TokenizeCommand("ab cd", &output).has_error());
ASSERT_EQ(2u, output.size());
EXPECT_EQ(0u, output[0].offset);
EXPECT_EQ("ab", output[0].str);
EXPECT_EQ(3u, output[1].offset);
EXPECT_EQ("cd", output[1].str);
EXPECT_FALSE(TokenizeCommand(" ab cd ", &output).has_error());
ASSERT_EQ(2u, output.size());
EXPECT_EQ(2u, output[0].offset);
EXPECT_EQ("ab", output[0].str);
EXPECT_EQ(6u, output[1].offset);
EXPECT_EQ("cd", output[1].str);
// Quoting.
EXPECT_FALSE(TokenizeCommand(" \"one string\" R\"(two\"string)\" ", &output).has_error());
ASSERT_EQ(2u, output.size());
EXPECT_EQ(2u, output[0].offset);
EXPECT_EQ("one string", output[0].str);
EXPECT_EQ(15u, output[1].offset);
EXPECT_EQ("two\"string", output[1].str);
// Quoting in the middle of a token.
EXPECT_FALSE(TokenizeCommand(" foo\"one string\"bar ", &output).has_error());
ASSERT_EQ(1u, output.size());
EXPECT_EQ(1u, output[0].offset);
EXPECT_EQ("fooone stringbar", output[0].str);
// Single quotes don't quote.
EXPECT_FALSE(TokenizeCommand("123'456", &output).has_error());
ASSERT_EQ(1u, output.size());
EXPECT_EQ(0u, output[0].offset);
EXPECT_EQ("123'456", output[0].str);
}
TEST(CommandParser, ParserBasic) {
Command output;
// Verb-only command.
Err err = ParseCommand("pause", &output);
EXPECT_FALSE(err.has_error());
EXPECT_TRUE(output.nouns().empty());
EXPECT_EQ(Verb::kPause, output.verb());
// Noun-only command.
err = ParseCommand("process", &output);
EXPECT_FALSE(err.has_error()) << err.msg();
EXPECT_EQ(1u, output.nouns().size());
EXPECT_TRUE(output.HasNoun(Noun::kProcess));
EXPECT_EQ(Command::kNoIndex, output.GetNounIndex(Noun::kProcess));
EXPECT_EQ(Verb::kNone, output.verb());
// Noun-index command.
err = ParseCommand("process 1", &output);
EXPECT_FALSE(err.has_error());
EXPECT_EQ(1u, output.nouns().size());
EXPECT_TRUE(output.HasNoun(Noun::kProcess));
EXPECT_EQ(1, output.GetNounIndex(Noun::kProcess));
EXPECT_EQ(Verb::kNone, output.verb());
// Noun-verb command.
err = ParseCommand("process pause", &output);
EXPECT_FALSE(err.has_error());
EXPECT_EQ(1u, output.nouns().size());
EXPECT_TRUE(output.HasNoun(Noun::kProcess));
EXPECT_EQ(Command::kNoIndex, output.GetNounIndex(Noun::kProcess));
EXPECT_EQ(Verb::kPause, output.verb());
// Noun-index-verb command.
err = ParseCommand("process 2 pause", &output);
EXPECT_FALSE(err.has_error());
EXPECT_EQ(1u, output.nouns().size());
EXPECT_TRUE(output.HasNoun(Noun::kProcess));
EXPECT_EQ(2, output.GetNounIndex(Noun::kProcess));
EXPECT_EQ(Verb::kPause, output.verb());
err = ParseCommand("process 2 thread 1 pause", &output);
EXPECT_FALSE(err.has_error());
EXPECT_EQ(2u, output.nouns().size());
EXPECT_TRUE(output.HasNoun(Noun::kProcess));
EXPECT_EQ(2, output.GetNounIndex(Noun::kProcess));
EXPECT_TRUE(output.HasNoun(Noun::kThread));
EXPECT_EQ(1, output.GetNounIndex(Noun::kThread));
EXPECT_EQ(Verb::kPause, output.verb());
}
TEST(CommandParser, ParserBasicErrors) {
Command output;
// Unknown command in different contexts.
Err err = ParseCommand("zzyzx", &output);
EXPECT_TRUE(err.has_error());
EXPECT_EQ("The string \"zzyzx\" is not a valid verb. Did you mean \"x\"?", err.msg());
err = ParseCommand("process 1 zzyzx", &output);
EXPECT_TRUE(err.has_error());
EXPECT_EQ("The string \"zzyzx\" is not a valid verb. Did you mean \"x\"?", err.msg());
err = ParseCommand("process 1 process pause", &output);
EXPECT_TRUE(err.has_error());
EXPECT_EQ("Noun \"process\" specified twice.", err.msg());
}
TEST(CommandParser, NounSwitches) {
Command output;
// Look up the switch ID for the "-v" noun switch.
const SwitchRecord* verbose_switch = nullptr;
for (const auto& sr : GetNounSwitches()) {
if (sr.ch == 'v') {
verbose_switch = &sr;
break;
}
}
ASSERT_TRUE(verbose_switch);
Err err = ParseCommand("frame -", &output);
EXPECT_TRUE(err.has_error());
EXPECT_EQ("Invalid switch \"-\". Usage: frame [ <id> [ <command> ... ] ]", err.msg());
// Valid short switch.
err = ParseCommand("frame -v", &output);
EXPECT_FALSE(err.has_error()) << err.msg();
EXPECT_EQ(1u, output.switches().size());
EXPECT_TRUE(output.HasSwitch(verbose_switch->id));
// Valid long switch.
err = ParseCommand("frame --verbose", &output);
EXPECT_FALSE(err.has_error()) << err.msg();
EXPECT_EQ(1u, output.switches().size());
EXPECT_TRUE(output.HasSwitch(verbose_switch->id));
}
TEST(CommandParser, VerbSwitches) {
Command output;
// Look up the switch ID for the size switch to "memory read". This allows
// the checks below to stay in sync without knowing much about how the memory
// command is implemented.
const auto& verbs = GetVerbs();
auto read_record = verbs.find(Verb::kMemRead);
ASSERT_NE(read_record, verbs.end());
const SwitchRecord* size_switch = nullptr;
for (const auto& sr : read_record->second.switches) {
if (sr.ch == 's') {
size_switch = &sr;
break;
}
}
ASSERT_TRUE(size_switch);
Err err = ParseCommand("mem-read -", &output);
EXPECT_TRUE(err.has_error());
EXPECT_EQ("Invalid switch \"-\". Usage: mem-read [ --size=<bytes> ] <address-expression>",
err.msg());
// Valid long switch with no equals.
err = ParseCommand("mem-read --size 234 next", &output);
EXPECT_FALSE(err.has_error());
EXPECT_EQ(1u, output.switches().size());
EXPECT_EQ("234", output.GetSwitchValue(size_switch->id));
ASSERT_EQ(1u, output.args().size());
EXPECT_EQ("next", output.args()[0]);
// Quoted value.
err = ParseCommand("mem-read --size \"23 4\" next", &output);
EXPECT_FALSE(err.has_error());
EXPECT_EQ(1u, output.switches().size());
EXPECT_EQ("23 4", output.GetSwitchValue(size_switch->id));
ASSERT_EQ(1u, output.args().size());
EXPECT_EQ("next", output.args()[0]);
// Valid long switch with equals sign.
err = ParseCommand("mem-read --size=234 next", &output);
EXPECT_FALSE(err.has_error()) << err.msg();
EXPECT_EQ(1u, output.switches().size());
EXPECT_EQ("234", output.GetSwitchValue(size_switch->id));
ASSERT_EQ(1u, output.args().size());
EXPECT_EQ("next", output.args()[0]);
// Valid long switch with equals and no value (this is OK, value is empty
// string).
err = ParseCommand("mem-read --size= next", &output);
EXPECT_FALSE(err.has_error());
EXPECT_EQ(1u, output.switches().size());
EXPECT_EQ("", output.GetSwitchValue(size_switch->id));
ASSERT_EQ(1u, output.args().size());
EXPECT_EQ("next", output.args()[0]);
// Expects a value for a long switch.
err = ParseCommand("mem-read --size", &output);
EXPECT_TRUE(err.has_error());
EXPECT_EQ(
"Argument needed for \"--size\". Usage: mem-read [ --size=<bytes> ] <address-expression>",
err.msg());
// Valid short switch with value following.
err = ParseCommand("mem-read -s 567 next", &output);
EXPECT_FALSE(err.has_error());
EXPECT_EQ(1u, output.switches().size());
EXPECT_EQ("567", output.GetSwitchValue(size_switch->id));
ASSERT_EQ(1u, output.args().size());
EXPECT_EQ("next", output.args()[0]);
// Valid short switch with value concatenated.
err = ParseCommand("mem-read -s567 next", &output);
EXPECT_FALSE(err.has_error());
EXPECT_EQ(1u, output.switches().size());
EXPECT_EQ("567", output.GetSwitchValue(size_switch->id));
ASSERT_EQ(1u, output.args().size());
EXPECT_EQ("next", output.args()[0]);
// Short switch with quoted value.
err = ParseCommand("mem-read -s\"56 7\" next", &output);
EXPECT_FALSE(err.has_error());
EXPECT_EQ(1u, output.switches().size());
EXPECT_EQ("56 7", output.GetSwitchValue(size_switch->id));
ASSERT_EQ(1u, output.args().size());
EXPECT_EQ("next", output.args()[0]);
// Expects a value for a short switch.
err = ParseCommand("mem-read -s", &output);
EXPECT_TRUE(err.has_error());
EXPECT_EQ("Argument needed for \"-s\". Usage: mem-read [ --size=<bytes> ] <address-expression>",
err.msg());
// Repeating a non-multi-value switch overwrites the previous value, and an inline switch value
// ("--size=123") does not bleed into a subsequent short switch ("-s 456").
err = ParseCommand("mem-read --size=123 -s 456 next", &output);
EXPECT_FALSE(err.has_error()) << err.msg();
EXPECT_EQ(1u, output.switches().size());
EXPECT_EQ("456", output.GetSwitchValue(size_switch->id));
ASSERT_EQ(1u, output.GetSwitchValues(size_switch->id).size());
EXPECT_EQ("456", output.GetSwitchValues(size_switch->id)[0]);
ASSERT_EQ(1u, output.args().size());
EXPECT_EQ("next", output.args()[0]);
// Multi-value switch accumulation and CommandReport generation on Command.
output.AddSwitch(size_switch->id, "789");
EXPECT_EQ("789", output.GetSwitchValue(size_switch->id));
std::span<const std::string> size_values = output.GetSwitchValues(size_switch->id);
ASSERT_EQ(2u, size_values.size());
EXPECT_EQ("456", size_values[0]);
EXPECT_EQ("789", size_values[1]);
CommandReport report = output.BuildReport();
ASSERT_EQ(2u, report.switches.size());
EXPECT_EQ("456", report.switches[0].value);
EXPECT_EQ("789", report.switches[1].value);
}
// Some verbs take all arguments as one large string, ignoring whitespace. "print" is one of these.
TEST(CommandParser, OneParam) {
Command output;
Err err = ParseCommand("print x + 2 ", &output);
EXPECT_FALSE(err.has_error());
EXPECT_EQ(Verb::kPrint, output.verb());
ASSERT_EQ(1u, output.args().size());
// The whitespace at the end is not trimmed. This could possibly be changed in the future.
EXPECT_EQ("x + 2 ", output.args()[0]);
err = ParseCommand("opendump path/has a/space/mini.dmp", &output);
EXPECT_FALSE(err.has_error());
EXPECT_EQ(Verb::kOpenDump, output.verb());
ASSERT_EQ(1u, output.args().size());
// Even unquoted, the path is consumed as a single string.
EXPECT_EQ("path/has a/space/mini.dmp", output.args()[0]);
err = ParseCommand("opendump \"path/has a/space/mini.dmp\"", &output);
EXPECT_FALSE(err.has_error());
EXPECT_EQ(Verb::kOpenDump, output.verb());
ASSERT_EQ(1u, output.args().size());
// A quoted path should continue to work regardless of the OneParam setting.
EXPECT_EQ("\"path/has a/space/mini.dmp\"", output.args()[0]);
}
TEST(CommandParser, MultiValueSwitches) {
static_assert(!std::is_constructible_v<SwitchRecord, int, bool, const char*, bool>);
static_assert(std::is_constructible_v<SwitchRecord, int, bool, const char*, char>);
static_assert(std::is_constructible_v<SwitchRecord, int, bool, const char*>);
constexpr int kSingleSwitch = 1;
constexpr int kExprSwitch = 2;
constexpr int kTagSwitch = 3;
constexpr int kUnsetSwitch = 99;
VerbRecord test_verb(nullptr, {"test-verb"}, "Short help",
"test-verb [ -s <val> ] [ -e <expr> ... ] [ --tag=<tag> ... ] <arg>", "Help",
CommandGroup::kGeneral);
test_verb.switches.emplace_back(kSingleSwitch, true, "single", 's');
test_verb.switches.push_back(SwitchRecord::MultiValue(kExprSwitch, "expr", 'e'));
test_verb.switches.push_back(SwitchRecord::MultiValue(kTagSwitch, "tag"));
EXPECT_EQ(0, test_verb.switches[2].ch);
EXPECT_TRUE(test_verb.switches[2].has_value);
EXPECT_TRUE(test_verb.switches[2].multi_value);
std::map<Verb, VerbRecord> verbs;
verbs.emplace(Verb::kPrint, std::move(test_verb));
Command output;
Err err = ParseCommandForTest(
"test-verb --expr=first -s old -e second -ethird --single=new --expr fourth "
"--tag=alpha --tag beta MyArg",
verbs, &output);
ASSERT_FALSE(err.has_error()) << err.msg();
EXPECT_EQ("new", output.GetSwitchValue(kSingleSwitch));
std::span<const std::string> single_values = output.GetSwitchValues(kSingleSwitch);
ASSERT_EQ(1u, single_values.size());
EXPECT_EQ("new", single_values[0]);
EXPECT_EQ("fourth", output.GetSwitchValue(kExprSwitch));
std::span<const std::string> expr_values = output.GetSwitchValues(kExprSwitch);
ASSERT_EQ(4u, expr_values.size());
EXPECT_EQ("first", expr_values[0]);
EXPECT_EQ("second", expr_values[1]);
EXPECT_EQ("third", expr_values[2]);
EXPECT_EQ("fourth", expr_values[3]);
EXPECT_EQ("beta", output.GetSwitchValue(kTagSwitch));
std::span<const std::string> tag_values = output.GetSwitchValues(kTagSwitch);
ASSERT_EQ(2u, tag_values.size());
EXPECT_EQ("alpha", tag_values[0]);
EXPECT_EQ("beta", tag_values[1]);
EXPECT_TRUE(output.GetSwitchValues(kUnsetSwitch).empty());
ASSERT_EQ(1u, output.args().size());
EXPECT_EQ("MyArg", output.args()[0]);
// Long-only multi-value switch does not register a short character.
err = ParseCommandForTest("test-verb -t foo", verbs, &output);
EXPECT_TRUE(err.has_error());
// Multi-value switches require an argument on each occurrence.
err = ParseCommandForTest("test-verb -e first -e", verbs, &output);
EXPECT_TRUE(err.has_error());
EXPECT_EQ(
"Argument needed for \"-e\". Usage: "
"test-verb [ -s <val> ] [ -e <expr> ... ] [ --tag=<tag> ... ] <arg>",
err.msg());
}
TEST(CommandParser, Completions) {
std::vector<std::string> comp;
// Noun completion.
comp = GetCommandCompletions("t", FillCommandContextCallback());
EXPECT_TRUE(CompletionContains(comp, "thread"));
// Verb completion.
comp = GetCommandCompletions("h", FillCommandContextCallback());
EXPECT_TRUE(CompletionContains(comp, "help"));
// Noun + Verb completion.
comp = GetCommandCompletions("process 2 p", FillCommandContextCallback());
EXPECT_TRUE(CompletionContains(comp, "process 2 pause"));
// Ending in a space gives everything.
comp = GetCommandCompletions("process ", FillCommandContextCallback());
EXPECT_TRUE(CompletionContains(comp, "process quit"));
EXPECT_TRUE(CompletionContains(comp, "process pause"));
// No input should give everything
comp = GetCommandCompletions("", FillCommandContextCallback());
EXPECT_TRUE(CompletionContains(comp, "pause"));
EXPECT_TRUE(CompletionContains(comp, "quit"));
// Verb with no argument prefix
comp = GetCommandCompletions("set ", FillCommandContextCallback());
EXPECT_TRUE(CompletionContains(comp, "set source-map"));
EXPECT_TRUE(CompletionContains(comp, "set language"));
// Verb with argument prefix
comp = GetCommandCompletions("set lan", FillCommandContextCallback());
EXPECT_TRUE(CompletionContains(comp, "set language"));
EXPECT_EQ(1u, comp.size());
}
} // namespace
} // namespace zxdb