Nothing
#####################
context('doc01')
doc <-
'Usage: prog'
test_that('parsing "" works',{
#$ prog
#{}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 0)
expect_equivalent(res[NULL], list())
})
test_that('parsing "--xxx" works',{
#$ prog --xxx
#"user-error"
expect_error(docopt(doc, '--xxx', strict=TRUE))
})
#####################
context('doc02')
doc <-
'Usage: prog [options]
Options: -a All.'
test_that('parsing "" works',{
#$ prog
#{"-a": false}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-a"], list("-a" = FALSE))
})
test_that('parsing "-a" works',{
#$ prog -a
#{"-a": true}
res <- docopt(doc, '-a', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-a"], list("-a" = TRUE))
})
test_that('parsing "-x" works',{
#$ prog -x
#"user-error"
expect_error(docopt(doc, '-x', strict=TRUE))
})
#####################
context('doc03')
doc <-
'Usage: prog [options]
Options: --all All.'
test_that('parsing "" works',{
#$ prog
#{"--all": false}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--all"], list("--all" = FALSE))
})
test_that('parsing "--all" works',{
#$ prog --all
#{"--all": true}
res <- docopt(doc, '--all', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--all"], list("--all" = TRUE))
})
test_that('parsing "--xxx" works',{
#$ prog --xxx
#"user-error"
expect_error(docopt(doc, '--xxx', strict=TRUE))
})
#####################
context('doc04')
doc <-
'Usage: prog [options]
Options: -v, --verbose Verbose.'
test_that('parsing "--verbose" works',{
#$ prog --verbose
#{"--verbose": true}
res <- docopt(doc, '--verbose', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--verbose"], list("--verbose" = TRUE))
})
test_that('parsing "--ver" works',{
#$ prog --ver
#{"--verbose": true}
res <- docopt(doc, '--ver', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--verbose"], list("--verbose" = TRUE))
})
test_that('parsing "-v" works',{
#$ prog -v
#{"--verbose": true}
res <- docopt(doc, '-v', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--verbose"], list("--verbose" = TRUE))
})
#####################
context('doc05')
doc <-
'Usage: prog [options]
Options: -p PATH'
test_that('parsing "-p home/" works',{
#$ prog -p home/
#{"-p": "home/"}
res <- docopt(doc, '-p home/', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-p"], list("-p" = "home/"))
})
test_that('parsing "-phome/" works',{
#$ prog -phome/
#{"-p": "home/"}
res <- docopt(doc, '-phome/', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-p"], list("-p" = "home/"))
})
test_that('parsing "-p" works',{
#$ prog -p
#"user-error"
expect_error(docopt(doc, '-p', strict=TRUE))
})
#####################
context('doc06')
doc <-
'Usage: prog [options]
Options: --path <path>'
test_that('parsing "--path home/" works',{
#$ prog --path home/
#{"--path": "home/"}
res <- docopt(doc, '--path home/', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--path"], list("--path" = "home/"))
})
test_that('parsing "--path=home/" works',{
#$ prog --path=home/
#{"--path": "home/"}
res <- docopt(doc, '--path=home/', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--path"], list("--path" = "home/"))
})
test_that('parsing "--pa home/" works',{
#$ prog --pa home/
#{"--path": "home/"}
res <- docopt(doc, '--pa home/', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--path"], list("--path" = "home/"))
})
test_that('parsing "--pa=home/" works',{
#$ prog --pa=home/
#{"--path": "home/"}
res <- docopt(doc, '--pa=home/', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--path"], list("--path" = "home/"))
})
test_that('parsing "--path" works',{
#$ prog --path
#"user-error"
expect_error(docopt(doc, '--path', strict=TRUE))
})
#####################
context('doc07')
doc <-
'Usage: prog [options]
Options: -p PATH, --path=<path> Path to files.'
test_that('parsing "-proot" works',{
#$ prog -proot
#{"--path": "root"}
res <- docopt(doc, '-proot', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--path"], list("--path" = "root"))
})
#####################
context('doc08')
doc <-
'Usage: prog [options]
Options: -p --path PATH Path to files.'
test_that('parsing "-p root" works',{
#$ prog -p root
#{"--path": "root"}
res <- docopt(doc, '-p root', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--path"], list("--path" = "root"))
})
test_that('parsing "--path root" works',{
#$ prog --path root
#{"--path": "root"}
res <- docopt(doc, '--path root', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--path"], list("--path" = "root"))
})
#####################
context('doc09')
doc <-
'Usage: prog [options]
Options:
-p PATH Path to files [default: ./]'
test_that('parsing "" works',{
#$ prog
#{"-p": "./"}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-p"], list("-p" = "./"))
})
test_that('parsing "-phome" works',{
#$ prog -phome
#{"-p": "home"}
res <- docopt(doc, '-phome', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-p"], list("-p" = "home"))
})
#####################
context('doc10')
doc <-
'UsAgE: prog [options]
OpTiOnS: --path=<files> Path to files
[dEfAuLt: /root]'
test_that('parsing "" works',{
#$ prog
#{"--path": "/root"}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--path"], list("--path" = "/root"))
})
test_that('parsing "--path=home" works',{
#$ prog --path=home
#{"--path": "home"}
res <- docopt(doc, '--path=home', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--path"], list("--path" = "home"))
})
#####################
context('doc11')
doc <-
'usage: prog [options]
options:
-a Add
-r Remote
-m <msg> Message'
test_that('parsing "-a -r -m Hello" works',{
#$ prog -a -r -m Hello
#{"-a": true, "-r": true, "-m": "Hello"}
res <- docopt(doc, '-a -r -m Hello', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("-a", "-r", "-m")], list("-a" = TRUE, "-r" = TRUE, "-m" = "Hello"))
})
test_that('parsing "-armyourass" works',{
#$ prog -armyourass
#{"-a": true, "-r": true, "-m": "yourass"}
res <- docopt(doc, '-armyourass', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("-a", "-r", "-m")], list("-a" = TRUE, "-r" = TRUE, "-m" = "yourass"))
})
test_that('parsing "-a -r" works',{
#$ prog -a -r
#{"-a": true, "-r": true, "-m": null}
res <- docopt(doc, '-a -r', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("-a", "-r", "-m")], list("-a" = TRUE, "-r" = TRUE, "-m" = NULL))
})
#####################
context('doc12')
doc <-
'Usage: prog [options]
Options: --version
--verbose'
test_that('parsing "--version" works',{
#$ prog --version
#{"--version": true, "--verbose": false}
res <- docopt(doc, '--version', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("--version", "--verbose")], list("--version" = TRUE, "--verbose" = FALSE))
})
test_that('parsing "--verbose" works',{
#$ prog --verbose
#{"--version": false, "--verbose": true}
res <- docopt(doc, '--verbose', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("--version", "--verbose")], list("--version" = FALSE, "--verbose" = TRUE))
})
test_that('parsing "--ver" works',{
#$ prog --ver
#"user-error"
expect_error(docopt(doc, '--ver', strict=TRUE))
})
test_that('parsing "--verb" works',{
#$ prog --verb
#{"--version": false, "--verbose": true}
res <- docopt(doc, '--verb', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("--version", "--verbose")], list("--version" = FALSE, "--verbose" = TRUE))
})
#####################
context('doc13')
doc <-
'usage: prog [-a -r -m <msg>]
options:
-a Add
-r Remote
-m <msg> Message'
test_that('parsing "-armyourass" works',{
#$ prog -armyourass
#{"-a": true, "-r": true, "-m": "yourass"}
res <- docopt(doc, '-armyourass', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("-a", "-r", "-m")], list("-a" = TRUE, "-r" = TRUE, "-m" = "yourass"))
})
#####################
context('doc14')
doc <-
'usage: prog [-armmsg]
options: -a Add
-r Remote
-m <msg> Message'
test_that('parsing "-a -r -m Hello" works',{
#$ prog -a -r -m Hello
#{"-a": true, "-r": true, "-m": "Hello"}
res <- docopt(doc, '-a -r -m Hello', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("-a", "-r", "-m")], list("-a" = TRUE, "-r" = TRUE, "-m" = "Hello"))
})
#####################
context('doc15')
doc <-
'usage: prog -a -b
options:
-a
-b'
test_that('parsing "-a -b" works',{
#$ prog -a -b
#{"-a": true, "-b": true}
res <- docopt(doc, '-a -b', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = TRUE, "-b" = TRUE))
})
test_that('parsing "-b -a" works',{
#$ prog -b -a
#{"-a": true, "-b": true}
res <- docopt(doc, '-b -a', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = TRUE, "-b" = TRUE))
})
test_that('parsing "-a" works',{
#$ prog -a
#"user-error"
expect_error(docopt(doc, '-a', strict=TRUE))
})
test_that('parsing "" works',{
#$ prog
#"user-error"
expect_error(docopt(doc, '', strict=TRUE))
})
#####################
context('doc16')
doc <-
'usage: prog (-a -b)
options: -a
-b'
test_that('parsing "-a -b" works',{
#$ prog -a -b
#{"-a": true, "-b": true}
res <- docopt(doc, '-a -b', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = TRUE, "-b" = TRUE))
})
test_that('parsing "-b -a" works',{
#$ prog -b -a
#{"-a": true, "-b": true}
res <- docopt(doc, '-b -a', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = TRUE, "-b" = TRUE))
})
test_that('parsing "-a" works',{
#$ prog -a
#"user-error"
expect_error(docopt(doc, '-a', strict=TRUE))
})
test_that('parsing "" works',{
#$ prog
#"user-error"
expect_error(docopt(doc, '', strict=TRUE))
})
#####################
context('doc17')
doc <-
'usage: prog [-a] -b
options: -a
-b'
test_that('parsing "-a -b" works',{
#$ prog -a -b
#{"-a": true, "-b": true}
res <- docopt(doc, '-a -b', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = TRUE, "-b" = TRUE))
})
test_that('parsing "-b -a" works',{
#$ prog -b -a
#{"-a": true, "-b": true}
res <- docopt(doc, '-b -a', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = TRUE, "-b" = TRUE))
})
test_that('parsing "-a" works',{
#$ prog -a
#"user-error"
expect_error(docopt(doc, '-a', strict=TRUE))
})
test_that('parsing "-b" works',{
#$ prog -b
#{"-a": false, "-b": true}
res <- docopt(doc, '-b', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = FALSE, "-b" = TRUE))
})
test_that('parsing "" works',{
#$ prog
#"user-error"
expect_error(docopt(doc, '', strict=TRUE))
})
#####################
context('doc18')
doc <-
'usage: prog [(-a -b)]
options: -a
-b'
test_that('parsing "-a -b" works',{
#$ prog -a -b
#{"-a": true, "-b": true}
res <- docopt(doc, '-a -b', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = TRUE, "-b" = TRUE))
})
test_that('parsing "-b -a" works',{
#$ prog -b -a
#{"-a": true, "-b": true}
res <- docopt(doc, '-b -a', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = TRUE, "-b" = TRUE))
})
test_that('parsing "-a" works',{
#$ prog -a
#"user-error"
expect_error(docopt(doc, '-a', strict=TRUE))
})
test_that('parsing "-b" works',{
#$ prog -b
#"user-error"
expect_error(docopt(doc, '-b', strict=TRUE))
})
test_that('parsing "" works',{
#$ prog
#{"-a": false, "-b": false}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = FALSE, "-b" = FALSE))
})
#####################
context('doc19')
doc <-
'usage: prog (-a|-b)
options: -a
-b'
test_that('parsing "-a -b" works',{
#$ prog -a -b
#"user-error"
expect_error(docopt(doc, '-a -b', strict=TRUE))
})
test_that('parsing "" works',{
#$ prog
#"user-error"
expect_error(docopt(doc, '', strict=TRUE))
})
test_that('parsing "-a" works',{
#$ prog -a
#{"-a": true, "-b": false}
res <- docopt(doc, '-a', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = TRUE, "-b" = FALSE))
})
test_that('parsing "-b" works',{
#$ prog -b
#{"-a": false, "-b": true}
res <- docopt(doc, '-b', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = FALSE, "-b" = TRUE))
})
#####################
context('doc20')
doc <-
'usage: prog [ -a | -b ]
options: -a
-b'
test_that('parsing "-a -b" works',{
#$ prog -a -b
#"user-error"
expect_error(docopt(doc, '-a -b', strict=TRUE))
})
test_that('parsing "" works',{
#$ prog
#{"-a": false, "-b": false}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = FALSE, "-b" = FALSE))
})
test_that('parsing "-a" works',{
#$ prog -a
#{"-a": true, "-b": false}
res <- docopt(doc, '-a', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = TRUE, "-b" = FALSE))
})
test_that('parsing "-b" works',{
#$ prog -b
#{"-a": false, "-b": true}
res <- docopt(doc, '-b', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = FALSE, "-b" = TRUE))
})
#####################
context('doc21')
doc <-
'usage: prog <arg>'
test_that('parsing "10" works',{
#$ prog 10
#{"<arg>": "10"}
res <- docopt(doc, '10', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["<arg>"], list("<arg>" = "10"))
})
test_that('parsing "10 20" works',{
#$ prog 10 20
#"user-error"
expect_error(docopt(doc, '10 20', strict=TRUE))
})
test_that('parsing "" works',{
#$ prog
#"user-error"
expect_error(docopt(doc, '', strict=TRUE))
})
#####################
context('doc22')
doc <-
'usage: prog [<arg>]'
test_that('parsing "10" works',{
#$ prog 10
#{"<arg>": "10"}
res <- docopt(doc, '10', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["<arg>"], list("<arg>" = "10"))
})
test_that('parsing "10 20" works',{
#$ prog 10 20
#"user-error"
expect_error(docopt(doc, '10 20', strict=TRUE))
})
test_that('parsing "" works',{
#$ prog
#{"<arg>": null}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["<arg>"], list("<arg>" = NULL))
})
#####################
context('doc23')
doc <-
'usage: prog <kind> <name> <type>'
test_that('parsing "10 20 40" works',{
#$ prog 10 20 40
#{"<kind>": "10", "<name>": "20", "<type>": "40"}
res <- docopt(doc, '10 20 40', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("<kind>", "<name>", "<type>")], list("<kind>" = "10", "<name>" = "20", "<type>" = "40"))
})
test_that('parsing "10 20" works',{
#$ prog 10 20
#"user-error"
expect_error(docopt(doc, '10 20', strict=TRUE))
})
test_that('parsing "" works',{
#$ prog
#"user-error"
expect_error(docopt(doc, '', strict=TRUE))
})
#####################
context('doc24')
doc <-
'usage: prog <kind> [<name> <type>]'
test_that('parsing "10 20 40" works',{
#$ prog 10 20 40
#{"<kind>": "10", "<name>": "20", "<type>": "40"}
res <- docopt(doc, '10 20 40', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("<kind>", "<name>", "<type>")], list("<kind>" = "10", "<name>" = "20", "<type>" = "40"))
})
test_that('parsing "10 20" works',{
#$ prog 10 20
#{"<kind>": "10", "<name>": "20", "<type>": null}
res <- docopt(doc, '10 20', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("<kind>", "<name>", "<type>")], list("<kind>" = "10", "<name>" = "20", "<type>" = NULL))
})
test_that('parsing "" works',{
#$ prog
#"user-error"
expect_error(docopt(doc, '', strict=TRUE))
})
#####################
context('doc25')
doc <-
'usage: prog [<kind> | <name> <type>]'
test_that('parsing "10 20 40" works',{
#$ prog 10 20 40
#"user-error"
expect_error(docopt(doc, '10 20 40', strict=TRUE))
})
test_that('parsing "20 40" works',{
#$ prog 20 40
#{"<kind>": null, "<name>": "20", "<type>": "40"}
res <- docopt(doc, '20 40', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("<kind>", "<name>", "<type>")], list("<kind>" = NULL, "<name>" = "20", "<type>" = "40"))
})
test_that('parsing "" works',{
#$ prog
#{"<kind>": null, "<name>": null, "<type>": null}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("<kind>", "<name>", "<type>")], list("<kind>" = NULL, "<name>" = NULL, "<type>" = NULL))
})
#####################
context('doc26')
doc <-
'usage: prog (<kind> --all | <name>)
options:
--all'
test_that('parsing "10 --all" works',{
#$ prog 10 --all
#{"<kind>": "10", "--all": true, "<name>": null}
res <- docopt(doc, '10 --all', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("<kind>", "--all", "<name>")], list("<kind>" = "10", "--all" = TRUE, "<name>" = NULL))
})
test_that('parsing "10" works',{
#$ prog 10
#{"<kind>": null, "--all": false, "<name>": "10"}
res <- docopt(doc, '10', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("<kind>", "--all", "<name>")], list("<kind>" = NULL, "--all" = FALSE, "<name>" = "10"))
})
test_that('parsing "" works',{
#$ prog
#"user-error"
expect_error(docopt(doc, '', strict=TRUE))
})
#####################
context('doc27')
doc <-
'usage: prog [<name> <name>]'
test_that('parsing "10 20" works',{
#$ prog 10 20
#{"<name>": ["10", "20"]}
res <- docopt(doc, '10 20', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["<name>"], list("<name>" = c("10", "20")))
})
test_that('parsing "10" works',{
#$ prog 10
#{"<name>": ["10"]}
res <- docopt(doc, '10', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["<name>"], list("<name>" = "10"))
})
test_that('parsing "" works',{
#$ prog
#{"<name>": []}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["<name>"], list("<name>" = list()))
})
#####################
context('doc28')
doc <-
'usage: prog [(<name> <name>)]'
test_that('parsing "10 20" works',{
#$ prog 10 20
#{"<name>": ["10", "20"]}
res <- docopt(doc, '10 20', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["<name>"], list("<name>" = c("10", "20")))
})
test_that('parsing "10" works',{
#$ prog 10
#"user-error"
expect_error(docopt(doc, '10', strict=TRUE))
})
test_that('parsing "" works',{
#$ prog
#{"<name>": []}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["<name>"], list("<name>" = list()))
})
#####################
context('doc29')
doc <-
'usage: prog NAME...'
test_that('parsing "10 20" works',{
#$ prog 10 20
#{"NAME": ["10", "20"]}
res <- docopt(doc, '10 20', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["NAME"], list(NAME = c("10", "20")))
})
test_that('parsing "10" works',{
#$ prog 10
#{"NAME": ["10"]}
res <- docopt(doc, '10', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["NAME"], list(NAME = "10"))
})
test_that('parsing "" works',{
#$ prog
#"user-error"
expect_error(docopt(doc, '', strict=TRUE))
})
#####################
context('doc30')
doc <-
'usage: prog [NAME]...'
test_that('parsing "10 20" works',{
#$ prog 10 20
#{"NAME": ["10", "20"]}
res <- docopt(doc, '10 20', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["NAME"], list(NAME = c("10", "20")))
})
test_that('parsing "10" works',{
#$ prog 10
#{"NAME": ["10"]}
res <- docopt(doc, '10', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["NAME"], list(NAME = "10"))
})
test_that('parsing "" works',{
#$ prog
#{"NAME": []}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["NAME"], list(NAME = list()))
})
#####################
context('doc31')
doc <-
'usage: prog [NAME...]'
test_that('parsing "10 20" works',{
#$ prog 10 20
#{"NAME": ["10", "20"]}
res <- docopt(doc, '10 20', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["NAME"], list(NAME = c("10", "20")))
})
test_that('parsing "10" works',{
#$ prog 10
#{"NAME": ["10"]}
res <- docopt(doc, '10', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["NAME"], list(NAME = "10"))
})
test_that('parsing "" works',{
#$ prog
#{"NAME": []}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["NAME"], list(NAME = list()))
})
#####################
context('doc32')
doc <-
'usage: prog [NAME [NAME ...]]'
test_that('parsing "10 20" works',{
#$ prog 10 20
#{"NAME": ["10", "20"]}
res <- docopt(doc, '10 20', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["NAME"], list(NAME = c("10", "20")))
})
test_that('parsing "10" works',{
#$ prog 10
#{"NAME": ["10"]}
res <- docopt(doc, '10', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["NAME"], list(NAME = "10"))
})
test_that('parsing "" works',{
#$ prog
#{"NAME": []}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["NAME"], list(NAME = list()))
})
#####################
context('doc33')
doc <-
'usage: prog (NAME | --foo NAME)
options: --foo'
test_that('parsing "10" works',{
#$ prog 10
#{"NAME": "10", "--foo": false}
res <- docopt(doc, '10', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("NAME", "--foo")], list(NAME = "10", "--foo" = FALSE))
})
test_that('parsing "--foo 10" works',{
#$ prog --foo 10
#{"NAME": "10", "--foo": true}
res <- docopt(doc, '--foo 10', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("NAME", "--foo")], list(NAME = "10", "--foo" = TRUE))
})
test_that('parsing "--foo=10" works',{
#$ prog --foo=10
#"user-error"
expect_error(docopt(doc, '--foo=10', strict=TRUE))
})
#####################
context('doc34')
doc <-
'usage: prog (NAME | --foo) [--bar | NAME]
options: --foo
options: --bar'
test_that('parsing "10" works',{
#$ prog 10
#{"NAME": ["10"], "--foo": false, "--bar": false}
res <- docopt(doc, '10', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("NAME", "--foo", "--bar")], list(NAME = "10", "--foo" = FALSE, "--bar" = FALSE))
})
test_that('parsing "10 20" works',{
#$ prog 10 20
#{"NAME": ["10", "20"], "--foo": false, "--bar": false}
res <- docopt(doc, '10 20', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("NAME", "--foo", "--bar")], list(NAME = c("10", "20"), "--foo" = FALSE, "--bar" = FALSE))
})
test_that('parsing "--foo --bar" works',{
#$ prog --foo --bar
#{"NAME": [], "--foo": true, "--bar": true}
res <- docopt(doc, '--foo --bar', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("NAME", "--foo", "--bar")], list(NAME = list(), "--foo" = TRUE, "--bar" = TRUE))
})
#####################
context('doc35')
doc <-
'Naval Fate.
Usage:
prog ship new <name>...
prog ship [<name>] move <x> <y> [--speed=<kn>]
prog ship shoot <x> <y>
prog mine (set|remove) <x> <y> [--moored|--drifting]
prog -h | --help
prog --version
Options:
-h --help Show this screen.
--version Show version.
--speed=<kn> Speed in knots [default: 10].
--moored Mored (anchored) mine.
--drifting Drifting mine.'
test_that('parsing "ship Guardian move 150 300 --speed=20" works',{
#$ prog ship Guardian move 150 300 --speed=20
#{"--drifting": false, "--help": false, "--moored": false, "--speed": "20", "--version": false, "<name>": ["Guardian"], "<x>": "150", "<y>": "300", "mine": false, "move": true, "new": false, "remove": false, "set": false, "ship": true, "shoot": false}
res <- docopt(doc, 'ship Guardian move 150 300 --speed=20', strict=TRUE)
expect_equivalent(length(res), 15)
expect_equivalent(res[c("--drifting", "--help", "--moored", "--speed", "--version","<name>", "<x>", "<y>", "mine", "move", "new", "remove", "set", "ship", "shoot")], list("--drifting" = FALSE, "--help" = FALSE, "--moored" = FALSE, "--speed" = "20", "--version" = FALSE, "<name>" = "Guardian", "<x>" = "150", "<y>" = "300", mine = FALSE, move = TRUE, new = FALSE, remove = FALSE, set = FALSE, ship = TRUE, shoot = FALSE))
})
#####################
context('doc36')
doc <-
'usage: prog --hello'
test_that('parsing "--hello" works',{
#$ prog --hello
#{"--hello": true}
res <- docopt(doc, '--hello', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--hello"], list("--hello" = TRUE))
})
#####################
context('doc37')
doc <-
'usage: prog [--hello=<world>]'
test_that('parsing "" works',{
#$ prog
#{"--hello": null}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--hello"], list("--hello" = NULL))
})
test_that('parsing "--hello wrld" works',{
#$ prog --hello wrld
#{"--hello": "wrld"}
res <- docopt(doc, '--hello wrld', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--hello"], list("--hello" = "wrld"))
})
#####################
context('doc38')
doc <-
'usage: prog [-o]'
test_that('parsing "" works',{
#$ prog
#{"-o": false}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-o"], list("-o" = FALSE))
})
test_that('parsing "-o" works',{
#$ prog -o
#{"-o": true}
res <- docopt(doc, '-o', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-o"], list("-o" = TRUE))
})
#####################
context('doc39')
doc <-
'usage: prog [-opr]'
test_that('parsing "-op" works',{
#$ prog -op
#{"-o": true, "-p": true, "-r": false}
res <- docopt(doc, '-op', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("-o", "-p", "-r")], list("-o" = TRUE, "-p" = TRUE, "-r" = FALSE))
})
#####################
context('doc40')
doc <-
'usage: prog --aabb | --aa'
test_that('parsing "--aa" works',{
#$ prog --aa
#{"--aabb": false, "--aa": true}
res <- docopt(doc, '--aa', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("--aabb", "--aa")], list("--aabb" = FALSE, "--aa" = TRUE))
})
#####################
context('doc41')
doc <-
'Usage: prog -v'
test_that('parsing "-v" works',{
#$ prog -v
#{"-v": true}
res <- docopt(doc, '-v', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-v"], list("-v" = TRUE))
})
#####################
context('doc42')
doc <-
'Usage: prog [-v -v]'
test_that('parsing "" works',{
#$ prog
#{"-v": 0}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-v"], list("-v" = 0))
})
test_that('parsing "-v" works',{
#$ prog -v
#{"-v": 1}
res <- docopt(doc, '-v', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-v"], list("-v" = 1))
})
test_that('parsing "-vv" works',{
#$ prog -vv
#{"-v": 2}
res <- docopt(doc, '-vv', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-v"], list("-v" = 2))
})
#####################
context('doc43')
doc <-
'Usage: prog -v ...'
test_that('parsing "" works',{
#$ prog
#"user-error"
expect_error(docopt(doc, '', strict=TRUE))
})
test_that('parsing "-v" works',{
#$ prog -v
#{"-v": 1}
res <- docopt(doc, '-v', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-v"], list("-v" = 1))
})
test_that('parsing "-vv" works',{
#$ prog -vv
#{"-v": 2}
res <- docopt(doc, '-vv', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-v"], list("-v" = 2))
})
test_that('parsing "-vvvvvv" works',{
#$ prog -vvvvvv
#{"-v": 6}
res <- docopt(doc, '-vvvvvv', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-v"], list("-v" = 6))
})
#####################
context('doc44')
doc <-
'Usage: prog [-v | -vv | -vvv]
This one is probably most readable user-friednly variant.'
test_that('parsing "" works',{
#$ prog
#{"-v": 0}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-v"], list("-v" = 0))
})
test_that('parsing "-v" works',{
#$ prog -v
#{"-v": 1}
res <- docopt(doc, '-v', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-v"], list("-v" = 1))
})
test_that('parsing "-vv" works',{
#$ prog -vv
#{"-v": 2}
res <- docopt(doc, '-vv', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-v"], list("-v" = 2))
})
test_that('parsing "-vvvv" works',{
#$ prog -vvvv
#"user-error"
expect_error(docopt(doc, '-vvvv', strict=TRUE))
})
#####################
context('doc45')
doc <-
'usage: prog [--ver --ver]'
test_that('parsing "--ver --ver" works',{
skip("not implemented")
#$ prog --ver --ver
#{"--ver": 2}
res <- docopt(doc, '--ver --ver', strict=TRUE)
expect_equivalent(length(res), 1)
skip_on_cran()
expect_equivalent(res["--ver"], list("--ver" = 2))
})
#####################
context('doc46')
doc <-
'usage: prog [go]'
test_that('parsing "go" works',{
#$ prog go
#{"go": true}
res <- docopt(doc, 'go', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["go"], list(go = TRUE))
})
#####################
context('doc47')
doc <-
'usage: prog [go go]'
test_that('parsing "" works',{
#$ prog
#{"go": 0}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["go"], list(go = 0))
})
test_that('parsing "go" works',{
#$ prog go
#{"go": 1}
skip("not implemented")
res <- docopt(doc, 'go', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["go"], list(go = 1))
})
test_that('parsing "go go" works',{
#$ prog go go
#{"go": 2}
skip("not implemented")
res <- docopt(doc, 'go go', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["go"], list(go = 2))
})
test_that('parsing "go go go" works',{
#$ prog go go go
#"user-error"
expect_error(docopt(doc, 'go go go', strict=TRUE))
})
#####################
context('doc48')
doc <-
'usage: prog go...'
test_that('parsing "go go go go go" works',{
#$ prog go go go go go
#{"go": 5}
skip("not implemented")
res <- docopt(doc, 'go go go go go', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["go"], list(go = 5))
})
test_that('parsing "-a" works',{
#$ prog -a
#{"-a": true, "-b": false}
skip("not implemented")
res <- docopt(doc, '-a', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-a", "-b")], list("-a" = TRUE, "-b" = FALSE))
})
test_that('parsing "-aa" works',{
#$ prog -aa
#"user-error"
expect_error(docopt(doc, '-aa', strict=TRUE))
})
#####################
context('doc49')
doc <-
'Usage: prog [options] A
Options:
-q Be quiet
-v Be verbose.'
test_that('parsing "arg" works',{
#$ prog arg
#{"A": "arg", "-v": false, "-q": false}
res <- docopt(doc, 'arg', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("A", "-v", "-q")], list(A = "arg", "-v" = FALSE, "-q" = FALSE))
})
test_that('parsing "-v arg" works',{
#$ prog -v arg
#{"A": "arg", "-v": true, "-q": false}
res <- docopt(doc, '-v arg', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("A", "-v", "-q")], list(A = "arg", "-v" = TRUE, "-q" = FALSE))
})
test_that('parsing "-q arg" works',{
#$ prog -q arg
#{"A": "arg", "-v": false, "-q": true}
res <- docopt(doc, '-q arg', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("A", "-v", "-q")], list(A = "arg", "-v" = FALSE, "-q" = TRUE))
})
#####################
context('doc50')
doc <-
'usage: prog [-]'
test_that('parsing "-" works',{
#$ prog -
#{"-": true}
res <- docopt(doc, '-', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-"], list("-" = TRUE))
})
test_that('parsing "" works',{
#$ prog
#{"-": false}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-"], list("-" = FALSE))
})
#####################
context('doc51')
doc <-
'usage: prog [NAME [NAME ...]]'
test_that('parsing "a b" works',{
#$ prog a b
#{"NAME": ["a", "b"]}
res <- docopt(doc, 'a b', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["NAME"], list(NAME = c("a", "b")))
})
test_that('parsing "" works',{
#$ prog
#{"NAME": []}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["NAME"], list(NAME = list()))
})
#####################
context('doc52')
doc <-
'usage: prog [options]
options:
-a Add
-m <msg> Message'
test_that('parsing "-a" works',{
#$ prog -a
#{"-m": null, "-a": true}
res <- docopt(doc, '-a', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-m", "-a")], list("-m" = NULL, "-a" = TRUE))
})
#####################
context('doc53')
doc <-
'usage: prog --hello'
test_that('parsing "--hello" works',{
#$ prog --hello
#{"--hello": true}
res <- docopt(doc, '--hello', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--hello"], list("--hello" = TRUE))
})
#####################
context('doc54')
doc <-
'usage: prog [--hello=<world>]'
test_that('parsing "" works',{
#$ prog
#{"--hello": null}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--hello"], list("--hello" = NULL))
})
test_that('parsing "--hello wrld" works',{
#$ prog --hello wrld
#{"--hello": "wrld"}
res <- docopt(doc, '--hello wrld', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--hello"], list("--hello" = "wrld"))
})
#####################
context('doc55')
doc <-
'usage: prog [-o]'
test_that('parsing "" works',{
#$ prog
#{"-o": false}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-o"], list("-o" = FALSE))
})
test_that('parsing "-o" works',{
#$ prog -o
#{"-o": true}
res <- docopt(doc, '-o', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-o"], list("-o" = TRUE))
})
#####################
context('doc56')
doc <-
'usage: prog [-opr]'
test_that('parsing "-op" works',{
#$ prog -op
#{"-o": true, "-p": true, "-r": false}
res <- docopt(doc, '-op', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("-o", "-p", "-r")], list("-o" = TRUE, "-p" = TRUE, "-r" = FALSE))
})
#####################
context('doc57')
doc <-
'usage: git [-v | --verbose]'
test_that('parsing "-v" works',{
#$ prog -v
#{"-v": true, "--verbose": false}
res <- docopt(doc, '-v', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("-v", "--verbose")], list("-v" = TRUE, "--verbose" = FALSE))
})
#####################
context('doc58')
doc <-
'usage: git remote [-v | --verbose]'
test_that('parsing "remote -v" works',{
#$ prog remote -v
#{"remote": true, "-v": true, "--verbose": false}
res <- docopt(doc, 'remote -v', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("remote", "-v", "--verbose")], list(remote = TRUE, "-v" = TRUE, "--verbose" = FALSE))
})
#####################
context('doc59')
doc <-
'usage: prog'
test_that('parsing "" works',{
#$ prog
#{}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 0)
expect_equivalent(res[NULL], list())
})
#####################
context('doc60')
doc <-
'usage: prog
prog <a> <b>'
test_that('parsing "1 2" works',{
#$ prog 1 2
#{"<a>": "1", "<b>": "2"}
res <- docopt(doc, '1 2', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("<a>", "<b>")], list("<a>" = "1", "<b>" = "2"))
})
test_that('parsing "" works',{
#$ prog
#{"<a>": null, "<b>": null}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("<a>", "<b>")], list("<a>" = NULL, "<b>" = NULL))
})
#####################
context('doc61')
doc <-
'usage: prog <a> <b>
prog'
test_that('parsing "" works',{
#$ prog
#{"<a>": null, "<b>": null}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("<a>", "<b>")], list("<a>" = NULL, "<b>" = NULL))
})
#####################
context('doc62')
doc <-
'usage: prog [--file=<f>]'
test_that('parsing "" works',{
#$ prog
#{"--file": null}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--file"], list("--file" = NULL))
})
#####################
context('doc63')
doc <-
'usage: prog [--file=<f>]
options: --file <a>'
test_that('parsing "" works',{
#$ prog
#{"--file": null}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--file"], list("--file" = NULL))
})
#####################
context('doc64')
doc <-
'Usage: prog [-a <host:port>]
Options: -a, --address <host:port> TCP address [default: localhost:6283].'
test_that('parsing "" works',{
#$ prog
#{"--address": "localhost:6283"}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--address"], list("--address" = "localhost:6283"))
})
#####################
context('doc65')
doc <-
'usage: prog --long=<arg> ...'
test_that('parsing "--long one" works',{
#$ prog --long one
#{"--long": ["one"]}
res <- docopt(doc, '--long one', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--long"], list("--long" = "one"))
})
test_that('parsing "--long one --long two" works',{
#$ prog --long one --long two
#{"--long": ["one", "two"]}
res <- docopt(doc, '--long one --long two', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--long"], list("--long" = c("one", "two")))
})
#####################
context('doc66')
doc <-
'usage: prog (go <direction> --speed=<km/h>)...'
test_that('parsing "go left --speed=5 go right --speed=9" works',{
skip("not implemented")
#$ prog go left --speed=5 go right --speed=9
#{"go": 2, "<direction>": ["left", "right"], "--speed": ["5", "9"]}
res <- docopt(doc, 'go left --speed=5 go right --speed=9', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("go", "<direction>", "--speed")], list(go = 2, "<direction>" = c("left", "right"), "--speed" = c("5", "9")))
})
#####################
context('doc67')
doc <-
'usage: prog [options] -a
options: -a'
skip("not implemented")
test_that('parsing "-a" works',{
#$ prog -a
#{"-a": true}
res <- docopt(doc, '-a', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-a"], list("-a" = TRUE))
})
#####################
context('doc68')
doc <-
'usage: prog [-o <o>]...
options: -o <o> [default: x]'
test_that('parsing "-o this -o that" works',{
#$ prog -o this -o that
#{"-o": ["this", "that"]}
res <- docopt(doc, '-o this -o that', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-o"], list("-o" = c("this", "that")))
})
test_that('parsing "" works',{
#$ prog
#{"-o": ["x"]}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-o"], list("-o" = "x"))
})
#####################
context('doc69')
doc <-
'usage: prog [-o <o>]...
options: -o <o> [default: x y]'
test_that('parsing "-o this" works',{
#$ prog -o this
#{"-o": ["this"]}
res <- docopt(doc, '-o this', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-o"], list("-o" = "this"))
})
test_that('parsing "" works',{
#$ prog
#{"-o": ["x", "y"]}
res <- docopt(doc, '', strict=TRUE)
expect_equivalent(length(res), 1)
skip("not implemented")
expect_equivalent(res["-o"], list("-o" = c("x", "y")))
})
#####################
context('doc70')
doc <-
'usage: prog -pPATH
options: -p PATH'
test_that('parsing "-pHOME" works',{
#$ prog -pHOME
#{"-p": "HOME"}
res <- docopt(doc, '-pHOME', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["-p"], list("-p" = "HOME"))
})
#####################
context('doc71')
doc <-
'Usage: foo (--xx=x|--yy=y)...'
test_that('parsing "--xx=1 --yy=2" works',{
#$ prog --xx=1 --yy=2
#{"--xx": ["1"], "--yy": ["2"]}
res <- docopt(doc, '--xx=1 --yy=2', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("--xx", "--yy")], list("--xx" = "1", "--yy" = "2"))
})
#####################
context('doc72')
doc <-
'usage: prog [<input file>]'
test_that('parsing "f.txt" works',{
#$ prog f.txt
#{"<input file>": "f.txt"}
res <- docopt(doc, 'f.txt', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["<input file>"], list("<input file>" = "f.txt"))
})
#####################
context('doc73')
doc <-
'usage: prog [--input=<file name>]...'
test_that('parsing "--input a.txt --input=b.txt" works',{
#$ prog --input a.txt --input=b.txt
#{"--input": ["a.txt", "b.txt"]}
res <- docopt(doc, '--input a.txt --input=b.txt', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--input"], list("--input" = c("a.txt", "b.txt")))
})
#####################
context('doc74')
doc <-
'usage: prog good [options]
prog fail [options]
options: --loglevel=N'
test_that('parsing "fail --loglevel 5" works',{
#$ prog fail --loglevel 5
#{"--loglevel": "5", "fail": true, "good": false}
res <- docopt(doc, 'fail --loglevel 5', strict=TRUE)
expect_equivalent(length(res), 3)
expect_equivalent(res[c("--loglevel", "fail", "good")], list("--loglevel" = "5", fail = TRUE, good = FALSE))
})
#####################
context('doc75')
doc <-
'usage:prog --foo'
test_that('parsing "--foo" works',{
#$ prog --foo
#{"--foo": true}
res <- docopt(doc, '--foo', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--foo"], list("--foo" = TRUE))
})
#####################
context('doc76')
doc <-
'PROGRAM USAGE: prog --foo'
test_that('parsing "--foo" works',{
#$ prog --foo
#{"--foo": true}
res <- docopt(doc, '--foo', strict=TRUE)
expect_equivalent(length(res), 1)
expect_equivalent(res["--foo"], list("--foo" = TRUE))
})
#####################
context('doc77')
doc <-
'Usage: prog --foo
prog --bar
NOT PART OF SECTION'
test_that('parsing "--foo" works',{
#$ prog --foo
#{"--foo": true, "--bar": false}
res <- docopt(doc, '--foo', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("--foo", "--bar")], list("--foo" = TRUE, "--bar" = FALSE))
})
#####################
context('doc78')
doc <-
'Usage:
prog --foo
prog --bar
NOT PART OF SECTION'
test_that('parsing "--foo" works',{
#$ prog --foo
#{"--foo": true, "--bar": false}
res <- docopt(doc, '--foo', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("--foo", "--bar")], list("--foo" = TRUE, "--bar" = FALSE))
})
#####################
context('doc79')
doc <-
'Usage:
prog --foo
prog --bar
NOT PART OF SECTION'
test_that('parsing "--foo" works',{
#$ prog --foo
#{"--foo": true, "--bar": false}
res <- docopt(doc, '--foo', strict=TRUE)
expect_equivalent(length(res), 2)
expect_equivalent(res[c("--foo", "--bar")], list("--foo" = TRUE, "--bar" = FALSE))
})
#####################
context('doc80')
doc <-
'Usage: prog [options]
global options: --foo
local options: --baz
--bar
other options:
--egg
--spam
-not-an-option-'
test_that('parsing "--baz --egg" works',{
#$ prog --baz --egg
#{"--foo": false, "--baz": true, "--bar": false, "--egg": true, "--spam": false}
res <- docopt(doc, '--baz --egg', strict=TRUE)
skip("not implemented")
expect_equivalent(length(res), 5)
expect_equivalent(res[c("--foo", "--baz", "--bar", "--egg", "--spam")], list("--foo" = FALSE, "--baz" = TRUE, "--bar" = FALSE, "--egg" = TRUE, "--spam" = FALSE))
})
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.