1 //===-- OptionsWithRawTest.cpp ----------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "gtest/gtest.h"
11 
12 #include "lldb/Utility/Args.h"
13 #include "lldb/Utility/StringList.h"
14 
15 using namespace lldb_private;
16 
17 TEST(OptionsWithRawTest, EmptyInput) {
18   // An empty string is just an empty suffix without any arguments.
19   OptionsWithRaw args("");
20   ASSERT_FALSE(args.HasArgs());
21   ASSERT_STREQ(args.GetRawPart().c_str(), "");
22 }
23 
24 TEST(OptionsWithRawTest, SingleWhitespaceInput) {
25   // Only whitespace is just a suffix.
26   OptionsWithRaw args(" ");
27   ASSERT_FALSE(args.HasArgs());
28   ASSERT_STREQ(args.GetRawPart().c_str(), " ");
29 }
30 
31 TEST(OptionsWithRawTest, WhitespaceInput) {
32   // Only whitespace is just a suffix.
33   OptionsWithRaw args("  ");
34   ASSERT_FALSE(args.HasArgs());
35   ASSERT_STREQ(args.GetRawPart().c_str(), "  ");
36 }
37 
38 TEST(OptionsWithRawTest, ArgsButNoDelimiter) {
39   // This counts as a suffix because there is no -- at the end.
40   OptionsWithRaw args("-foo bar");
41   ASSERT_FALSE(args.HasArgs());
42   ASSERT_STREQ(args.GetRawPart().c_str(), "-foo bar");
43 }
44 
45 TEST(OptionsWithRawTest, ArgsButNoLeadingDash) {
46   // No leading dash means we have no arguments.
47   OptionsWithRaw args("foo bar --");
48   ASSERT_FALSE(args.HasArgs());
49   ASSERT_STREQ(args.GetRawPart().c_str(), "foo bar --");
50 }
51 
52 TEST(OptionsWithRawTest, QuotedSuffix) {
53   // We need to have a way to escape the -- to make it usable as an argument.
54   OptionsWithRaw args("-foo \"--\" bar");
55   ASSERT_FALSE(args.HasArgs());
56   ASSERT_STREQ(args.GetRawPart().c_str(), "-foo \"--\" bar");
57 }
58 
59 TEST(OptionsWithRawTest, EmptySuffix) {
60   // An empty suffix with arguments.
61   OptionsWithRaw args("-foo --");
62   ASSERT_TRUE(args.HasArgs());
63   ASSERT_EQ(args.GetArgString(), "-foo ");
64   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-foo --");
65 
66   auto ref = args.GetArgs().GetArgumentArrayRef();
67   ASSERT_EQ(1u, ref.size());
68   EXPECT_STREQ("-foo", ref[0]);
69 
70   ASSERT_STREQ(args.GetRawPart().c_str(), "");
71 }
72 
73 TEST(OptionsWithRawTest, EmptySuffixSingleWhitespace) {
74   // A single whitespace also countas as an empty suffix (because that usually
75   // separates the suffix from the double dash.
76   OptionsWithRaw args("-foo -- ");
77   ASSERT_TRUE(args.HasArgs());
78   ASSERT_EQ(args.GetArgString(), "-foo ");
79   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-foo -- ");
80 
81   auto ref = args.GetArgs().GetArgumentArrayRef();
82   ASSERT_EQ(1u, ref.size());
83   EXPECT_STREQ("-foo", ref[0]);
84 
85   ASSERT_STREQ(args.GetRawPart().c_str(), "");
86 }
87 
88 TEST(OptionsWithRawTest, WhitespaceSuffix) {
89   // A single whtiespace character as a suffix.
90   OptionsWithRaw args("-foo --  ");
91   ASSERT_TRUE(args.HasArgs());
92   ASSERT_EQ(args.GetArgString(), "-foo ");
93   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-foo -- ");
94 
95   auto ref = args.GetArgs().GetArgumentArrayRef();
96   ASSERT_EQ(1u, ref.size());
97   EXPECT_STREQ("-foo", ref[0]);
98 
99   ASSERT_STREQ(args.GetRawPart().c_str(), " ");
100 }
101 
102 TEST(OptionsWithRawTest, LeadingSpaceArgs) {
103   // Whitespace before the first dash needs to be ignored.
104   OptionsWithRaw args(" -foo -- bar");
105   ASSERT_TRUE(args.HasArgs());
106   ASSERT_EQ(args.GetArgString(), " -foo ");
107   ASSERT_EQ(args.GetArgStringWithDelimiter(), " -foo -- ");
108 
109   auto ref = args.GetArgs().GetArgumentArrayRef();
110   ASSERT_EQ(1u, ref.size());
111   EXPECT_STREQ("-foo", ref[0]);
112 
113   ASSERT_STREQ(args.GetRawPart().c_str(), "bar");
114 }
115 
116 TEST(OptionsWithRawTest, SingleWordSuffix) {
117   // A single word as a suffix.
118   OptionsWithRaw args("-foo -- bar");
119   ASSERT_TRUE(args.HasArgs());
120   ASSERT_EQ(args.GetArgString(), "-foo ");
121   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-foo -- ");
122 
123   auto ref = args.GetArgs().GetArgumentArrayRef();
124   ASSERT_EQ(1u, ref.size());
125   EXPECT_STREQ("-foo", ref[0]);
126 
127   ASSERT_STREQ(args.GetRawPart().c_str(), "bar");
128 }
129 
130 TEST(OptionsWithRawTest, MultiWordSuffix) {
131   // Multiple words as a suffix.
132   OptionsWithRaw args("-foo -- bar baz");
133   ASSERT_TRUE(args.HasArgs());
134   ASSERT_EQ(args.GetArgString(), "-foo ");
135   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-foo -- ");
136 
137   auto ref = args.GetArgs().GetArgumentArrayRef();
138   ASSERT_EQ(1u, ref.size());
139   EXPECT_STREQ("-foo", ref[0]);
140 
141   ASSERT_STREQ(args.GetRawPart().c_str(), "bar baz");
142 }
143 
144 TEST(OptionsWithRawTest, UnterminatedQuote) {
145   // A quote character in the suffix shouldn't influence the parsing.
146   OptionsWithRaw args("-foo -- bar \" ");
147   ASSERT_TRUE(args.HasArgs());
148   ASSERT_EQ(args.GetArgString(), "-foo ");
149   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-foo -- ");
150 
151   auto ref = args.GetArgs().GetArgumentArrayRef();
152   ASSERT_EQ(1u, ref.size());
153   EXPECT_STREQ("-foo", ref[0]);
154 
155   ASSERT_STREQ(args.GetRawPart().c_str(), "bar \" ");
156 }
157 
158 TEST(OptionsWithRawTest, TerminatedQuote) {
159   // A part of the suffix is quoted, which shouldn't influence the parsing.
160   OptionsWithRaw args("-foo -- bar \"a\" ");
161   ASSERT_TRUE(args.HasArgs());
162   ASSERT_EQ(args.GetArgString(), "-foo ");
163   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-foo -- ");
164 
165   auto ref = args.GetArgs().GetArgumentArrayRef();
166   ASSERT_EQ(1u, ref.size());
167   EXPECT_STREQ("-foo", ref[0]);
168 
169   ASSERT_STREQ(args.GetRawPart().c_str(), "bar \"a\" ");
170 }
171 
172 TEST(OptionsWithRawTest, EmptyArgsOnlySuffix) {
173   // Empty argument list, but we have a suffix.
174   OptionsWithRaw args("-- bar");
175   ASSERT_TRUE(args.HasArgs());
176   ASSERT_EQ(args.GetArgString(), "");
177   ASSERT_EQ(args.GetArgStringWithDelimiter(), "-- ");
178 
179   auto ref = args.GetArgs().GetArgumentArrayRef();
180   ASSERT_EQ(0u, ref.size());
181 
182   ASSERT_STREQ(args.GetRawPart().c_str(), "bar");
183 }
184