gergely/taskwarrior-2.x
1
0
Fork 0
Code Issues Actions Packages Projects Releases 1 Wiki Activity

Expressions

Browse Source 
- Improved strictness of attr and attmod detection, although it needs
  more.
- Added unit tests arguments.t.cpp, to test the detection methods.
This commit is contained in:
Paul Beckingham
2011-06-08 00:16:19 -04:00
parent 390ffb65f9
commit 199bb85d88
6 changed files with 270 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

169
test/arguments.t.cpp
View File

@@ -34,7 +34,7 @@ Context context;
////////////////////////////////////////////////////////////////////////////////
int main (int argc, char** argv)
{
UnitTest t (14);
UnitTest t (109);
const char* fake[] =
{
@@ -57,45 +57,164 @@ int main (int argc, char** argv)
// void capture (int, char**);
Arguments a1;
a1.capture (12, &fake[0]);
t.is (a1.size (), (size_t)11, "11 arguments expected");
t.is (a1[0], "list", "Arguments properly strips argv[0]");
t.is (a1.size (), (size_t)12, "12 arguments expected");
// std::string combine ();
t.is (a1.combine (),
"list proj:foo 1,3,5-10 12 pattern1 rc.name1=value1 rc.name2:value2 "
"task list proj:foo 1,3,5-10 12 pattern1 rc.name1=value1 rc.name2:value2 "
"234 -- pattern2 n:v",
"combine good");
// TODO void append_stdin ();
// TODO void rc_override (std::string&, File&, std::string&);
// TODO void get_data_location (std::string&);
// TODO void apply_overrides (std::string&);
// TODO void resolve_aliases ();
// TODO bool extract_command (const std::vector <std::string>&, std::string&);
// bool is_attr (const std::string&);
t.ok (Arguments::is_attr ("name:"), "name: -> attr");
t.ok (Arguments::is_attr ("name:\"\""), "name:\"\" -> attr");
t.ok (Arguments::is_attr ("name:one"), "name:one -> attr");
t.ok (Arguments::is_attr ("name:\"one\""), "name:\"one\" -> attr");
t.ok (Arguments::is_attr ("name:\"one two\""), "name:\"one two\" -> attr");
// void extract_sequence (std::vector <int>&);
std::vector <int> sequence;
a1.extract_sequence (sequence);
size_t s = sequence.size ();
t.is (s, (size_t)9, "1,3,5-10 12 --> 1,3,5,6,7,8,9,10,12 == 9");
t.ok (Arguments::is_attr ("name="), "name= -> attr");
t.ok (Arguments::is_attr ("name=\"\""), "name=\"\" -> attr");
t.ok (Arguments::is_attr ("name=one"), "name=one -> attr");
t.ok (Arguments::is_attr ("name=\"one\""), "name=\"one\" -> attr");
t.ok (Arguments::is_attr ("name=\"one two\""), "name=\"one two\" -> attr");
if (s > 0) t.is (sequence[0], 1, "sequence 1"); else t.fail ("sequence 1");
if (s > 1) t.is (sequence[1], 3, "sequence 3"); else t.fail ("sequence 3");
if (s > 2) t.is (sequence[2], 5, "sequence 5"); else t.fail ("sequence 5");
if (s > 3) t.is (sequence[3], 6, "sequence 6"); else t.fail ("sequence 6");
if (s > 4) t.is (sequence[4], 7, "sequence 7"); else t.fail ("sequence 7");
if (s > 5) t.is (sequence[5], 8, "sequence 8"); else t.fail ("sequence 8");
if (s > 6) t.is (sequence[6], 9, "sequence 9"); else t.fail ("sequence 9");
if (s > 7) t.is (sequence[7], 10, "sequence 10"); else t.fail ("sequence 10");
if (s > 8) t.is (sequence[8], 12, "sequence 12"); else t.fail ("sequence 12");
// bool is_attmod (const std::string&);
t.ok (Arguments::is_attmod ("name.is:"), "name.is: -> attr");
t.ok (Arguments::is_attmod ("name.is:\"\""), "name.is:\"\" -> attr");
t.ok (Arguments::is_attmod ("name.is:one"), "name.is:one -> attr");
t.ok (Arguments::is_attmod ("name.is:\"one\""), "name.is:\"one\" -> attr");
t.ok (Arguments::is_attmod ("name.is:\"one two\""), "name.is:\"one two\" -> attr");
t.is (a1.size (), (size_t)9, "a1 - <sequence> = 9 args");
t.ok (Arguments::is_attmod ("name.is="), "name.is= -> attr");
t.ok (Arguments::is_attmod ("name.is=\"\""), "name.is=\"\" -> attr");
t.ok (Arguments::is_attmod ("name.is=one"), "name.is=one -> attr");
t.ok (Arguments::is_attmod ("name.is=\"one\""), "name.is=\"one\" -> attr");
t.ok (Arguments::is_attmod ("name.is=\"one two\""), "name.is=\"one two\" -> attr");
// bool is_subst (const std::string&);
t.notok (Arguments::is_subst ("///"), "/// -> not subst");
t.notok (Arguments::is_subst ("//to/"), "//to/ -> not subst");
t.ok (Arguments::is_subst ("/from//"), "/from// -> subst");
t.ok (Arguments::is_subst ("/from/to/"), "/from/to/ -> subst");
t.ok (Arguments::is_subst ("/from from/to to/"), "/from from/to to/ -> subst");
t.notok (Arguments::is_subst ("///g"), "///g -> not subst");
t.notok (Arguments::is_subst ("//to/g"), "//to/g -> not subst");
t.ok (Arguments::is_subst ("/from//g"), "/from//g -> subst");
t.ok (Arguments::is_subst ("/from/to/g"), "/from/to/g -> subst");
t.ok (Arguments::is_subst ("/from from/to to/g"), "/from from/to to/g -> subst");
// bool is_pattern (const std::string&);
t.notok (Arguments::is_pattern ("//"), "// -> not pattern");
t.notok (Arguments::is_pattern ("///"), "/// -> not pattern");
t.ok (Arguments::is_pattern ("/one/"), "/one/ -> pattern");
t.ok (Arguments::is_pattern ("/one two/"), "/one two/ -> pattern");
t.ok (Arguments::is_pattern ("/ /"), "/ / -> pattern");
// bool is_id (const std::string&);
t.ok (Arguments::is_id ("1"), "1 -> id");
t.ok (Arguments::is_id ("1,2"), "1,2 -> id");
t.ok (Arguments::is_id ("1-2"), "1-2 -> id");
t.ok (Arguments::is_id ("1,2,3"), "1,2,3 -> id");
t.ok (Arguments::is_id ("1-2,3,4-5"), "1-2,3,4-5 -> id");
t.notok (Arguments::is_id ("1-2-3"), "1-2-3 -> no id");
// bool is_uuid (const std::string&);
t.ok (Arguments::is_uuid ("00000000-0000-0000-0000-000000000000"),
"00000000-0000-0000-0000-000000000000 -> uuid");
t.ok (Arguments::is_uuid ("eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee,ffffffff-ffff-ffff-ffff-ffffffffffff"),
"eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee,ffffffff-ffff-ffff-ffff-ffffffffffff -> uuid");
// bool is_tag (const std::string&);
t.ok (Arguments::is_tag ("+one"), "+one -> tag");
t.ok (Arguments::is_tag ("-one"), "-one -> tag");
t.notok (Arguments::is_tag ("+one "), "+one -> not tag");
t.notok (Arguments::is_tag ("-one "), "-one -> not tag");
t.notok (Arguments::is_tag ("+"), "+ -> not tag");
t.notok (Arguments::is_tag ("-"), "- -> not tag");
t.notok (Arguments::is_tag ("++"), "++ -> not tag");
t.notok (Arguments::is_tag ("--"), "-- -> not tag");
t.notok (Arguments::is_tag ("+one two"), "+one two -> not tag");
// bool is_operator (const std::string&);
t.ok (Arguments::is_operator ("^"), "^ -> operator");
t.ok (Arguments::is_operator ("!"), "! -> operator");
t.ok (Arguments::is_operator ("not"), "not -> operator");
t.ok (Arguments::is_operator ("-"), "- -> operator");
t.ok (Arguments::is_operator ("*"), "* -> operator");
t.ok (Arguments::is_operator ("/"), "/ -> operator");
t.ok (Arguments::is_operator ("%"), "% -> operator");
t.ok (Arguments::is_operator ("+"), "+ -> operator");
t.ok (Arguments::is_operator ("-"), "- -> operator");
t.ok (Arguments::is_operator ("<"), "< -> operator");
t.ok (Arguments::is_operator ("lt"), "lt -> operator");
t.ok (Arguments::is_operator ("<="), "<= -> operator");
t.ok (Arguments::is_operator ("le"), "le -> operator");
t.ok (Arguments::is_operator (">="), ">= -> operator");
t.ok (Arguments::is_operator ("ge"), "ge -> operator");
t.ok (Arguments::is_operator (">"), "> -> operator");
t.ok (Arguments::is_operator ("gt"), "gt -> operator");
t.ok (Arguments::is_operator ("~"), "~ -> operator");
t.ok (Arguments::is_operator ("!~"), "!~ -> operator");
t.ok (Arguments::is_operator ("="), "= -> operator");
t.ok (Arguments::is_operator ("eq"), "eq -> operator");
t.ok (Arguments::is_operator ("!="), "!= -> operator");
t.ok (Arguments::is_operator ("ne"), "ne -> operator");
t.ok (Arguments::is_operator ("and"), "and -> operator");
t.ok (Arguments::is_operator ("or"), "or -> operator");
t.ok (Arguments::is_operator ("("), "( -> operator");
t.ok (Arguments::is_operator (")"), ") -> operator");
t.notok (Arguments::is_operator ("$"), "$ -> not operator");
// bool is_expression (const std::string&);
t.notok (Arguments::is_expression ("foo"), "foo -> expression");
t.ok (Arguments::is_expression ("1+1"), "1+1 -> expression");
t.ok (Arguments::is_expression ("a~b"), "a~b -> expression");
t.ok (Arguments::is_expression ("(1)"), "(1) -> expression");
t.ok (Arguments::is_expression ("not a"), "not a -> expression");
// static bool valid_modifier (const std::string&);
t.ok (Arguments::valid_modifier ("before"), "before -> modifier");
t.ok (Arguments::valid_modifier ("under"), "under -> modifier");
t.ok (Arguments::valid_modifier ("below"), "below -> modifier");
t.ok (Arguments::valid_modifier ("after"), "after -> modifier");
t.ok (Arguments::valid_modifier ("over"), "over -> modifier");
t.ok (Arguments::valid_modifier ("above"), "above -> modifier");
t.ok (Arguments::valid_modifier ("none"), "none -> modifier");
t.ok (Arguments::valid_modifier ("any"), "any -> modifier");
t.ok (Arguments::valid_modifier ("is"), "is -> modifier");
t.ok (Arguments::valid_modifier ("equals"), "equals -> modifier");
t.ok (Arguments::valid_modifier ("isnt"), "isnt -> modifier");
t.ok (Arguments::valid_modifier ("not"), "not -> modifier");
t.ok (Arguments::valid_modifier ("has"), "has -> modifier");
t.ok (Arguments::valid_modifier ("contains"), "contains -> modifier");
t.ok (Arguments::valid_modifier ("hasnt"), "hasnt -> modifier");
t.ok (Arguments::valid_modifier ("startswith"), "startswith -> modifier");
t.ok (Arguments::valid_modifier ("left"), "left -> modifier");
t.ok (Arguments::valid_modifier ("endswith"), "endswith -> modifier");
t.ok (Arguments::valid_modifier ("right"), "right -> modifier");
t.ok (Arguments::valid_modifier ("word"), "word -> modifier");
t.ok (Arguments::valid_modifier ("noword"), "noword -> modifier");
t.notok (Arguments::valid_modifier ("duck"), "duck -> not modified");
// TODO void extract_uuids (std::vector <std::string>&);
// TODO void extract_filter ();
// TODO void extract_modifications ();
// TODO void extract_text ();
// TODO bool extract_attr (const std::string&, std::string&, std::string&);
// TODO bool extract_attmod (const std::string&, std::string&, std::string&, std::string&, std::string&);
// TODO bool extract_subst (const std::string&, std::string&, std::string&, bool&);
// TODO bool extract_pattern (const std::string&, std::string&);
// TODO bool extract_id (const std::string&, std::vector <int>&);
// TODO bool extract_uuid (const std::string&, std::vector <std::string>&);
// TODO bool extract_tag (const std::string&, char&, std::string&);
// TODO bool extract_operator (const std::string&, std::string&);
// TODO Arguments extract_read_only_filter ();
// TODO Arguments extract_write_filter ();
// TODO Arguments extract_modifications ();
return 0;
}