Remove third_party/java/jopt-simple/src/{site,test}.
They are unused and the tests depend on Joda Time which I'm going to
remove.
Also document the removal in the package's README.bazel.md.
Change-Id: I7b0ee89718bfc2cffcc60a8262cf53dbf9035669
diff --git a/third_party/java/jopt-simple/README.bazel.md b/third_party/java/jopt-simple/README.bazel.md
index 9985e82..759711b 100644
--- a/third_party/java/jopt-simple/README.bazel.md
+++ b/third_party/java/jopt-simple/README.bazel.md
@@ -4,3 +4,4 @@
2. `git checkout jopt-simple-5.0.3` (commithash `b52b94611dba126a8236a10277d15676e31ab5f6`)
3. Dump the contents of the `git` tree into `third_party/java/jopt-simple`
4. Keep the existing, trivial `BUILD` file
+5. Remove the src/test and src/site directories.
diff --git a/third_party/java/jopt-simple/src/site/apt/acknowledgments.apt b/third_party/java/jopt-simple/src/site/apt/acknowledgments.apt
deleted file mode 100644
index ec35ed7..0000000
--- a/third_party/java/jopt-simple/src/site/apt/acknowledgments.apt
+++ /dev/null
@@ -1,90 +0,0 @@
- ---------------
- Acknowledgments
- ---------------
-
- Thanks to the following people who have offered constructive feedback, support, contribution,
- and/or praise for JOpt Simple:
-
- * Paul Armstrong
-
- * Guillaume Aubert
-
- * David Beckingsale
-
- * Jochen Bedersdorfer
-
- * Louis Bergelson
-
- * Ryan Breidenbach
-
- * Erik Broes
-
- * Carlos Cadete
-
- * Laurent Caillette
-
- * Matthew Daniel
-
- * Hans Dockter
-
- * Kevin C. Dorff
-
- * Adam Fisk
-
- * Raymund F\u00FCl\u00F6p
-
- * Dave Jarvis
-
- * Paul King
-
- * El Kodus
-
- * Alexander Kriegisch
-
- * Zachary Kurmas
-
- * Henning Luebbers
-
- * Derek Mahar
-
- * Bruno Mascret
-
- * Antoine Neveux
-
- * Christian Ohr
-
- * Michael Osipov
-
- * Brian Oxley (binkley)
-
- * Andrew Parker
-
- * Julien Ponge
-
- * Rob Reed
-
- * Mark Reinhold
-
- * Alex Renger
-
- * Andrew Robinson
-
- * Jonathan Shook
-
- * Jason Smith
-
- * Emils Solmanis
-
- * Leo Uzcategui
-
- * Alan van Dam
-
- * Douglas Wegscheid
-
- * Chris K Wensel
-
- * Ashley Williams
-
- * Daniel Yokomizo
-
- []
diff --git a/third_party/java/jopt-simple/src/site/apt/changes.apt b/third_party/java/jopt-simple/src/site/apt/changes.apt
deleted file mode 100644
index 2bc0d7d..0000000
--- a/third_party/java/jopt-simple/src/site/apt/changes.apt
+++ /dev/null
@@ -1,385 +0,0 @@
- ----------
- Change Log
- ----------
-
-Changes in version 5.0.3
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/96} gh-96}} so that
- options that take an argument but don't change the argument type from
- <<<String>>> still show a <<<String>>> type indicator in the default
- option help.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/104} gh-104}} so
- that <<<EnumConverter>>> performs case-insensitive matching against arguments
- of options. Thanks to Martin Paljak for this.
-
-Changes in version 5.0.2
-
- * Made some package-private abstract classes become public classes
- with package-private constructors. This makes it possible to call some methods
- from Kotlin that were previously inaccessible. Thanks to Mirko Friedenhagen
- for this.
-
-Changes in version 5.0.1
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/92} gh-92}} so that
- in the event that <<<printHelpOn()>>> is called more than once, the output
- is not duplicated.
-
-Changes in version 5.0
-
- * Abandoning JDKs prior to 7. All source is Java 7-compatible, and bytecode is compiled to 1.7
- version.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/51} gh-51}} by adding
- <<<OptionSpecBuilder.availableIf()>>> and <<<OptionSpecBuilder.availableUnless()>>>. Thanks
- to Christian Ohr for this.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/70} gh-70}} by adding
- <<<EnumConverter>>> and <<<PathConverter>>>. Thanks to Christian Ohr for this.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/88} gh-88}} by adding
- an <<<OptionParser>>> constructor to allow suppression of option abbreviations.
- Thanks to Louis Bergelson for this.
-
-Changes in version 4.10
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/85} gh-85}}
- by correcting the description column width consumption of the built-in
- help formatter.
-
-Changes in version 4.9
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/79} gh-79}}
- by correcting the behavior of <<<OptionException.multipleOptionString>>>
- when handling options with synonyms.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/72} gh-72}}
- by externalizing some of the literal strings in <<<BuiltinHelpFormatter>>>
- into resource bundles.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/76} gh-76}}
- by modifying the behavior of <<<OptionalArgumentOptionSpec>>> so that if
- the argument following the option does not "look like" an option but can
- be converted to the option argument's type, treat the argument as the argument
- of the option.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/68} gh-68}}
- by modifying <<<BuiltinHelpFormatter>>> to be more extensible and documenting
- the behavior of the newly accessible methods.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/73} gh-73}}
- by correcting the behavior of <<<OptionSet.specs()>>> to remove all instances
- of the non-option argument spec.
-
-Changes in version 4.8
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/65} gh-65}}
- by modifying the build file to create a JAR with OSGi metadata.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/63} gh-63}}
- by externalizing exception messages into resource bundles.
- Currently, we ship only with messages for locale "en_US".
- Translations for other locales are more than welcome.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/58} gh-58}} by
- rewriting exception messaging to clarify synonymous options.
- Synonyms are be separated by slashes (/); lists of distinct options will
- be separated by commas (,) in square brackets ([]).
-
-Changes in version 4.7
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/57} gh-57}} by admitting
- the underscore as a legal option character.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/53} gh-53}} by correcting
- <<<OptionSet.hasOptions()>>> to answer correctly for no switches.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/56} gh-56}} by correcting
- the default help formatting not to use a <<<Set>>> for rows of output,
- but <<<List>>>.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/59} gh-59}} by relaxing
- the return type of <<<ValueConverter.valueType()>>>.
-
-Changes in version 4.6
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/31} gh-31}} by offering
- <<<OptionSpecBuilder.requiredUnless()>>>. Thanks to Christian Ohr for this.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/38} gh-38}} by offering
- <<<OptionParser.recognizedOptions()>>>. Thanks to Antoine Neveux for this.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/35} gh-35}} by offering
- <<<OptionSet.asMap()>>>. Thanks to Brian Oxley for this.
-
-Changes in version 4.5
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/17} gh-17}} by offering
- <<<OptionParser.nonOptions()>>> and <<<NonOptionArgumentSpec>>>.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/pull/27} gh-27}} by offering
- <<<OptionParser.allowsUnrecognizedOptions()>>>. Thanks to Erik Broes for this.
-
-Changes in version 4.4
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/16} gh-16}} by offering
- <<<BuiltinHelpFormatter>>> that allows configuration of overall row width and
- column separator width. Thanks to Ryan Breidenbach for contributing code to this.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/12} gh-12}} by offering
- <<<OptionSpecBuilder.requiredIf()>>>.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/22} gh-22}}. Thanks to
- El Kodus for this.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/19} gh-19}}. Thanks to
- El Kodus for this.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/14} gh-14}} by offering
- <<<AbstractOptionSpec.forHelp()>>>.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/13} gh-13}} by offering
- <<<ArgumentAcceptingOptionSpec.withValuesSeparatedBy(String)>>>.
-
- * Added <<<InetAddressValueConverter>>>. Thanks to Raymund F\u00FCl\u00F6p for this.
-
-Changes in version 4.3
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/9} gh-9}} by offering
- <<<OptionSet.specs()>>>, which gives a list of the specs corresponding to the
- options detected on a parse, in the order in which the options occurred on the
- command line.
-
-Changes in version 4.2
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/8} gh-8}} by offering
- <<<ArgumentAcceptingOptionSpec.defaultsTo(V[])>>> in addition to
- <<<ArgumentAcceptingOptionSpec.defaultsTo(V, V...)>>>.
-
- * Removing some internal unused classes and methods.
-
-Changes in version 4.1
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/7} gh-7}} by allowing short option
- clusters to contain options which can accept arguments. When such an option is encountered,
- the remaining characters in the cluster are treated as the argument to the option. Thanks to
- Alan van Dam for this.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/6} gh-6}} with general improvements
- to the project's site. Thanks to Michael Osipov for this.
-
-Changes in version 4.0
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/4} gh-4}} by adding method
- <<<OptionParser.formatHelpWith(HelpFormatter)>>> to allow programmers to influence what
- help is printed with <<<OptionParser.printHelpOn()>>>. A <<<HelpFormatter>>> is handed a
- map, keyed by option text, whose values are <<<OptionDescriptor>>>s that describe the
- options the parser has been configured with.
-
- * Added method <<<OptionSet.hasOptions()>>>. Thanks to Michael Osipov for this.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/pull/3} gh-3}} by using
- <<<SimpleDateFormat.toPattern()>>> rather than <<<SimpleDateFormat.toLocalizedPattern()>>>
- in <<<DateConverter>>>. Thanks to Michael Osipov for this.
-
- * Resolved {{{https://github.com/pholser/jopt-simple/issues/5} gh-5}} by allowing primitive
- <<<Class>>> objects whose wrapper types are considered "value types" for purposes of
- <<<ArgumentAcceptingOptionSpec.ofType()>>> in place of the wrapper classes. Thanks to
- Daniel Yokomizo for suggesting this.
-
-Changes in version 3.3
-
- * Resolved {{{https://github.com/pholser/jopt-simple/pull/1} gh-1}} by adding method
- <<<required()>>> to class <<<ArgumentAcceptingOptionSpec>>>, to allow callers to indicate
- that a given option must be present on the command line. Thanks to Emils Solmanis for
- adding this.
-
-Changes in version 3.2
-
- * Added method <<<defaultsTo()>>> to class <<<ArgumentAcceptingOptionSpec>>>, to allow
- callers to specify default values for arguments of options. These influence the return
- values of <<<OptionSpec.value(s)()>>> and <<<OptionSet.value(s)Of()>>>. Default values
- also show up in the help screen entries for their options. This serves to resolve
- {{{https://sourceforge.net/tracker/?func=detail&aid=2484524&group_id=125731&atid=703508} feature
- request 2484524}}.
-
- * Fixed a problem whereby the empty string, a string consisting solely of whitespace, or a
- string with embedded whitespace weren't being properly recognized as arguments of options
- when they should have.
-
- * Resolved {{{https://sourceforge.net/tracker/?func=detail&aid=2793762&group_id=125731&atid=703508} feature
- request 2793762}}, having to do with improving the behavior of embedded newlines in option
- descriptions in help screens.
-
-Changes in version 3.1
-
- * Added method <<<withValuesConvertedBy()>>> to class <<<ArgumentAcceptingOptionSpec>>>,
- to allow callers to specify converters or validators that transform arguments of
- options into instances of specific Java types. This is useful for types which do not
- meet the requirements of <<<ofType()>>>.
-
- * Added classes <<<DateConverter>>> and <<<RegexMatcher>>> as examples of useful
- argument converters.
-
-Changes in version 3.0.1
-
- * Dependency on {{{http://ant.apache.org} Ant}} more appropriately test-scoped in the
- {{{http://maven.apache.org} Maven}} POM. That way, if you use JOpt Simple with Maven,
- you don't download Ant unnecessarily.
-
-Changes in version 3.0
-
- * Version 3.0 supports Java 5 and greater only. If you need to use JOpt Simple in a
- pre-Java-5 environment, use the latest 2.x release.
-
- * Where appropriate, existing API calls have been updated to use Java generics.
-
- * Extracted and surfaced interface <<<OptionSpec>>>. <<<OptionSpec>>>s returned by
- the fluent interface methods can be used to retrieve arguments of the options they
- represent in a type-safe manner.
-
- * Removed all previously deprecated methods.
-
- * Added methods to <<<OptionSet>>> to allow detection of options and retrieval of
- option arguments using instances of <<<OptionSpec>>>.
-
- * Converted tests to JUnit 4.
-
- * Switched to MIT License.
-
- * Relaxing some <<<List>>> parameter types and return types of methods to
- <<<Collection>>>.
-
- * <<<OptionArgumentConversionException>>> no longer drops the original cause on the
- floor; hence <<<OptionException>>> can now be created with a cause.
-
- * {{{http://maven.apache.org} Maven}}-ized the project web site.
-
- * Overhauled the examples page.
-
-Changes in version 2.4.1
-
- * Fixed {{{https://sourceforge.net/tracker/index.php?func=detail&aid=2018262&group_id=125731&atid=703505} bug 2018262}}.
-
-Changes in version 2.4
-
- * Added the <<<acceptsAll()>>> method to class <<<OptionParser>>>. Options passed to
- a given invocation of this method are treated as synonymous, so that each gives the
- same answer when given as the argument to the methods <<<has()>>>, <<<valuesOf()>>>,
- etc. on <<<OptionSet>>>.
-
- * Surfaced the class <<<KeyValuePair>>>. This class can be very handy as a value
- type for arguments whose values take on the form <<<key=value>>>, such as the <<<-D>>>
- arguments to JVMs.
-
- * Fixed {{{https://sourceforge.net/tracker/index.php?func=detail&aid=1932577&group_id=125731&atid=703505} bug 1932577}}.
-
- * Added method <<<withValuesSeparatedBy()>>> to class <<<ArgumentAcceptingOptionSpec>>>,
- to allow callers to specify multiple values for an option as a single argument with
- values separated by a given character.
-
- * Method <<<ofType()>>> on class <<<ArgumentAcceptingOptionSpec>>> now returns self
- rather than <<<void>>>.
-
- * Deprecated another "get for get's sake": <<<OptionParser.setPosixlyCorrect()>>>
- It is replaced with a less Java-beany-looking method.
-
- * Cleaned up the help screens produced by <<<OptionParser.printHelpOn()>>> so they are
- rendered as two 40-character columns, with long space-broken values split across lines
- as needed.
-
- * Fixed {{{https://sourceforge.net/tracker/index.php?func=detail&aid=1956418&group_id=125731&atid=703505} bug 1956418}}.
-
-Changes in version 2.3.6
-
- * No changes to code; just getting {{{http://maven.apache.org} Maven}} to do releases
- with its plugins.
-
-Changes in version 2.3.3
-
- * Deprecated method <<<OptionSet.wasDetected()>>> in favor of <<<OptionSet.has()>>> --
- the new name seems to read better.
-
- * <<<OptionException>>>s now override <<<getMessage()>>> sensibly, so that if a caller
- wants to handle the exception by catching it and displaying a message from the
- exception, she can do so and get satisfactory results.
-
- * {{{http://maven.apache.org} Maven}}-ized project's build.
-
- * Minor internal changes.
-
-Changes in version 2.3.2
-
- * Minor internal changes.
-
-Changes in version 2.3.1
-
- * Fixed a bug with POSIX-ly correct parsers. It was previously thought that POSIX-ly
- correct parsers should signal end of options when they detect an argument that does
- not lexically look like an option and could not be an argument of a previous option,
- required or optional. Such parsers now signal end of options when they detect an
- argument that does not lexically look like an option, and is not an argument of a
- previous option with a required argument. If you want such an argument to be treated
- as the argument of a preceding option whose argument is optional, you can still get
- this behavior by appending the argument to the option, either with abutting syntax
- (<<<-d/tmp>>>) or key-value syntax (<<<-d=/tmp>>>).
-
-Changes in version 2.3
-
- * No feature changes in this release; but this release can now be used with JDK 1.3.
- Previous releases could be used only with JDK 1.4 or newer.
-
-Changes in version 2.2
-
- * Removed all previously deprecated methods.
-
- * Re-clarified the contract of the one-arg <<<String>>> constructor of
- <<<OptionParser>>>: the constructor now raises <<<NullPointerException>>> if its
- argument is <<<null>>>. This is the convention for Java library methods which receive
- illegal <<<null>>> parameters.
-
-Changes in version 2.1
-
- * Introduced a facility for <<<OptionParser>>>s to print a help screen, which
- describes the options they accept.
-
- * Added the ability to provide descriptions of options and their arguments when
- configuring an <<<OptionParser>>>. These descriptions are printed in the
- aforementioned help screens.
-
- * Clarified the contract of the one-arg <<<String>>> constructor of <<<OptionParser>>>:
- the constructor raises <<<IllegalArgumentException>>> if its argument is <<<null>>>.
-
- * Deprecated <<<OptionParser.noArg()>>>, <<<OptionParser.requiredArg()>>>, and
- <<<OptionParser.optionalArg()>>>.
-
- * Deprecated some "gets for gets' sake": <<<OptionException.getOption()>>>,
- <<<OptionSet.getNonOptionArguments()>>>. They are replaced with less
- Java-beany-looking methods.
-
-Changes in version 2.0
-
- * Introduced a "fluent interface" API for specifying options for an <<<OptionParser>>>
- to recognize. The old methods for option specification still work--you need not
- convert to the new methods.
-
- * Added the ability to specify that option arguments should be converted to specific
- types. You can do this either with the old option specification methods or with the
- new fluent interface API.
-
- * Deprecated <<<OptionParser.requiresArg()>>> in favor of
- <<<OptionParser.requiredArg()>>> -- the new name seems to read better.
-
-Version 1.0
-
- * First major release.
-
- * Includes concrete classes <<<OptionParser>>> and <<<OptionSet>>>.
-
- * Supports POSIX <<<getopt()>>> and GNU <<<getopt_long()>>> command line syntax.
-
- * No type conversion on option arguments, they are all treated as <<<String>>>s.
-
- * Methods <<<noArg()>>>, <<<requiredArg()>>>, and <<<optionalArg()>>> tell an
- <<<OptionParser>>> what options to recognize.
diff --git a/third_party/java/jopt-simple/src/site/apt/developer.apt b/third_party/java/jopt-simple/src/site/apt/developer.apt
deleted file mode 100644
index 59d5d82..0000000
--- a/third_party/java/jopt-simple/src/site/apt/developer.apt
+++ /dev/null
@@ -1,48 +0,0 @@
- --------------
- Developer Docs
- --------------
-
-Help for developing JOpt Simple
-
- This page has notes and hints for contributing to JOpt Simple, mostly around getting started and style questions.
-
-* Code Style
-
- Style is important. Why? Chiefly to aid merges. Reformatting code makes merging more difficult. When needing to reformat unchanged code, please do so on a separate commit with a clear commit message indicating a non-code change.
-
- In general use the Eclipse formatter (there is a plugin for IntelliJ IDEA). See <<<jopt-simple-eclipse-formatting.xml>>> and <<<jopt-simple.importorder>>> in the project root.
-
- The ultimate arbiter of good style is Paul Holser.
-
-** Braces
-
- * Yes:
-
-+----+
-for (int i = 0; i < 10; ++i) {
- if (i < 5)
- println(i);
-}
-+----+
-
- * No:
-
-+----+
-for (int i = 0; i < 10; ++i)
- if (i < 5)
- println(i);
-+----+
-
-* {{Building}}
-
- There are no integration tests. Your typical command line is:
-
-+----+
-$ mvn clean test
-+----+
-
- Before pushing commits, please check that the site fully builds:
-
-+----+
-$ mvn clean post-site
-+----+
diff --git a/third_party/java/jopt-simple/src/site/apt/download.apt.vm b/third_party/java/jopt-simple/src/site/apt/download.apt.vm
deleted file mode 100644
index dde9015..0000000
--- a/third_party/java/jopt-simple/src/site/apt/download.apt.vm
+++ /dev/null
@@ -1,26 +0,0 @@
- --------
- Download
- --------
-
- Releases of JOpt Simple are synced to the central Maven repository. Declare a
- dependency element in your POM like so:
-
-+---------------------------------------------
-...
-<dependencies>
- ...
- <dependency>
- <groupId>net.sf.jopt-simple</groupId>
- <artifactId>jopt-simple</artifactId>
- <version>${project.version}</version>
- </dependency>
- ...
-</dependencies>
-...
-+---------------------------------------------
-
- If you're not using Maven, you can still download the newer releases from the Maven
- repository manually, {{{http://repo1.maven.org/maven2/net/sf/jopt-simple/jopt-simple} here}}.
-
- You can find older releases at
- {{{http://sourceforge.net/project/showfiles.php?group_id=125731} SourceForge}}.
diff --git a/third_party/java/jopt-simple/src/site/apt/examples.apt b/third_party/java/jopt-simple/src/site/apt/examples.apt
deleted file mode 100644
index 3b43dee..0000000
--- a/third_party/java/jopt-simple/src/site/apt/examples.apt
+++ /dev/null
@@ -1,462 +0,0 @@
- -----------------
- Examples of Usage
- -----------------
-
-Preamble
-
- The simplicity in JOpt "Simple" arises from two guiding principles:
-
- * Stick as often as possible to supporting conventional Unix option syntaxes.
-
- * Keep the surface area of the published API as small and simple as possible.
-
- []
-
- To the first principle: You will not see support in JOpt Simple for option "groups",
- alternative option prefixes (<<<+>>>, <<</>>>), enforced multiplicity of option
- arguments, etc. JOpt Simple believes you can create a useful and understandable CLI
- without all that stuff. If you feel as though you need any of those features, there
- are lots of other choices out there. The author of JOpt Simple believes you'll want
- to leverage its easy configuration, parsing, and option interrogation APIs instead of
- using more feature-laden, but perhaps more confusing libraries.
-
- To the second principle: JOpt Simple will make every attempt to keep the API free
- of clutter. The API is well factored, making it intuitive to use, and the entire
- library is well tested, making it more reliable and predictable. If you cannot look
- at the Javadoc and quickly get a sense of what you need to do to use JOpt Simple,
- then JOpt Simple has failed. So by all means, let the author know what needs
- improved.
-
- With that said, let's take a tour through JOpt Simple's features.
-
-Options
-
- JOpt Simple supports short options and long options, using a syntax that attempts to
- take from the best of POSIX <<<getopt()>>> and GNU <<<getopt_long()>>>.
-
-* Short Options
-
- Short options begin with a single hyphen (<<<->>>) followed by a single letter or
- digit, or question mark (<<<?>>>), or dot (<<<.>>>).
-
-+----------------------------------------------------------------------------------------
-@SHORT_OPTIONS_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
- When you construct an <<<OptionParser>>> with a string of short option characters,
- you configure that parser to recognize the options with those characters.
-
-** Arguments of Options
-
- Short options can accept single arguments. The argument can be made required or
- optional. When you construct an <<<OptionParser>>> with a string of short option
- characters, append a single colon (<<<:>>>) to an option character to configure
- that option to require an argument. Append two colons (<<<::>>>) to an option
- character to configure that option to accept an optional argument. Append an
- asterisk (<<<*>>>) to an option character, but before any "argument" indicators,
- to configure that option as a "help" option.
-
- The syntax of the option specification string given to the <<<OptionParser>>>
- constructor should look familiar to you if you have used GNU's <<<getopt()>>>
- before.
-
-+----------------------------------------------------------------------------------------
-@SHORT_OPTIONS_WITH_ARGUMENTS_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-*** Specifying Arguments for a Short Option on the Command Line
-
- A short option's argument can occur:
-
- * in the position on the command line after the option
-
- * right up against the option
-
- * right up against the option separated by an equals sign (<<<=>>>)
-
- []
-
-+----------------------------------------------------------------------------------------
-@SHORT_OPTIONS_WITH_ARGUMENT_POSITIONING_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-*** Multiple Arguments for a Single Option
-
- To specify <n> arguments for a single option, specify the option <n> times on the
- command line, once for each argument. JOpt Simple reports the arguments given to the
- option in the order in which they were encountered on the command line.
-
-+----------------------------------------------------------------------------------------
-@SHORT_OPTIONS_WITH_MULTIPLE_ARGUMENTS_FOR_SINGLE_OPTION_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-** Clustering Short Options
-
- Short options can be <clustered> in a single argument.
-
-+----------------------------------------------------------------------------------------
-@SHORT_OPTIONS_CLUSTERING_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
- If one of the short options can accept an argument, the remaining characters are interpreted
- as the argument for that option.
-
-+----------------------------------------------------------------------------------------
-@SHORT_OPTIONS_CLUSTERING_WITH_ARGUMENT_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-* Long Options/Fluent Interface
-
- Long options begin with two hyphens (<<<-->>>), followed by multiple letters,
- digits, hyphens, question marks, or dots. A hyphen cannot be the first character of
- a long option specification when configuring the parser.
-
- Whereas short options can be configured using a constructor argument to
- <<<OptionParser>>>, both long and short options can be configured using a "fluent
- interface" API, that enables some very descriptive and powerful features.
-
-+----------------------------------------------------------------------------------------
-@LONG_OPTIONS_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-** Arguments of Options
-
- Like short options, long options can accept single arguments. The argument can be
- made required or optional. Use the methods <<<withRequiredArg()>>> and
- <<<withOptionalArg()>>> on the return value of <<<OptionParser.accepts()>>> to signal
- that an option takes a required or optional argument.
-
-+----------------------------------------------------------------------------------------
-@LONG_OPTIONS_WITH_ARGUMENTS_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-** Abbreviating Long Options
-
- Notice in the example above that the command line uses abbreviations of command line
- options. You can abbreviate options so long as the abbreviation is unambiguous.
- Even though you can abbreviate the options on the command line, you cannot address
- the <<<OptionSet>>> using those abbreviations. You can use a special constructor
- for the <<<OptionParser>>> that turns off abbreviation matching.
-
-** Using Single Hyphen on Long Options
-
- As demonstrated in the example above, you can use a single hyphen instead of a
- double hyphen to specify a long option -- but be careful that doing so doesn't
- introduce ambiguity.
-
-*** Specifying Arguments for a Long Option on the Command Line
-
- A long option's argument can occur:
-
- * in the position on the command line after the option
-
- * right up against the option separated by an equals sign (<<<=>>>)
-
- []
-
-+----------------------------------------------------------------------------------------
-@LONG_OPTIONS_WITH_ARGUMENT_POSITIONING_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-*** Multiple Arguments for a Single Option
-
- Specify multiple arguments for a long option in the same manner as for short options
- (see above).
-
-** Alternative Form of Long Options
-
- The option <<<-W>>> is reserved. If you tell the parser to recognize alternative
- long options, then it will treat, for example, <<<-W foo=bar>>> as the long option
- <<<foo>>> with argument bar, as though you had written <<<--foo=bar>>>.
-
- You can specify <<<-W>>> as a valid short option, or use it as an abbreviation for a
- long option, but recognizing alternative long options will always supersede this
- behavior.
-
- To recognize alternative long options, either construct an <<<OptionParser>>> with a
- string of short option characters containing the sequence <<<W;>>> (a capital W
- followed by a semicolon), or call the method
- <<<OptionParser.recognizeAlternativeLongOptions()>>>.
-
-+----------------------------------------------------------------------------------------
-@ALTERNATIVE_LONG_OPTIONS_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-* Other Features
-
-** Converting Option Arguments to Other Types
-
- Without action other than the <<<with*Arg()>>> methods, arguments of options are
- returned as <<<String>>>s. For backwards compatibility,
- <<<OptionSet.valueOf(String)>>> and <<<OptionSet.valuesOf(String)>>> return
- <<<Object>>> and <<<List<?>>>>, respectively, so to get the values out as
- <<<String>>>s, you will need to downcast the results of those methods.
-
- You can tell JOpt Simple to convert the arguments of options to different Java types
- via the <<<ofType()>>> method on the return value of <<<with*Arg()>>>. The
- <<<Class>>> argument of <<<ofType()>>> must represent a Java class that has either:
-
- * a <<<public static>>> method called <<<valueOf()>>> which accepts a single
- <<<String>>> argument and whose return type is the type itself, or
-
- * a <<<public>>> constructor which takes a single <<<String>>> argument.
-
- []
-
- If the class has both, the <<<valueOf()>>> method is used.
-
- Note that <<<enum>>>s have a <<<valueOf()>>> method.
-
-+----------------------------------------------------------------------------------------
-@OPTION_ARGUMENT_VALUE_TYPE_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
- Another way to convert arguments of options is to specify a converter object via
- <<<withValuesConvertedBy()>>>. This is useful when the desired type for the arguments
- does not meet the requirements that <<<ofType()>>> sets forth. Such objects may not
- perform any "conversion" at all, but rather can validate that arguments conform to
- certain restrictions before passing through as-is.
-
- You can also do this for the non-option arguments of your command line, if you desire
- to treat them all as a single type.
-
-+----------------------------------------------------------------------------------------
-@OPTION_ARGUMENT_CONVERTER_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-** Retrieving Arguments of Options in a Type-Safe Manner
-
- In the previous examples, we have been discarding the return values of the methods
- of JOpt Simple's fluent interface. If instead you retain them in variables of type
- <<<OptionSpec>>>, you can use them to retrieve arguments of options in a type-safe
- manner.
-
- You can also do this for the non-option arguments of your command line, if you desire
- to treat them all as a single type.
-
-+----------------------------------------------------------------------------------------
-@TYPESAFE_OPTION_ARGUMENT_RETRIEVAL_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-** Exporting Options and Arguments to other Code
-
- As an integration aid for other libraries, you can use <<<OptionSet.asMap()>>> to
- obtain a mapping of <<<OptionSpec>>> to option values, for example to create a
- properties map of options.
-
- Here is sample code to create properties whose keys have a common prefix. The key is
- choosen as the first non-short option:
-
-+----------------------------------------------------------------------------------------
-@EXPORTING_OPTIONS_AND_ARGUMENTS_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-** Default Values for Option Arguments
-
- Often it is convenient to specify default values for the arguments of certain
- command line options. To do this, call the <<<defaultsTo()>>> method.
-
-+----------------------------------------------------------------------------------------
-@DEFAULT_VALUES_FOR_OPTION_ARGUMENTS_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
- You can see that <<<defaultsTo()>>> should relieve you of the burden of having to
- check <<<has()>>> and/or <<<hasArgument()>>> on an <<<OptionSet>>> for a given option,
- and has no bearing on the return values of those methods. Specifying a default value
- for an option with a required argument does not mean that you can elide an argument for
- the option on the command line.
-
- The type of values <<<defaultsTo()>>> expects is dictated by the class given by a
- previous call to <<<ofType()>>> or <<<withValuesConvertedBy()>>>; if no such call has
- been made, the type is <<<String>>>.
-
-** "Required" Options
-
- You can indicate that a given option must be present on the command line via the
- <<<required()>>> method. Only options that accept arguments can be made "required".
-
- An option designated as a "help" option via <<<forHelp()>>>, when present on the
- command line, causes missing "required" options not to reject the command line.
-
-+----------------------------------------------------------------------------------------
-@REQUIRED_OPTIONS_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-** "Required" Dependent Options
-
- You can indicate that a given option must be present on the command line if some
- other option is present on the command line via the <<<requiredIf()>>> method.
- Any option can be made "required if".
-
- An option designated as a "help" option via <<<forHelp()>>>, when present on the
- command line, causes missing "required if" options not to reject the command line.
-
-+----------------------------------------------------------------------------------------
-@REQUIRED_IF_OPTIONS_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
- You can also indicate that a given option must be present on the command line if some
- other option is NOT present on the command line via the <<<requiredUnless()>>> method.
- Any option can be made "required unless", but, to avoid potential conflicts, it should
- not be "required if" at the same time.
-
-+----------------------------------------------------------------------------------------
-@REQUIRED_UNLESS_OPTIONS_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-** "Available" Dependent Options
-
- Similarly to <<<requiredIf()>>> and <<<requiredUnless()>>>, you can indicate that a
- given option can be present on the command line only if/unless some other option is
- present on the command line, via the <<<availableIf()>>> and <<<availableUnless()>>>
- methods.
-
-
-** Synonyms of Options
-
- Sometimes it is useful to allow many different options to share the same meaning in
- the program that uses them. To specify that options are to be treated as synonymous,
- use the <<<acceptsAll()>>> method of <<<OptionParser>>>.
-
-+----------------------------------------------------------------------------------------
-@OPTION_SYNONYM_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-** Concise Specification of Multiple Arguments for an Option
-
- Another way to specify multiple arguments for an option is to tell the parser to
- treat a single argument containing multiple delimited values as multiple arguments
- for the option using the <<<withValuesSeparatedBy()>>> method.
-
-+----------------------------------------------------------------------------------------
-@MULTIPLE_DELIMITED_ARGUMENTS_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-** Signalling End of Options
-
- An argument consisting only of two hyphens (<<<-->>>) signals that the remaining
- arguments are to be treated as non-options.
-
- An argument consisting only of a single hyphen is considered a non-option argument
- (though it can be an argument of an option). Many Unix programs treat single hyphens
- as stand-ins for the standard input or standard output stream.
-
-*** Non-Option Arguments
-
- Any arguments which are not options or arguments of options can be retrieved via
- method <<<nonOptionArguments()>>> on <<<OptionSet>>>. If the double hyphen is an
- argument, it is ignored and is not a non-option argument.
-
-+----------------------------------------------------------------------------------------
-@SIGNALLING_END_OF_OPTIONS_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-** "POSIX-ly Correct"-ness
-
- By default, as with GNU <<<getopt()>>>, JOpt Simple allows intermixing of options and
- non-options. If, however, the parser has been created to be "POSIX-ly correct", then
- the first argument that does not look lexically like an option, and is not a required
- argument of a preceding option, signals the end of options. You can still bind
- optional arguments to their options using the abutting (for short options) or
- <<<=>>> syntax.
-
- Unlike GNU <<<getopt()>>>, JOptSimple does not honor the environment variable
- <<<POSIXLY_CORRECT>>>. "POSIX-ly correct" parsers are configured by either:
-
- * using the method <<<OptionParser.posixlyCorrect()>>>
-
- * using the <<<OptionParser>>> constructor with an argument whose first character is
- a plus sign (<<<+>>>)
-
- []
-
-+----------------------------------------------------------------------------------------
-@POSIXLY_CORRECT_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-** Special Optional Argument Handling
-
- If the parser detects an option whose argument is optional, and the next argument
- "looks like" an option, that argument is not treated as the argument to the option,
- but as a potentially valid option. If, on the other hand, the optional argument is
- typed as a derivative of <<<Number>>>, then that argument is treated as the negative
- number argument of the option, even if the parser recognizes the corresponding numeric
- option.
-
-+----------------------------------------------------------------------------------------
-@SPECIAL_OPTIONAL_ARGUMENT_HANDLING_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
-Generating Command Line Help
-
- When you call method <<<OptionParser.printHelpOn()>>>, JOpt Simple will write a
- help screen (80-column width) describing all the options it is configured with,
- along with types of option arguments, whether the option is required (in angle
- brackets) or optional (in square brackets), etc. To give an option a description,
- use <<<OptionParser.accepts*()>>> with a description argument. To give an option
- argument a description, use <<<describedAs()>>> on the return value of
- <<<with*Arg()>>>.
-
-+----------------------------------------------------------------------------------------
-@HELP_SCREEN_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
- Here is what the help screen looks like for the example above:
-
-+----------------------------------------------------------------------------------------
-@HELP_SCREEN_EXAMPLE_HELP@
-+----------------------------------------------------------------------------------------
-
- If you want to create your own help screen, give method
- <<<OptionParser.formatHelpWith()>>> a <<<HelpFormatter>>> that builds the help screen
- as a String. When you call <<<OptionParser.printHelpOn()>>>, JOpt Simple will use
- your <<<HelpFormatter>>> to produce the help and write it to the given stream.
-
- For example, this program:
-
-+----------------------------------------------------------------------------------------
-@HELP_FORMATTER_EXAMPLE@
-+----------------------------------------------------------------------------------------
-
- yields the following output:
-
-+----------------------------------------------------------------------------------------
-@HELP_FORMATTER_EXAMPLE_OUTPUT@
-+----------------------------------------------------------------------------------------
-
-Handling Exceptions
-
- JOpt Simple's classes raise some derivative of <<<OptionException>>> if they encounter
- problems during parsing. These exceptions are unchecked, so you don't have to do
- anything with such an exception if you don't want to. The rationale behind this
- decision is that you will most likely be invoking JOpt Simple's functionality from a
- <<<main()>>> method or very near to it, where a failure such as unrecognized arguments
- can just stop down the JVM and yield a stack trace without much user or programmer
- inconvenience. So, without any exception handling at all, a user would see something
- like this:
-
-+----------------------------------------------------------------------------------------
-@EXAMPLE_STACK_TRACE@
-+----------------------------------------------------------------------------------------
-
- If you want to handle the exception yourself, you can catch <<<OptionException>>> in
- your code, and do whatever you please with the contents of the exception, perhaps
- using the help generation facility.
-
-* Suppressing <<<UnrecognizedOptionException>>>
-
- Sometimes you want to ignore unrecognized options on the command line.
-
- For example, you might be interested in handling only a part of the arguments given.
- Or you might want to pass on options to another program and not bother the user with
- providing two hyphens (<<<-->>>) to indicate the end of known options. Or maybe
- you want to provide future forwards/backwards compatibility when you foresee passing
- in new options to old code (or old code invoking new code with "old" arguments).
-
- You can achieve this by using the method <<<OptionParser.allowsUnrecognizedOptions()>>>.
- When you call this method, then any unrecognized options handed to <<<parse()>>> are
- treated as non-option arguments, rather than causing an exception to be raised.
-
-+----------------------------------------------------------------------------------------
-@UNRECOGNIZED_OPTIONS_ALLOWED_EXAMPLE@
-+----------------------------------------------------------------------------------------
diff --git a/third_party/java/jopt-simple/src/site/apt/index.apt b/third_party/java/jopt-simple/src/site/apt/index.apt
deleted file mode 100644
index 88c2af8..0000000
--- a/third_party/java/jopt-simple/src/site/apt/index.apt
+++ /dev/null
@@ -1,71 +0,0 @@
- -----------
- JOpt Simple
- -----------
-
- JOpt Simple is a Java library for parsing command line options, such as those you
- might pass to an invocation of <<<javac>>>.
-
- In the interest of striving for simplicity, as closely as possible JOpt Simple
- attempts to honor the command line option syntaxes of
- {{{http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap12.html} POSIX <<<getopt()>>>}}
- and
- GNU {{{http://www.gnu.org/software/libc/manual/html_node/Getopt-Long-Options.html} <<<getopt_long()>>>}}.
- It also aims to make option parser configuration and retrieval of options and their
- arguments simple and expressive, without being overly clever.
-
- Here are some libraries that perform the same duties as JOpt Simple:
-
- * {{{http://jargs.sourceforge.net} JArgs}}
-
- * {{{http://jakarta.apache.org/commons/cli/} Jakarta Commons CLI}}
-
- * {{{http://te-code.sourceforge.net/} TE-Code}} has a command line parsing library.
-
- * {{{http://www.cs.ubc.ca/spider/lloyd/java/argparser.html} argparser}}
-
- * {{{http://www.urbanophile.com/arenn/hacking/download.html} Java port of GNU getopt}}
-
- * {{{https://args4j.dev.java.net/} Args4J}}
-
- * {{{http://www.martiansoftware.com/jsap/} JSAP}}
-
- * {{{http://clajr.sourceforge.net} CLAJR}}
-
- * {{{http://ostermiller.org/utils/CmdLn.html} CmdLn}}
-
- * {{{http://jewelcli.sourceforge.net} JewelCli}}
-
- * {{{http://jcommando.sourceforge.net} JCommando}}
-
- * {{{http://code.google.com/p/parse-cmd/} parse-cmd}}
-
- * {{{http://jcommander.org} JCommander}}
-
- * {{{http://types.cs.washington.edu/plume-lib/api/plume/Options.html} plume-lib Options}}
-
- []
-
- I hope you'll agree that JOpt Simple tops them all in ease of use and cleanliness of
- code (although I admire JewelCli quite a bit).
-
- I'd love to hear your constructive {{{mailto:pholser@alumni.rice.edu} feedback}},
- especially suggestions for improvements to the library or the site! If your project
- is using JOpt Simple, do let me know.
-
-Projects Using JOpt Simple
-
- Here are some we know of or have known of:
-
- * {{{http://openjdk.java.net/} OpenJDK}}.
- From {{{http://weblogs.java.net/blog/mreinhold/} Mark Reinhold}}: "I thought you might
- be interested to know that we're using your jopt-simple library in the open-source
- Java Development Kit. Thanks for writing such a nice little library! It's far
- cleaner than any of the other alternatives out there."
-
- * {{{http://www.gradle.org/} Gradle}}
-
- * {{{http://natbraille.free.fr} NATBraille}}
-
- * {{{https://minecraft.net} Minecraft}}
-
- []
diff --git a/third_party/java/jopt-simple/src/site/resources/css/prettify.css b/third_party/java/jopt-simple/src/site/resources/css/prettify.css
deleted file mode 100644
index f8c7db2..0000000
--- a/third_party/java/jopt-simple/src/site/resources/css/prettify.css
+++ /dev/null
@@ -1,49 +0,0 @@
-/* Pretty printing styles. Used with prettify.js. */
-
-.str { color: #080; }
-.kwd { color: #008; }
-.com { color: #800; }
-.typ { color: #606; }
-.lit { color: #066; }
-.pun { color: #660; }
-.pln { color: #000; }
-.tag { color: #008; }
-.atn { color: #606; }
-.atv { color: #080; }
-.dec { color: #606; }
-
-pre.prettyprint {
- padding: 2px;
- border: 1px solid #888;
-}
-
-@media print {
- .str { color: #060; }
-
- .kwd {
- color: #006;
- font-weight: bold;
- }
-
- .com {
- color: #600;
- font-style: italic;
- }
-
- .typ {
- color: #404;
- font-weight: bold;
- }
-
- .lit { color: #044; }
- .pun { color: #440; }
- .pln { color: #000; }
-
- .tag {
- color: #006;
- font-weight: bold;
- }
-
- .atn { color: #404; }
- .atv { color: #060; }
-}
diff --git a/third_party/java/jopt-simple/src/site/resources/images/jopt-simple-logo.png b/third_party/java/jopt-simple/src/site/resources/images/jopt-simple-logo.png
deleted file mode 100644
index 4a3f707..0000000
--- a/third_party/java/jopt-simple/src/site/resources/images/jopt-simple-logo.png
+++ /dev/null
Binary files differ
diff --git a/third_party/java/jopt-simple/src/site/resources/scripts/prettify.js b/third_party/java/jopt-simple/src/site/resources/scripts/prettify.js
deleted file mode 100644
index de1e07f..0000000
--- a/third_party/java/jopt-simple/src/site/resources/scripts/prettify.js
+++ /dev/null
@@ -1,1602 +0,0 @@
-// Copyright (C) 2006 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-
-/**
- * @fileoverview
- * some functions for browser-side pretty printing of code contained in html.
- *
- * The lexer should work on a number of languages including C and friends,
- * Java, Python, Bash, SQL, HTML, XML, CSS, Javascript, and Makefiles.
- * It works passably on Ruby, PHP and Awk and a decent subset of Perl, but,
- * because of commenting conventions, doesn't work on Smalltalk, Lisp-like, or
- * CAML-like languages.
- *
- * If there's a language not mentioned here, then I don't know it, and don't
- * know whether it works. If it has a C-like, Bash-like, or XML-like syntax
- * then it should work passably.
- *
- * Usage:
- * 1) include this source file in an html page via
- * <script type="text/javascript" src="/path/to/prettify.js"></script>
- * 2) define style rules. See the example page for examples.
- * 3) mark the <pre> and <code> tags in your source with class=prettyprint.
- * You can also use the (html deprecated) <xmp> tag, but the pretty printer
- * needs to do more substantial DOM manipulations to support that, so some
- * css styles may not be preserved.
- * That's it. I wanted to keep the API as simple as possible, so there's no
- * need to specify which language the code is in.
- *
- * Change log:
- * cbeust, 2006/08/22
- * Java annotations (start with "@") are now captured as literals ("lit")
- */
-
-var PR_keywords = {};
-/** initialize the keyword list for our target languages. */
-(function () {
- var CPP_KEYWORDS = "abstract bool break case catch char class const " +
- "const_cast continue default delete deprecated dllexport dllimport do " +
- "double dynamic_cast else enum explicit extern false float for friend " +
- "goto if inline int long mutable naked namespace new noinline noreturn " +
- "nothrow novtable operator private property protected public register " +
- "reinterpret_cast return selectany short signed sizeof static " +
- "static_cast struct switch template this thread throw true try typedef " +
- "typeid typename union unsigned using declaration, directive uuid " +
- "virtual void volatile while typeof";
- var CSHARP_KEYWORDS = "as base by byte checked decimal delegate descending " +
- "event finally fixed foreach from group implicit in interface internal " +
- "into is lock null object out override orderby params readonly ref sbyte " +
- "sealed stackalloc string select uint ulong unchecked unsafe ushort var";
- var JAVA_KEYWORDS = "package synchronized boolean implements import throws " +
- "instanceof transient extends final strictfp native super";
- var JSCRIPT_KEYWORDS = "debugger export function with NaN Infinity";
- var PERL_KEYWORDS = "require sub unless until use elsif BEGIN END";
- var PYTHON_KEYWORDS = "and assert def del elif except exec global lambda " +
- "not or pass print raise yield False True None";
- var RUBY_KEYWORDS = "then end begin rescue ensure module when undef next " +
- "redo retry alias defined";
- var SH_KEYWORDS = "done fi";
-
- var KEYWORDS = [CPP_KEYWORDS, CSHARP_KEYWORDS, JAVA_KEYWORDS,
- JSCRIPT_KEYWORDS, PERL_KEYWORDS, PYTHON_KEYWORDS,
- RUBY_KEYWORDS, SH_KEYWORDS];
- for ( var k = 0; k < KEYWORDS.length; k++ ) {
- var kw = KEYWORDS[k].split(' ');
- for ( var i = 0; i < kw.length; i++ ) {
- if ( kw[i] ) {
- PR_keywords[kw[i]] = true;
- }
- }
- }
-}).call(this);
-
-// token style names. correspond to css classes
-/** token style for a string literal */
-var PR_STRING = 'str';
-/** token style for a keyword */
-var PR_KEYWORD = 'kwd';
-/** token style for a comment */
-var PR_COMMENT = 'com';
-/** token style for a type */
-var PR_TYPE = 'typ';
-/** token style for a literal value. e.g. 1, null, true. */
-var PR_LITERAL = 'lit';
-/** token style for a punctuation string. */
-var PR_PUNCTUATION = 'pun';
-/** token style for a punctuation string. */
-var PR_PLAIN = 'pln';
-
-/** token style for an sgml tag. */
-var PR_TAG = 'tag';
-/** token style for a markup declaration such as a DOCTYPE. */
-var PR_DECLARATION = 'dec';
-/** token style for embedded source. */
-var PR_SOURCE = 'src';
-/** token style for an sgml attribute name. */
-var PR_ATTRIB_NAME = 'atn';
-/** token style for an sgml attribute value. */
-var PR_ATTRIB_VALUE = 'atv';
-
-/** the number of characters between tab columns */
-var PR_TAB_WIDTH = 8;
-
-/** the position of the end of a token during. A division of a string into
- * n tokens can be represented as a series n - 1 token ends, as long as
- * runs of whitespace warrant their own token.
- * @private
- */
-function PR_TokenEnd( end, style ) {
- if ( undefined === style ) {
- throw new Error('BAD');
- }
- if ( 'number' != typeof(end) ) {
- throw new Error('BAD');
- }
- this.end = end;
- this.style = style;
-}
-PR_TokenEnd.prototype.toString = function () {
- return '[PR_TokenEnd ' + this.end +
- (this.style ? ':' + this.style : '') + ']';
-};
-
-/** a chunk of text with a style. These are used to represent both the output
- * from the lexing functions as well as intermediate results.
- * @constructor
- * @param token the token text
- * @param style one of the token styles defined in designdoc-template, or null
- * for a styleless token, such as an embedded html tag.
- * @private
- */
-function PR_Token( token, style ) {
- if ( undefined === style ) {
- throw new Error('BAD');
- }
- this.token = token;
- this.style = style;
-}
-
-PR_Token.prototype.toString = function () {
- return '[PR_Token ' + this.token + (this.style ? ':' + this.style : '') + ']';
-};
-
-/** a helper class that decodes common html entities used to escape special
- * characters in source code.
- * @constructor
- * @private
- */
-function PR_DecodeHelper() {
- this.next = 0;
- this.ch = '\0';
-}
-
-var PR_NAMED_ENTITIES = {
- 'lt': '<',
- 'gt': '>',
- 'quot': '"',
- 'apos': "'",
- 'amp': '&' // reencoding requires that & always be decoded properly
-};
-
-PR_DecodeHelper.prototype.decode = function ( s, i ) {
- var next = i + 1;
- var ch = s.charAt(i);
- if ( '&' === ch ) {
- var semi = s.indexOf(';', next);
- if ( semi >= 0 && semi < next + 4 ) {
- var entityName = s.substring(next, semi);
- var decoded = null;
- if ( entityName.charAt(0) === '#' ) { // check for numeric entity
- var ch1 = entityName.charAt(1);
- var charCode;
- if ( ch1 === 'x' || ch1 === 'X' ) { // like  
- charCode = parseInt(entityName.substring(2), 16);
- }
- else { // like  
- charCode = parseInt(entityName.substring(1), 10);
- }
- if ( !isNaN(charCode) ) {
- decoded = String.fromCharCode(charCode);
- }
- }
- if ( !decoded ) {
- decoded = PR_NAMED_ENTITIES[entityName.toLowerCase()];
- }
- if ( decoded ) {
- ch = decoded;
- next = semi + 1;
- }
- else { // skip over unrecognized entity
- next = i + 1;
- ch = '\0';
- }
- }
- }
- this.next = next;
- this.ch = ch;
- return this.ch;
-};
-
-// some string utilities
-function PR_isWordChar( ch ) {
- return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
-}
-
-function PR_isIdentifierStart( ch ) {
- return PR_isWordChar(ch) || ch == '_' || ch == '$' || ch == '@';
-}
-
-function PR_isIdentifierPart( ch ) {
- return PR_isIdentifierStart(ch) || PR_isDigitChar(ch);
-}
-
-function PR_isSpaceChar( ch ) {
- return "\t \r\n".indexOf(ch) >= 0;
-}
-
-function PR_isDigitChar( ch ) {
- return ch >= '0' && ch <= '9';
-}
-
-function PR_trim( s ) {
- var i = 0, j = s.length - 1;
- while ( i <= j && PR_isSpaceChar(s.charAt(i)) ) {
- ++i;
- }
- while ( j > i && PR_isSpaceChar(s.charAt(j)) ) {
- --j;
- }
- return s.substring(i, j + 1);
-}
-
-function PR_startsWith( s, prefix ) {
- return s.length >= prefix.length && prefix == s.substring(0, prefix.length);
-}
-
-function PR_endsWith( s, suffix ) {
- return s.length >= suffix.length &&
- suffix == s.substring(s.length - suffix.length, s.length);
-}
-
-/** true iff prefix matches the first prefix characters in chars[0:len].
- * @private
- */
-function PR_prefixMatch( chars, len, prefix ) {
- if ( len < prefix.length ) {
- return false;
- }
- for ( var i = 0, n = prefix.length; i < n; ++i ) {
- if ( prefix.charAt(i) != chars[i] ) {
- return false;
- }
- }
- return true;
-}
-
-/** like textToHtml but escapes double quotes to be attribute safe. */
-function PR_attribToHtml( str ) {
- return str.replace(/&/g, '&')
- .replace(/</g, '<')
- .replace(/>/g, '>')
- .replace(/\"/g, '"')
- .replace(/\xa0/, ' ');
-}
-
-/** escapest html special characters to html. */
-function PR_textToHtml( str ) {
- return str.replace(/&/g, '&')
- .replace(/</g, '<')
- .replace(/>/g, '>')
- .replace(/\xa0/g, ' ');
-}
-
-/** is the given node's innerHTML normally unescaped? */
-function PR_isRawContent( node ) {
- return 'XMP' == node.tagName;
-}
-
-var PR_innerHtmlWorks = null;
-function PR_getInnerHtml( node ) {
- // inner html is hopelessly broken in Safari 2.0.4 when the content is
- // an html description of well formed XML and the containing tag is a PRE
- // tag, so we detect that case and emulate innerHTML.
- if ( null == PR_innerHtmlWorks ) {
- var testNode = document.createElement('PRE');
- testNode.appendChild(
- document.createTextNode('<!DOCTYPE foo PUBLIC "foo bar">\n<foo />'));
- PR_innerHtmlWorks = !/</.test(testNode.innerHTML);
- }
-
- if ( PR_innerHtmlWorks ) {
- var content = node.innerHTML;
- // XMP tags contain unescaped entities so require special handling.
- if ( PR_isRawContent(node) ) {
- content = PR_textToHtml(content);
- }
- return content;
- }
-
- var out = [];
- for ( var child = node.firstChild; child; child = child.nextSibling ) {
- PR_normalizedHtml(child, out);
- }
- return out.join('');
-}
-
-/**
- * walks the DOM returning a properly escaped version of innerHTML.
- */
-function PR_normalizedHtml( node, out ) {
- switch ( node.nodeType ) {
- case 1: // an element
- var name = node.tagName.toLowerCase();
- out.push('\074', name);
- for ( var i = 0; i < node.attributes.length; ++i ) {
- var attr = node.attributes[i];
- if ( !attr.specified ) {
- continue;
- }
- out.push(' ');
- PR_normalizedHtml(attr, out);
- }
- out.push('>');
- for ( var child = node.firstChild; child; child = child.nextSibling ) {
- PR_normalizedHtml(child, out);
- }
- if ( node.firstChild || !/^(?:br|link|img)$/.test(name) ) {
- out.push('<\/', name, '>');
- }
- break;
- case 2: // an attribute
- out.push(node.name.toLowerCase(), '="', PR_attribToHtml(node.value), '"');
- break;
- case 3: case 4: // text
- out.push(PR_textToHtml(node.nodeValue));
- break;
- }
-}
-
-/** expand tabs to spaces
- * @param {Array} chunks PR_Tokens possibly containing tabs
- * @param {Number} tabWidth number of spaces between tab columns
- * @return {Array} chunks with tabs replaced with spaces
- */
-function PR_expandTabs( chunks, tabWidth ) {
- var SPACES = ' ';
-
- var charInLine = 0;
- var decodeHelper = new PR_DecodeHelper();
-
- var chunksOut = []
- for ( var chunkIndex = 0; chunkIndex < chunks.length; ++chunkIndex ) {
- var chunk = chunks[chunkIndex];
- if ( chunk.style == null ) {
- chunksOut.push(chunk);
- continue;
- }
-
- var s = chunk.token;
- var pos = 0;
- // index of last character output
- var out = [];
-
- // walk over each character looking for tabs and newlines.
- // On tabs, expand them. On newlines, reset charInLine.
- // Otherwise increment charInLine
- for ( var charIndex = 0, n = s.length; charIndex < n;
- charIndex = decodeHelper.next ) {
- decodeHelper.decode(s, charIndex);
- var ch = decodeHelper.ch;
-
- switch ( ch ) {
- case '\t':
- out.push(s.substring(pos, charIndex));
- // calculate how much space we need in front of this part
- // nSpaces is the amount of padding -- the number of spaces needed to
- // move us to the next column, where columns occur at factors of
- // tabWidth.
- var nSpaces = tabWidth - (charInLine % tabWidth);
- charInLine += nSpaces;
- for ( ; nSpaces >= 0; nSpaces -= SPACES.length ) {
- out.push(SPACES.substring(0, nSpaces));
- }
- pos = decodeHelper.next;
- break;
- case '\n': case '\r':
- charInLine = 0;
- break;
- default:
- ++charInLine;
- }
- }
- out.push(s.substring(pos));
- chunksOut.push(new PR_Token(out.join(''), chunk.style));
- }
- return chunksOut
-}
-
-/** split markup into chunks of html tags (style null) and
- * plain text (style {@link #PR_PLAIN}).
- *
- * @param {String} s html.
- * @return {Array} of PR_Tokens of style PR_PLAIN, and null.
- * @private
- */
-function PR_chunkify( s ) {
- // The below pattern matches one of the following
- // (1) /[^<]+/ : A run of characters other than '<'
- // (2) /<\/?[a-zA-Z][^>]*>/ : A probably tag that should not be highlighted
- // (3) /</ : A '<' that does not begin a larger chunk. Treated as 1
- var chunkPattern = /(?:[^<]+|<\/?[a-zA-Z][^>]*>|<)/g;
- // since the pattern has the 'g' modifier and defines no capturing groups,
- // this will return a list of all chunks which we then classify and wrap as
- // PR_Tokens
- var matches = s.match(chunkPattern);
- var chunks = [];
- if ( matches ) {
- var lastChunk = null;
- for ( var i = 0, n = matches.length; i < n; ++i ) {
- var chunkText = matches[i];
- var style;
- if ( chunkText.length < 2 || chunkText.charAt(0) !== '<' ) {
- if ( lastChunk && lastChunk.style === PR_PLAIN ) {
- lastChunk.token += chunkText;
- continue;
- }
- style = PR_PLAIN;
- }
- else { // a tag
- style = null;
- }
- lastChunk = new PR_Token(chunkText, style);
- chunks.push(lastChunk);
- }
- }
- return chunks;
-}
-
-/** walk the tokenEnds list and the chunk list in parallel to generate a list
- * of split tokens.
- * @private
- */
-function PR_splitChunks( chunks, tokenEnds ) {
- var tokens = [];
- // the output
-
- var ci = 0;
- // index into chunks
- // position of beginning of amount written so far in absolute space.
- var posAbs = 0;
- // position of amount written so far in chunk space
- var posChunk = 0;
-
- // current chunk
- var chunk = new PR_Token('', null);
-
- for ( var ei = 0, ne = tokenEnds.length, lastEnd = 0; ei < ne; ++ei ) {
- var tokenEnd = tokenEnds[ei];
- var end = tokenEnd.end;
- if ( end === lastEnd ) {
- continue;
- } // skip empty regions
-
- var tokLen = end - posAbs;
- var remainingInChunk = chunk.token.length - posChunk;
- while ( remainingInChunk <= tokLen ) {
- if ( remainingInChunk > 0 ) {
- tokens.push(
- new PR_Token(chunk.token.substring(posChunk, chunk.token.length),
- null == chunk.style ? null : tokenEnd.style));
- }
- posAbs += remainingInChunk;
- posChunk = 0;
- if ( ci < chunks.length ) {
- chunk = chunks[ci++];
- }
-
- tokLen = end - posAbs;
- remainingInChunk = chunk.token.length - posChunk;
- }
-
- if ( tokLen ) {
- tokens.push(
- new PR_Token(chunk.token.substring(posChunk, posChunk + tokLen),
- tokenEnd.style));
- posAbs += tokLen;
- posChunk += tokLen;
- }
- }
-
- return tokens;
-}
-
-/** splits markup tokens into declarations, tags, and source chunks.
- * @private
- */
-function PR_splitMarkup( chunks ) {
- // A state machine to split out declarations, tags, etc.
- // This state machine deals with absolute space in the text, indexed by k,
- // and position in the current chunk, indexed by pos and tokenStart to
- // generate a list of the ends of tokens.
- // Absolute space is calculated by considering the chunks as appended into
- // one big string, as they were before being split.
-
- // Known failure cases
- // Server side scripting sections such as <?...?> in attributes.
- // i.e. <span class="<? foo ?>">
- // Handling this would require a stack, and we don't use PHP.
-
- // The output: a list of pairs of PR_TokenEnd instances
- var tokenEnds = [];
-
- var state = 0;
- // FSM state variable
- var k = 0;
- // position in absolute space of the start of the current chunk
- var tokenStart = -1;
- // the start of the current token
-
- // Try to find a closing tag for any open <style> or <script> tags
- // We can't do this at a later stage because then the following case
- // would fail:
- // <script>document.writeln('<!--');</script>
-
- // We use tokenChars[:tokenCharsI] to accumulate the tag name so that we
- // can check whether to enter into a no scripting section when the tag ends.
- var tokenChars = new Array(12);
- var tokenCharsI = 0;
- // if non null, the tag prefix that we need to see to break out.
- var endScriptTag = null;
- var decodeHelper = new PR_DecodeHelper();
-
- for ( var ci = 0, nc = chunks.length; ci < nc; ++ci ) {
- var chunk = chunks[ci];
- if ( PR_PLAIN != chunk.style ) {
- k += chunk.token.length;
- continue;
- }
-
- var s = chunk.token;
- var pos = 0;
- // the position past the last character processed so far in s
-
- for ( var i = 0, n = s.length; i < n; /* i = next at bottom */ ) {
- decodeHelper.decode(s, i);
- var ch = decodeHelper.ch;
- var next = decodeHelper.next;
-
- var tokenStyle = null;
- switch ( state ) {
- case 0:
- if ( '<' == ch ) {
- state = 1;
- }
- break;
- case 1:
- tokenCharsI = 0;
- if ( '/' == ch ) { // only consider close tags if we're in script/style
- state = 7;
- }
- else if ( null == endScriptTag ) {
- if ( '!' == ch ) {
- state = 2;
- }
- else if ( PR_isWordChar(ch) ) {
- state = 8;
- }
- else if ( '?' == ch ) {
- state = 9;
- }
- else if ( '%' == ch ) {
- state = 11;
- }
- else if ( '<' != ch ) {
- state = 0;
- }
- }
- else if ( '<' != ch ) {
- state = 0;
- }
- break;
- case 2:
- if ( '-' == ch ) {
- state = 4;
- }
- else if ( PR_isWordChar(ch) ) {
- state = 3;
- }
- else if ( '<' == ch ) {
- state = 1;
- }
- else {
- state = 0;
- }
- break;
- case 3:
- if ( '>' == ch ) {
- state = 0;
- tokenStyle = PR_DECLARATION;
- }
- break;
- case 4:
- if ( '-' == ch ) {
- state = 5;
- }
- break;
- case 5:
- if ( '-' == ch ) {
- state = 6;
- }
- break;
- case 6:
- if ( '>' == ch ) {
- state = 0;
- tokenStyle = PR_COMMENT;
- }
- else if ( '-' == ch ) {
- state = 6;
- }
- else {
- state = 4;
- }
- break;
- case 7:
- if ( PR_isWordChar(ch) ) {
- state = 8;
- }
- else if ( '<' == ch ) {
- state = 1;
- }
- else {
- state = 0;
- }
- break;
- case 8:
- if ( '>' == ch ) {
- state = 0;
- tokenStyle = PR_TAG;
- }
- break;
- case 9:
- if ( '?' == ch ) {
- state = 10;
- }
- break;
- case 10:
- if ( '>' == ch ) {
- state = 0;
- tokenStyle = PR_SOURCE;
- }
- else if ( '?' != ch ) {
- state = 9;
- }
- break;
- case 11:
- if ( '%' == ch ) {
- state = 12;
- }
- break;
- case 12:
- if ( '>' == ch ) {
- state = 0;
- tokenStyle = PR_SOURCE;
- }
- else if ( '%' != ch ) {
- state = 11;
- }
- break;
- }
-
- if ( tokenCharsI < tokenChars.length ) {
- tokenChars[tokenCharsI++] = ch.toLowerCase();
- }
- if ( 1 == state ) {
- tokenStart = k + i;
- }
- i = next;
- if ( tokenStyle != null ) {
- if ( null != tokenStyle ) {
- if ( endScriptTag ) {
- if ( PR_prefixMatch(tokenChars, tokenCharsI, endScriptTag) ) {
- endScriptTag = null;
- }
- }
- else {
- if ( PR_prefixMatch(tokenChars, tokenCharsI, 'script') ) {
- endScriptTag = '/script';
- }
- else if ( PR_prefixMatch(tokenChars, tokenCharsI, 'style') ) {
- endScriptTag = '/style';
- }
- else if ( PR_prefixMatch(tokenChars, tokenCharsI, 'xmp') ) {
- endScriptTag = '/xmp';
- }
- }
- // disallow the tag if endScriptTag is set and this was not an open
- // tag.
- if ( endScriptTag && tokenCharsI && '/' == tokenChars[0] ) {
- tokenStyle = null;
- }
- }
- if ( null != tokenStyle ) {
- tokenEnds.push(new PR_TokenEnd(tokenStart, PR_PLAIN));
- tokenEnds.push(new PR_TokenEnd(k + next, tokenStyle));
- }
- }
- }
- k += chunk.token.length;
- }
- tokenEnds.push(new PR_TokenEnd(k, PR_PLAIN));
-
- return tokenEnds;
-}
-
-/** splits the given string into comment, string, and "other" tokens.
- * @return {Array} of PR_Tokens with style in
- * (PR_STRING, PR_COMMENT, PR_PLAIN, null)
- * The result array may contain spurious zero length tokens. Ignore them.
- *
- * @private
- */
-function PR_splitStringAndCommentTokens( chunks ) {
- // a state machine to split out comments, strings, and other stuff
- var tokenEnds = [];
- // positions of ends of tokens in absolute space
- var state = 0;
- // FSM state variable
- var delim = -1;
- // string delimiter
- var k = 0;
- // absolute position of beginning of current chunk
-
- for ( var ci = 0, nc = chunks.length; ci < nc; ++ci ) {
- var chunk = chunks[ci];
- var s = chunk.token;
- if ( PR_PLAIN == chunk.style ) {
- var decodeHelper = new PR_DecodeHelper();
- var last = -1;
- var next;
- for ( var i = 0, n = s.length; i < n; last = i,i = next ) {
- decodeHelper.decode(s, i);
- var ch = decodeHelper.ch;
- next = decodeHelper.next;
- if ( 0 == state ) {
- if ( ch == '"' || ch == '\'' || ch == '`' ) {
- tokenEnds.push(new PR_TokenEnd(k + i, PR_PLAIN));
- state = 1;
- delim = ch;
- }
- else if ( ch == '/' ) {
- state = 3;
- }
- else if ( ch == '#' ) {
- tokenEnds.push(new PR_TokenEnd(k + i, PR_PLAIN));
- state = 4;
- }
- }
- else if ( 1 == state ) {
- if ( ch == delim ) {
- state = 0;
- tokenEnds.push(new PR_TokenEnd(k + next, PR_STRING));
- }
- else if ( ch == '\\' ) {
- state = 2;
- }
- }
- else if ( 2 == state ) {
- state = 1;
- }
- else if ( 3 == state ) {
- if ( ch == '/' ) {
- state = 4;
- tokenEnds.push(new PR_TokenEnd(k + last, PR_PLAIN));
- }
- else if ( ch == '*' ) {
- state = 5;
- tokenEnds.push(new PR_TokenEnd(k + last, PR_PLAIN));
- }
- else {
- state = 0;
- // next loop will reenter state 0 without same value of i, so
- // ch will be reconsidered as start of new token.
- next = i;
- }
- }
- else if ( 4 == state ) {
- if ( ch == '\r' || ch == '\n' ) {
- state = 0;
- tokenEnds.push(new PR_TokenEnd(k + i, PR_COMMENT));
- }
- }
- else if ( 5 == state ) {
- if ( ch == '*' ) {
- state = 6;
- }
- }
- else if ( 6 == state ) {
- if ( ch == '/' ) {
- state = 0;
- tokenEnds.push(new PR_TokenEnd(k + next, PR_COMMENT));
- }
- else if ( ch != '*' ) {
- state = 5;
- }
- }
- }
- }
- k += s.length;
- }
- var endTokenType;
- switch ( state ) {
- case 1: case 2:
- endTokenType = PR_STRING;
- break;
- case 4: case 5: case 6:
- endTokenType = PR_COMMENT;
- break;
- default:
- endTokenType = PR_PLAIN;
- break;
- }
- // handle unclosed token which can legally happen for line comments (state 4)
- tokenEnds.push(new PR_TokenEnd(k, endTokenType));
- // a token ends at the end
-
- return PR_splitChunks(chunks, tokenEnds);
-}
-
-/** used by lexSource to split a non string, non comment token.
- * @private
- */
-function PR_splitNonStringNonCommentToken( s, outlist ) {
- var pos = 0;
- var state = 0;
-
- var decodeHelper = new PR_DecodeHelper();
- var next;
- for ( var i = 0; i <= s.length; i = next ) {
- if ( i == s.length ) {
- // nstate will not be equal to state, so it will append the token
- nstate = -2;
- next = i + 1;
- }
- else {
- decodeHelper.decode(s, i);
- next = decodeHelper.next;
- var ch = decodeHelper.ch;
-
- // the next state.
- // if set to -1 then it will cause a reentry to state 0 without consuming
- // another character.
- var nstate = state;
-
- switch ( state ) {
- case 0: // whitespace state
- if ( PR_isIdentifierStart(ch) ) {
- nstate = 1;
- }
- else if ( PR_isDigitChar(ch) ) {
- nstate = 2;
- }
- else if ( !PR_isSpaceChar(ch) ) {
- nstate = 3;
- }
- if ( nstate && pos < i ) {
- var t = s.substring(pos, i);
- outlist.push(new PR_Token(t, PR_PLAIN));
- pos = i;
- }
- break;
- case 1: // identifier state
- if ( !PR_isIdentifierPart(ch) ) {
- nstate = -1;
- }
- break;
- case 2: // number literal state
- // handle numeric literals like
- // 0x7f 300UL 100_000
-
- // this does not treat floating point values as a single literal
- // 0.1 and 3e-6
- // are each split into multiple tokens
- if ( !(PR_isDigitChar(ch) || PR_isWordChar(ch) || ch == '_') ) {
- nstate = -1;
- }
- break;
- case 3: // punctuation state
- if ( PR_isIdentifierStart(ch) || PR_isDigitChar(ch) ||
- PR_isSpaceChar(ch) ) {
- nstate = -1;
- }
- break;
- }
- }
-
- if ( nstate != state ) {
- if ( nstate < 0 ) {
- if ( i > pos ) {
- var t = s.substring(pos, i);
- var wordDecodeHelper = new PR_DecodeHelper();
- wordDecodeHelper.decode(t, 0);
- var ch0 = wordDecodeHelper.ch;
- var isSingleCharacter = wordDecodeHelper.next == t.length;
- var style;
- if ( PR_isIdentifierStart(ch0) ) {
- if ( PR_keywords[t] ) {
- style = PR_KEYWORD;
- }
- else if ( ch0 === '@' ) {
- style = PR_LITERAL;
- }
- else {
- // Treat any word that starts with an uppercase character and
- // contains at least one lowercase character as a type, or
- // ends with _t.
- // This works perfectly for Java, pretty well for C++, and
- // passably for Python. The _t catches C structs.
- var isType = false;
- if ( ch0 >= 'A' && ch0 <= 'Z' ) {
- for ( var j = wordDecodeHelper.next;
- j < t.length; j = wordDecodeHelper.next ) {
- wordDecodeHelper.decode(t, j);
- var ch1 = wordDecodeHelper.ch;
- if ( ch1 >= 'a' && ch1 <= 'z' ) {
- isType = true;
- break;
- }
- }
- if ( !isType && !isSingleCharacter &&
- t.substring(t.length - 2) == '_t' ) {
- isType = true;
- }
- }
- style = isType ? PR_TYPE : PR_PLAIN;
- }
- }
- else if ( PR_isDigitChar(ch0) ) {
- style = PR_LITERAL;
- }
- else if ( !PR_isSpaceChar(ch0) ) {
- style = PR_PUNCTUATION;
- }
- else {
- style = PR_PLAIN;
- }
- pos = i;
- outlist.push(new PR_Token(t, style));
- }
-
- state = 0;
- if ( nstate == -1 ) {
- // don't increment. This allows us to use state 0 to redispatch based
- // on the current character.
- next = i;
- continue;
- }
- }
- state = nstate;
- }
- }
-
-}
-
-/** split a group of chunks of markup.
- * @private
- */
-function PR_tokenizeMarkup( chunks ) {
- if ( !(chunks && chunks.length) ) {
- return chunks;
- }
-
- var tokenEnds = PR_splitMarkup(chunks);
- return PR_splitChunks(chunks, tokenEnds);
-}
-
-/** split tags attributes and their values out from the tag name, and
- * recursively lex source chunks.
- * @private
- */
-function PR_splitTagAttributes( tokens ) {
- var tokensOut = [];
- var state = 0;
- var stateStyle = PR_TAG;
- var delim = null;
- // attribute delimiter for quoted value state.
- var decodeHelper = new PR_DecodeHelper();
- for ( var ci = 0; ci < tokens.length; ++ci ) {
- var tok = tokens[ci];
- if ( PR_TAG == tok.style ) {
- var s = tok.token;
- var start = 0;
- for ( var i = 0; i < s.length; /* i = next at bottom */ ) {
- decodeHelper.decode(s, i);
- var ch = decodeHelper.ch;
- var next = decodeHelper.next;
-
- var emitEnd = null;
- // null or position of end of chunk to emit.
- var nextStyle = null;
- // null or next value of stateStyle
- if ( ch == '>' ) {
- if ( PR_TAG != stateStyle ) {
- emitEnd = i;
- nextStyle = PR_TAG;
- }
- }
- else {
- switch ( state ) {
- case 0:
- if ( '<' == ch ) {
- state = 1;
- }
- break;
- case 1:
- if ( PR_isSpaceChar(ch) ) {
- state = 2;
- }
- break;
- case 2:
- if ( !PR_isSpaceChar(ch) ) {
- nextStyle = PR_ATTRIB_NAME;
- emitEnd = i;
- state = 3;
- }
- break;
- case 3:
- if ( '=' == ch ) {
- emitEnd = i;
- nextStyle = PR_TAG;
- state = 5;
- }
- else if ( PR_isSpaceChar(ch) ) {
- emitEnd = i;
- nextStyle = PR_TAG;
- state = 4;
- }
- break;
- case 4:
- if ( '=' == ch ) {
- state = 5;
- }
- else if ( !PR_isSpaceChar(ch) ) {
- emitEnd = i;
- nextStyle = PR_ATTRIB_NAME;
- state = 3;
- }
- break;
- case 5:
- if ( '"' == ch || '\'' == ch ) {
- emitEnd = i;
- nextStyle = PR_ATTRIB_VALUE;
- state = 6;
- delim = ch;
- }
- else if ( !PR_isSpaceChar(ch) ) {
- emitEnd = i;
- nextStyle = PR_ATTRIB_VALUE;
- state = 7;
- }
- break;
- case 6:
- if ( ch == delim ) {
- emitEnd = next;
- nextStyle = PR_TAG;
- state = 2;
- }
- break;
- case 7:
- if ( PR_isSpaceChar(ch) ) {
- emitEnd = i;
- nextStyle = PR_TAG;
- state = 2;
- }
- break;
- }
- }
- if ( emitEnd ) {
- if ( emitEnd > start ) {
- tokensOut.push(
- new PR_Token(s.substring(start, emitEnd), stateStyle));
- start = emitEnd;
- }
- stateStyle = nextStyle;
- }
- i = next;
- }
- if ( s.length > start ) {
- tokensOut.push(new PR_Token(s.substring(start, s.length), stateStyle));
- }
- }
- else {
- if ( tok.style ) {
- state = 0;
- stateStyle = PR_TAG;
- }
- tokensOut.push(tok);
- }
- }
- return tokensOut;
-}
-
-/** identify regions of markup that are really source code, and recursivley
- * lex them.
- * @private
- */
-function PR_splitSourceNodes( tokens ) {
- var tokensOut = [];
- // when we see a <script> tag, store '/' here so that we know to end the
- // source processing
- var endScriptTag = null;
- var decodeHelper = new PR_DecodeHelper();
-
- var sourceChunks = null;
-
- for ( var ci = 0, nc = tokens.length; /* break below */; ++ci ) {
- var tok;
-
- if ( ci < nc ) {
- tok = tokens[ci];
- if ( null == tok.style ) {
- tokens.push(tok);
- continue;
- }
- }
- else if ( !endScriptTag ) {
- break;
- }
- else {
- // else pretend there's an end tag so we can gracefully handle
- // unclosed source blocks
- tok = new PR_Token('', null);
- }
-
- var s = tok.token;
-
- if ( null == endScriptTag ) {
- if ( PR_SOURCE == tok.style ) {
- // split off any starting and trailing <?, <%
- if ( '<' == decodeHelper.decode(s, 0) ) {
- decodeHelper.decode(s, decodeHelper.next);
- if ( '%' == decodeHelper.ch || '?' == decodeHelper.ch ) {
- endScriptTag = decodeHelper.ch;
- tokensOut.push(new PR_Token(s.substring(0, decodeHelper.next),
- PR_TAG));
- s = s.substring(decodeHelper.next, s.length);
- }
- }
- }
- else if ( PR_TAG == tok.style ) {
- if ( '<' == decodeHelper.decode(s, 0) &&
- '/' != s.charAt(decodeHelper.next) ) {
- var tagContent = s.substring(decodeHelper.next).toLowerCase();
- // FIXME(msamuel): this does not mirror exactly the code in
- // in PR_splitMarkup that defers splitting tags inside script and
- // style blocks.
- if ( PR_startsWith(tagContent, 'script') ||
- PR_startsWith(tagContent, 'style') ||
- PR_startsWith(tagContent, 'xmp') ) {
- endScriptTag = '/';
- }
- }
- }
- }
-
- if ( null != endScriptTag ) {
- var endTok = null;
- if ( PR_SOURCE == tok.style ) {
- if ( endScriptTag == '%' || endScriptTag == '?' ) {
- var pos = s.lastIndexOf(endScriptTag);
- if ( pos >= 0 && '>' == decodeHelper.decode(s, pos + 1) &&
- s.length == decodeHelper.next ) {
- endTok = new PR_Token(s.substring(pos, s.length), PR_TAG);
- s = s.substring(0, pos);
- }
- }
- if ( null == sourceChunks ) {
- sourceChunks = [];
- }
- sourceChunks.push(new PR_Token(s, PR_PLAIN));
- }
- else if ( PR_PLAIN == tok.style ) {
- if ( null == sourceChunks ) {
- sourceChunks = [];
- }
- sourceChunks.push(tok);
- }
- else if ( PR_TAG == tok.style ) {
- // if it starts with </ then it must be the end tag.
- if ( '<' == decodeHelper.decode(tok.token, 0) &&
- tok.token.length > decodeHelper.next &&
- '/' == decodeHelper.decode(tok.token, decodeHelper.next) ) {
- endTok = tok;
- }
- else {
- tokensOut.push(tok);
- }
- }
- else if ( ci >= nc ) {
- // force the token to close
- endTok = tok;
- }
- else {
- if ( sourceChunks ) {
- sourceChunks.push(tok);
- }
- else {
- // push remaining tag and attribute tokens from the opening tag
- tokensOut.push(tok);
- }
- }
- if ( endTok ) {
- if ( sourceChunks ) {
- var sourceTokens = PR_lexSource(sourceChunks);
- tokensOut.push(new PR_Token('<span class=embsrc>', null));
- for ( var si = 0, ns = sourceTokens.length; si < ns; ++si ) {
- tokensOut.push(sourceTokens[si]);
- }
- tokensOut.push(new PR_Token('</span>', null));
- sourceChunks = null;
- }
- if ( endTok.token ) {
- tokensOut.push(endTok);
- }
- endScriptTag = null;
- }
- }
- else {
- tokensOut.push(tok);
- }
- }
- return tokensOut;
-}
-
-/** splits the quotes from an attribute value.
- * ['"foo"'] -> ['"', 'foo', '"']
- * @private
- */
-function PR_splitAttributeQuotes( tokens ) {
- var firstPlain = null, lastPlain = null;
- for ( var i = 0; i < tokens.length; ++i ) {
- if ( PR_PLAIN == tokens[i].style ) {
- firstPlain = i;
- break;
- }
- }
- for ( var i = tokens.length; --i >= 0; ) {
- if ( PR_PLAIN == tokens[i].style ) {
- lastPlain = i;
- break;
- }
- }
- if ( null == firstPlain ) {
- return tokens;
- }
-
- var decodeHelper = new PR_DecodeHelper();
- var fs = tokens[firstPlain].token;
- var fc = decodeHelper.decode(fs, 0);
- if ( '"' != fc && '\'' != fc ) {
- return tokens;
- }
- var fpos = decodeHelper.next;
-
- var ls = tokens[lastPlain].token;
- var lpos = ls.lastIndexOf('&');
- if ( lpos < 0 ) {
- lpos = ls.length - 1;
- }
- var lc = decodeHelper.decode(ls, lpos);
- if ( lc != fc || decodeHelper.next != ls.length ) {
- lc = null;
- lpos = ls.length;
- }
-
- var tokensOut = [];
- for ( var i = 0; i < firstPlain; ++i ) {
- tokensOut.push(tokens[i]);
- }
- tokensOut.push(new PR_Token(fs.substring(0, fpos), PR_ATTRIB_VALUE));
- if ( lastPlain == firstPlain ) {
- tokensOut.push(new PR_Token(fs.substring(fpos, lpos), PR_PLAIN));
- }
- else {
- tokensOut.push(new PR_Token(fs.substring(fpos, fs.length), PR_PLAIN));
- for ( var i = firstPlain + 1; i < lastPlain; ++i ) {
- tokensOut.push(tokens[i]);
- }
- if ( lc ) {
- tokens.push(new PR_Token(ls.substring(0, lpos), PR_PLAIN));
- }
- else {
- tokens.push(tokens[lastPlain]);
- }
- }
- if ( lc ) {
- tokensOut.push(new PR_Token(ls.substring(lpos, ls.length), PR_PLAIN));
- }
- for ( var i = lastPlain + 1; i < tokens.length; ++i ) {
- tokensOut.push(tokens[i]);
- }
- return tokensOut;
-}
-
-/** identify attribute values that really contain source code and recursively
- * lex them.
- * @private
- */
-function PR_splitSourceAttributes( tokens ) {
- var tokensOut = [];
-
- var sourceChunks = null;
- var inSource = false;
- var name = '';
-
- for ( var ci = 0, nc = tokens.length; ci < nc; ++ci ) {
- var tok = tokens[ci];
- var outList = tokensOut;
- if ( PR_TAG == tok.style ) {
- if ( inSource ) {
- inSource = false;
- name = '';
- if ( sourceChunks ) {
- tokensOut.push(new PR_Token('<span class=embsrc>', null));
- var sourceTokens =
- PR_lexSource(PR_splitAttributeQuotes(sourceChunks));
- for ( var si = 0, ns = sourceTokens.length; si < ns; ++si ) {
- tokensOut.push(sourceTokens[si]);
- }
- tokensOut.push(new PR_Token('</span>', null));
- sourceChunks = null;
- }
- }
- else if ( name && tok.token.indexOf('=') >= 0 ) {
- var nameLower = name.toLowerCase();
- if ( PR_startsWith(nameLower, 'on') || 'style' == nameLower ) {
- inSource = true;
- }
- }
- else {
- name = '';
- }
- }
- else if ( PR_ATTRIB_NAME == tok.style ) {
- name += tok.token;
- }
- else if ( PR_ATTRIB_VALUE == tok.style ) {
- if ( inSource ) {
- if ( null == sourceChunks ) {
- sourceChunks = [];
- }
- outList = sourceChunks;
- tok = new PR_Token(tok.token, PR_PLAIN);
- }
- }
- else {
- if ( sourceChunks ) {
- outList = sourceChunks;
- }
- }
- outList.push(tok);
- }
- return tokensOut;
-}
-
-/** returns a list of PR_Token objects given chunks of source code.
- *
- * This code treats ", ', and ` as string delimiters, and \ as a string escape.
- * It does not recognize perl's qq() style strings. It has no special handling
- * for double delimiter escapes as in basic, or tje tripled delimiters used in
- * python, but should work on those regardless although in those cases a single
- * string literal may be broken up into multiple adjacent string literals.
- *
- * It recognizes C, C++, and shell style comments.
- *
- * @param chunks PR_Tokens with style in (null, PR_PLAIN)
- */
-function PR_lexSource( chunks ) {
- // split into strings, comments, and other.
- // We do this because strings and comments are easily recognizable and can
- // contain stuff that looks like other tokens, so we want to mark those early
- // so we don't recurse into them.
- var tokens = PR_splitStringAndCommentTokens(chunks);
-
- // split non comment|string tokens on whitespace and word boundaries
- var tokensOut = [];
- for ( var i = 0; i < tokens.length; ++i ) {
- var tok = tokens[i];
- if ( PR_PLAIN === tok.style ) {
- PR_splitNonStringNonCommentToken(tok.token, tokensOut);
- continue;
- }
- tokensOut.push(tok);
- }
-
- return tokensOut;
-}
-
-/** returns a list of PR_Token objects given a string of markup.
- *
- * This code assumes that < tokens are html escaped, but " are not.
- * It will do a resonable job with <, but will not recognize an "
- * as starting a string.
- *
- * This code recognizes a number of constructs.
- * <!-- ... --> comment
- * <!\w ... > declaration
- * <\w ... > tag
- * </\w ... > tag
- * <?...?> embedded source
- * &[#\w]...; entity
- *
- * It does not recognizes %foo; entities.
- *
- * It will recurse into any <style>, <script>, and on* attributes using
- * PR_lexSource.
- */
-function PR_lexMarkup( chunks ) {
- // This function works as follows:
- // 1) Start by splitting the markup into text and tag chunks
- // Input: String s
- // Output: List<PR_Token> where style in (PR_PLAIN, null)
- // 2) Then split the text chunks further into comments, declarations,
- // tags, etc.
- // After each split, consider whether the token is the start of an
- // embedded source section, i.e. is an open <script> tag. If it is,
- // find the corresponding close token, and don't bother to lex in between.
- // Input: List<String>
- // Output: List<PR_Token> with style in (PR_TAG, PR_PLAIN, PR_SOURCE, null)
- // 3) Finally go over each tag token and split out attribute names and values.
- // Input: List<PR_Token>
- // Output: List<PR_Token> where style in
- // (PR_TAG, PR_PLAIN, PR_SOURCE, NAME, VALUE, null)
- var tokensOut = PR_tokenizeMarkup(chunks);
- tokensOut = PR_splitTagAttributes(tokensOut);
- tokensOut = PR_splitSourceNodes(tokensOut);
- tokensOut = PR_splitSourceAttributes(tokensOut);
- return tokensOut;
-}
-
-/**
- * classify the string as either source or markup and lex appropriately.
- * @param {String} html
- */
-function PR_lexOne( html ) {
- var chunks = PR_expandTabs(PR_chunkify(html), PR_TAB_WIDTH);
-
- // treat it as markup if the first non whitespace character is a < and the
- // last non-whitespace character is a >
- var isMarkup = false;
- for ( var i = 0; i < chunks.length; ++i ) {
- if ( PR_PLAIN == chunks[i].style ) {
- if ( PR_startsWith(PR_trim(chunks[i].token), '<') ) {
- for ( var j = chunks.length; --j >= 0; ) {
- if ( PR_PLAIN == chunks[j].style ) {
- isMarkup = PR_endsWith(PR_trim(chunks[j].token), '>');
- break;
- }
- }
- }
- break;
- }
- }
-
- return isMarkup ? PR_lexMarkup(chunks) : PR_lexSource(chunks);
-}
-
-/** pretty print a chunk of code.
- *
- * @param s code as html
- * @return code as html, but prettier
- */
-function prettyPrintOne( s ) {
- try {
- var tokens = PR_lexOne(s);
- var out = [];
- var lastStyle = null;
- for ( var i = 0; i < tokens.length; i++ ) {
- var t = tokens[i];
- if ( t.style != lastStyle ) {
- if ( lastStyle != null ) {
- out.push('</span>');
- }
- if ( t.style != null ) {
- out.push('<span class=', t.style, '>');
- }
- lastStyle = t.style;
- }
- var html = t.token;
- if ( null != t.style ) {
- // This interacts badly with some wikis which introduces paragraph tags
- // into pre blocks for some strange reason.
- // It's necessary for IE though which seems to lose the preformattedness
- // of <pre> tags when their innerHTML is assigned.
- // http://stud3.tuwien.ac.at/~e0226430/innerHtmlQuirk.html
- html = html
- .replace(/(\r\n?|\n| ) /g, '$1 ')
- .replace(/\r\n?|\n/g, '<br>');
- }
- out.push(html);
- }
- if ( lastStyle != null ) {
- out.push('</span>');
- }
- return out.join('');
- }
- catch ( e ) {
- if ( 'console' in window ) {
- console.log(e);
- console.trace();
- }
- return s;
- }
-}
-
-/** find all the < pre > and < code > tags in the DOM with class=prettyprint and
- * prettify them.
- */
-function prettyPrint() {
- // fetch a list of nodes to rewrite
- var codeSegments = [
- document.getElementsByTagName('pre'),
- document.getElementsByTagName('code'),
- document.getElementsByTagName('xmp') ];
- var elements = [];
- for ( var i = 0; i < codeSegments.length; ++i ) {
- for ( var j = 0; j < codeSegments[i].length; ++j ) {
- elements.push(codeSegments[i][j]);
- }
- }
- codeSegments = null;
-
- // the loop is broken into a series of continuations to make sure that we
- // don't make the browser unresponsive when rewriting a large page.
- var k = 0;
-
- function doWork() {
- var endTime = new Date().getTime() + 250;
- for ( ; k < elements.length && new Date().getTime() < endTime; k++ ) {
- var cs = elements[k];
- if ( cs.className && cs.className.indexOf('prettyprint') >= 0 ) {
-
- // make sure this is not nested in an already prettified element
- var nested = false;
- for ( var p = cs.parentNode; p != null; p = p.parentNode ) {
- if ( (p.tagName == 'pre' || p.tagName == 'code' ||
- p.tagName == 'xmp') &&
- p.className && p.className.indexOf('prettyprint') >= 0 ) {
- nested = true;
- break;
- }
- }
- if ( !nested ) {
- // fetch the content as a snippet of properly escaped HTML.
- // Firefox adds newlines at the end.
- var content = PR_getInnerHtml(cs);
- content = content.replace(/(?:\r\n?|\n)$/, '');
-
- // do the pretty printing
- var newContent = prettyPrintOne(content);
-
- // push the prettified html back into the tag.
- if ( !PR_isRawContent(cs) ) {
- // just replace the old html with the new
- cs.innerHTML = newContent;
- }
- else {
- // we need to change the tag to a <pre> since <xmp>s do not allow
- // embedded tags such as the span tags used to attach styles to
- // sections of source code.
- var pre = document.createElement('PRE');
- for ( var i = 0; i < cs.attributes.length; ++i ) {
- var a = cs.attributes[i];
- if ( a.specified ) {
- pre.setAttribute(a.name, a.value);
- }
- }
- pre.innerHTML = newContent;
- // remove the old
- cs.parentNode.replaceChild(pre, cs);
- }
- }
- }
- }
- if ( k < elements.length ) {
- // finish up in a continuation
- setTimeout(doWork, 250);
- }
- }
-
- doWork();
-}
diff --git a/third_party/java/jopt-simple/src/site/site.xml b/third_party/java/jopt-simple/src/site/site.xml
deleted file mode 100644
index 8dafe09..0000000
--- a/third_party/java/jopt-simple/src/site/site.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="JOpt Simple - a Java command line parsing library">
- <bannerLeft>
- <name>JOpt Simple</name>
- <src>images/jopt-simple-logo.png</src>
- <href>http://pholser.github.com/jopt-simple/</href>
- </bannerLeft>
- <body>
- <menu name="JOpt Simple">
- <item name="Overview" href="index.html"/>
- <item name="Download" href="download.html"/>
- <item name="Examples" href="examples.html"/>
- <item name="Change Log" href="changes.html"/>
- <item name="Javadoc" href="apidocs/index.html"/>
- <item name="Developer Docs" href="developer.html"/>
- <item name="Acknowledgements" href="acknowledgments.html"/>
- </menu>
- <menu ref="reports"/>
- </body>
-</project>
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/AbstractOptionParserFixture.java b/third_party/java/jopt-simple/src/test/java/joptsimple/AbstractOptionParserFixture.java
deleted file mode 100644
index 3385c51..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/AbstractOptionParserFixture.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.rules.ExpectedException;
-
-import static org.junit.Assert.*;
-import static org.junit.rules.ExpectedException.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public abstract class AbstractOptionParserFixture {
- @Rule public final ExpectedException thrown = none();
-
- protected OptionParser parser;
-
- @Before
- public final void createNewParser() {
- parser = new OptionParser();
- }
-
- static void assertOptionDetected( OptionSet detectedOptions, String option ) {
- assertTrue( "option '" + option + "' not detected?", detectedOptions.has( option ) );
- }
-
- static void assertOptionNotDetected( OptionSet detectedOptions, String option ) {
- assertOptionNotDetected( "option '" + option + "' detected?", detectedOptions, option );
- }
-
- static void assertOptionNotDetected( String message, OptionSet detectedOptions, String option ) {
- assertFalse( message, detectedOptions.has( option ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/AbstractOptionSpecFixture.java b/third_party/java/jopt-simple/src/test/java/joptsimple/AbstractOptionSpecFixture.java
deleted file mode 100644
index 91901c9..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/AbstractOptionSpecFixture.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.infinitest.toolkit.EqualsHashCodeTestSupport;
-import org.junit.Test;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public abstract class AbstractOptionSpecFixture extends EqualsHashCodeTestSupport {
- @Override
- protected AbstractOptionSpec<?> equal() {
- return createEqualOptionSpecInstance();
- }
-
- @Override
- protected AbstractOptionSpec<?> notEqual() {
- return createNotEqualOptionSpecInstance();
- }
-
- protected abstract AbstractOptionSpec<?> createEqualOptionSpecInstance();
-
- protected abstract AbstractOptionSpec<?> createNotEqualOptionSpecInstance();
-
- @Test( expected = NullPointerException.class )
- public final void testValuesWithNullOptionSet() {
- createEqualOptionSpecInstance().values( null );
- }
-
- @Test( expected = NullPointerException.class )
- public final void testValueWithNullOptionSet() {
- createNotEqualOptionSpecInstance().value( null );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/AbstractOptionSpecOptionsImmutabilityTestCase.java b/third_party/java/jopt-simple/src/test/java/joptsimple/AbstractOptionSpecOptionsImmutabilityTestCase.java
deleted file mode 100644
index 0660640..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/AbstractOptionSpecOptionsImmutabilityTestCase.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.List;
-
-import org.infinitest.toolkit.UnmodifiableListTestSupport;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public abstract class AbstractOptionSpecOptionsImmutabilityTestCase extends UnmodifiableListTestSupport<String> {
- @Override
- protected List<String> newList() {
- AbstractOptionSpec<?> spec = newOptionSpec( containedItem() );
- return spec.options();
- }
-
- @Override
- protected final String newItem() {
- return "not";
- }
-
- @Override
- protected String containedItem() {
- return "in";
- }
-
- protected abstract AbstractOptionSpec<?> newOptionSpec( String option );
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/AbstractOptionSpecValuesImmutabilityTestCase.java b/third_party/java/jopt-simple/src/test/java/joptsimple/AbstractOptionSpecValuesImmutabilityTestCase.java
deleted file mode 100644
index 9e41ef8..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/AbstractOptionSpecValuesImmutabilityTestCase.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.Collections;
-import java.util.List;
-
-import org.infinitest.toolkit.UnmodifiableListTestSupport;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public abstract class AbstractOptionSpecValuesImmutabilityTestCase<T> extends UnmodifiableListTestSupport<T> {
- @Override
- protected List<T> newList() {
- AbstractOptionSpec<T> spec = newOptionSpec();
- OptionSet options = new OptionSet( Collections.<String, AbstractOptionSpec<?>> emptyMap() );
- options.addWithArgument( spec, firstArg() );
- options.addWithArgument( spec, secondArg() );
-
- return spec.values( options );
- }
-
- protected abstract AbstractOptionSpec<T> newOptionSpec();
-
- protected abstract String firstArg();
-
- protected abstract String secondArg();
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/AlternativeLongOptionSpecOptionsImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/AlternativeLongOptionSpecOptionsImmutabilityTest.java
deleted file mode 100644
index 529557d..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/AlternativeLongOptionSpecOptionsImmutabilityTest.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static joptsimple.ParserRules.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class AlternativeLongOptionSpecOptionsImmutabilityTest extends AbstractOptionSpecOptionsImmutabilityTestCase {
- @Override
- protected AbstractOptionSpec<?> newOptionSpec( String option ) {
- return new AlternativeLongOptionSpec();
- }
-
- @Override
- protected String containedItem() {
- return RESERVED_FOR_EXTENSIONS;
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/AlternativeLongOptionSpecValuesImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/AlternativeLongOptionSpecValuesImmutabilityTest.java
deleted file mode 100644
index 933c171..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/AlternativeLongOptionSpecValuesImmutabilityTest.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class AlternativeLongOptionSpecValuesImmutabilityTest
- extends AbstractOptionSpecValuesImmutabilityTestCase<String> {
-
- @Override
- protected AbstractOptionSpec<String> newOptionSpec() {
- return new AlternativeLongOptionSpec();
- }
-
- @Override
- protected String firstArg() {
- return "x=y";
- }
-
- @Override
- protected String secondArg() {
- return "z=w";
- }
-
- @Override
- protected String newItem() {
- return "a=b";
- }
-
- @Override
- protected String containedItem() {
- return "x=y";
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ArgumentAcceptingOptionSpecDefaultValuesImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ArgumentAcceptingOptionSpecDefaultValuesImmutabilityTest.java
deleted file mode 100644
index d20c48c..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ArgumentAcceptingOptionSpecDefaultValuesImmutabilityTest.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.List;
-
-import org.infinitest.toolkit.UnmodifiableListTestSupport;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ArgumentAcceptingOptionSpecDefaultValuesImmutabilityTest extends UnmodifiableListTestSupport<String> {
- @Override
- protected List<String> newList() {
- return new RequiredArgumentOptionSpec<String>( "option" ).defaultsTo( "a", "b" ).defaultValues();
- }
-
- @Override
- protected String containedItem() {
- return "a";
- }
-
- @Override
- protected String newItem() {
- return "c";
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ArgumentAcceptingOptionSpecTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ArgumentAcceptingOptionSpecTest.java
deleted file mode 100644
index 32ef589..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ArgumentAcceptingOptionSpecTest.java
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.infinitest.toolkit.Block;
-import org.junit.Test;
-
-import static org.infinitest.toolkit.Assertions.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ArgumentAcceptingOptionSpecTest {
- @Test( expected = NullPointerException.class )
- public void requiredArgOfNullType() {
- new RequiredArgumentOptionSpec<Void>( "a" ).ofType( null );
- }
-
- @Test( expected = NullPointerException.class )
- public void optionalArgOfNullType() {
- new OptionalArgumentOptionSpec<Void>( "verbose" ).ofType( null );
- }
-
- @Test( expected = IllegalArgumentException.class )
- public void requiredArgOfNonValueType() {
- new RequiredArgumentOptionSpec<Void>( "threshold" ).ofType( Object.class );
- }
-
- @Test( expected = IllegalArgumentException.class )
- public void optionalArgOfNonValueType() {
- new OptionalArgumentOptionSpec<Void>( "max" ).ofType( Object.class );
- }
-
- @Test
- public void requiredArgOfValueTypeBasedOnValueOf() {
- assertNoException( new Block() {
- public void execute() {
- new RequiredArgumentOptionSpec<Void>( "threshold" ).ofType( ValueOfHaver.class );
- }
- } );
- }
-
- @Test
- public void optionalArgOfValueTypeBasedOnValueOf() {
- assertNoException( new Block() {
- public void execute() {
- new OptionalArgumentOptionSpec<Void>( "abc" ).ofType( ValueOfHaver.class );
- }
- } );
- }
-
- @Test
- public void requiredArgOfValueTypeBasedOnCtor() {
- assertNoException( new Block() {
- public void execute() {
- new RequiredArgumentOptionSpec<Void>( "threshold" ).ofType( Ctor.class );
- }
- } );
- }
-
- @Test
- public void optionalArgOfValueTypeBasedOnCtor() {
- final OptionalArgumentOptionSpec<Ctor> spec = new OptionalArgumentOptionSpec<>( "abc" );
-
- assertNoException( new Block() {
- public void execute() {
- spec.ofType( Ctor.class );
- assertEquals( "foo", spec.convert( "foo" ).getS() );
- }
- } );
- }
-
- @Test( expected = IllegalArgumentException.class )
- public void rejectsUnicodeZeroAsCharValueSeparatorForRequiredArgument() {
- new RequiredArgumentOptionSpec<Void>( "a" ).withValuesSeparatedBy( '\u0000' );
- }
-
- @Test( expected = IllegalArgumentException.class )
- public void rejectsUnicodeZeroAsCharValueSeparatorForOptionalArgument() {
- new OptionalArgumentOptionSpec<Void>( "b" ).withValuesSeparatedBy( '\u0000' );
- }
-
- @Test( expected = IllegalArgumentException.class )
- public void rejectsUnicodeZeroInStringValueSeparatorForRequiredArgument() {
- new RequiredArgumentOptionSpec<Void>( "c" ).withValuesSeparatedBy( "::\u0000::" );
- }
-
- @Test( expected = IllegalArgumentException.class )
- public void rejectsUnicodeZeroInStringValueSeparatorForOptionalArgument() {
- new OptionalArgumentOptionSpec<Void>( "d" ).withValuesSeparatedBy( "::::\u0000" );
- }
-
- @Test( expected = NullPointerException.class )
- public void rejectsNullConverter() {
- new RequiredArgumentOptionSpec<Void>( "c" ).withValuesConvertedBy( null );
- }
-
- @Test( expected = NullPointerException.class )
- public void rejectsNullDefaultValue() {
- new RequiredArgumentOptionSpec<Integer>( "d" ).defaultsTo( null );
- }
-
- @Test( expected = NullPointerException.class )
- public void rejectsNullDefaultValueRemainder() {
- new RequiredArgumentOptionSpec<Integer>( "d" ).defaultsTo( 2, (Integer[]) null );
- }
-
- @Test( expected = NullPointerException.class )
- public void rejectsNullInDefaultValueRemainder() {
- new RequiredArgumentOptionSpec<Integer>( "d" ).defaultsTo( 2, 3, null );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ArgumentListHasNoMoreArgsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ArgumentListHasNoMoreArgsTest.java
deleted file mode 100644
index 1ae5075..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ArgumentListHasNoMoreArgsTest.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Before;
-import org.junit.Test;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ArgumentListHasNoMoreArgsTest {
- private ArgumentList noMore;
-
- @Before
- public void setUp() {
- noMore = new ArgumentList();
- }
-
- @Test( expected = IndexOutOfBoundsException.class )
- public void peek() {
- noMore.peek();
- }
-
- @Test( expected = IndexOutOfBoundsException.class )
- public void next() {
- noMore.next();
- }
-
- @Test( expected = IndexOutOfBoundsException.class )
- public void treatNextAsLongOption() {
- noMore.treatNextAsLongOption();
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ArgumentListTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ArgumentListTest.java
deleted file mode 100644
index 425a41a..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ArgumentListTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ArgumentListTest {
- private ArgumentList args;
-
- @Before
- public void setUp() {
- args = new ArgumentList( "-a", "b", "c" );
- }
-
- @Test
- public void nextAndPeek() {
- assertNextArgumentIs( "-a" );
- assertNextArgumentIs( "b" );
- assertNextArgumentIs( "c" );
- assertNoMoreArguments();
- }
-
- @Test
- public void treatNextAsLongOption() {
- args.treatNextAsLongOption();
- assertNextArgumentIs( "-a" );
-
- args.treatNextAsLongOption();
- assertNextArgumentIs( "--b" );
-
- args.treatNextAsLongOption();
- assertNextArgumentIs( "--c" );
-
- assertNoMoreArguments();
- }
-
- private void assertNextArgumentIs( String expectedArg ) {
- assertTrue( "no more arguments?", args.hasMore() );
- assertEquals( "peek?", expectedArg, args.peek() );
- assertEquals( "next?", expectedArg, args.next() );
- }
-
- private void assertNoMoreArguments() {
- assertFalse( "more arguments?", args.hasMore() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/AvailableIfAnyTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/AvailableIfAnyTest.java
deleted file mode 100644
index c3e4e59..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/AvailableIfAnyTest.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2014 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static java.util.Collections.emptyList;
-
-import static org.junit.Assert.assertEquals;
-
-public class AvailableIfAnyTest extends AbstractOptionParserFixture {
- @Before
- public void configureParser() {
- OptionSpec<Void> a = parser.accepts( "a" );
- parser.accepts( "b" );
- OptionSpec<Void> c = parser.accepts( "c" );
- parser.accepts( "d" );
- parser.accepts( "n" ).availableIf( a, c );
- }
-
- @Test
- public void rejectsCommandLineExistingForbiddenOption() {
- thrown.expect( UnavailableOptionException.class );
-
- parser.parse( "-b", "-n" );
- }
-
- @Test
- public void rejectsCommandLineExistingOtherForbiddenOption() {
- thrown.expect( UnavailableOptionException.class );
-
- parser.parse( "-d", "-n" );
- }
-
- @Test
- public void rejectsCommandLineOnlyForbiddenOption() {
- thrown.expect( UnavailableOptionException.class );
-
- parser.parse( "-n" );
- }
-
- @Test
- public void rejectsCommandLineWithNotAllConditionallyRequiredOptionsPresent() {
- thrown.expect( UnavailableOptionException.class );
-
- parser.parse( "-b", "-d", "-n" );
- }
-
- @Test
- public void acceptsCommandLineWithAllowedOptionsPresent() {
- OptionSet options = parser.parse( "-a", "-c", "-n" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "c" );
- assertOptionDetected( options, "n" );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/AvailableIfUnlessTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/AvailableIfUnlessTest.java
deleted file mode 100644
index 6f394b8..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/AvailableIfUnlessTest.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2014 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static java.util.Arrays.asList;
-import static java.util.Collections.emptyList;
-import static java.util.Collections.singletonList;
-
-import static org.junit.Assert.assertEquals;
-
-public class AvailableIfUnlessTest extends AbstractOptionParserFixture {
- @Before
- public void configureParser() {
- parser.mutuallyExclusive(
- parser.acceptsAll( asList( "ftp", "file-transfer" ) ),
- parser.accepts( "file" ),
- parser.accepts( "http" )
- );
-
- parser.acceptsAll( asList( "username", "userid" ) ).availableIf( "file-transfer" ).withRequiredArg();
- parser.acceptsAll( asList( "password", "pwd" ) ).availableIf( "ftp" ).withRequiredArg();
- parser.acceptsAll( asList( "directory", "dir" ) ).availableIf( "file" ).withRequiredArg();
- parser.accepts( "?" ).forHelp();
- }
-
- @Test
- public void rejectsEmptyMutualExclusiveness() {
- thrown.expect( NullPointerException.class );
-
- parser.mutuallyExclusive( (OptionSpecBuilder[]) null );
- }
-
- @Test
- public void rejectsConflictingCommandLineOptions1() {
- thrown.expect( UnavailableOptionException.class );
-
- parser.parse( "--ftp", "--file" );
- }
-
- @Test
- public void rejectsConflictingCommandLineOptions2() {
- thrown.expect( UnavailableOptionException.class );
-
- parser.parse( "--ftp", "--http" );
- }
-
- @Test
- public void rejectsIncompatibleOptions1() {
- thrown.expect( UnavailableOptionException.class );
-
- parser.parse( "--file", "--username", "joe" );
- }
-
- @Test
- public void rejectsIncompatibleOptions2() {
- thrown.expect( UnavailableOptionException.class );
-
- parser.parse( "--ftp", "--directory", "/tmp" );
- }
-
-
- @Test
- public void acceptsCommandLineWithConditionallyAllowedOptionsPresent1() {
- OptionSet options = parser.parse( "--ftp", "--userid", "joe", "--password=secret" );
-
- assertOptionDetected( options, "ftp" );
- assertOptionDetected( options, "username" );
- assertOptionDetected( options, "password" );
- assertEquals( singletonList( "joe" ), options.valuesOf( "username" ) );
- assertEquals( singletonList( "secret" ), options.valuesOf( "password" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void acceptsCommandLineWithConditionallyAllowedOptionsPresent2() {
- OptionSet options = parser.parse( "--file", "--dir", "/tmp");
-
- assertOptionDetected( options, "file" );
- assertOptionDetected( options, "dir" );
- assertEquals( singletonList( "/tmp" ), options.valuesOf( "dir" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void rejectsCommandLineOnlyContainingForbiddenOptionSynonym() {
- thrown.expect( UnavailableOptionException.class );
-
- parser.parse( "--pwd", "secret" );
- }
-
- @Test
- public void rejectsOptionNotAlreadyConfigured() {
- thrown.expect( UnconfiguredOptionException.class );
-
- parser.accepts( "foo" ).availableIf( "bar" );
- parser.accepts( "foo" ).availableUnless( "bar" );
- }
-
- @Test
- public void presenceOfHelpOptionNegatesAllowedIfness() {
- OptionSet options = parser.parse( "--file", "--userid", "joe", "-?" );
-
- assertOptionDetected( options, "file" );
- assertOptionDetected( options, "?" );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void presenceOfHelpOptionNegatesAllowedUnlessness() {
- OptionSet options = parser.parse( "--file", "--ftp", "-?" );
-
- assertOptionDetected( options, "file" );
- assertOptionDetected( options, "file-transfer" );
- assertOptionDetected( options, "?" );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/AvailableUnlessAnyTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/AvailableUnlessAnyTest.java
deleted file mode 100644
index c551916..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/AvailableUnlessAnyTest.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2014 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static java.util.Collections.emptyList;
-
-import static org.junit.Assert.assertEquals;
-
-public class AvailableUnlessAnyTest extends AbstractOptionParserFixture {
- @Before
- public void configureParser() {
- parser.accepts( "a" );
- parser.accepts( "b" );
- OptionSpec<Void> c = parser.accepts( "c" );
- parser.accepts( "d" );
- parser.accepts( "n" ).availableUnless( "a" ).availableUnless( c );
- }
-
- @Test
- public void rejectsCommandLineExistingForbiddenOption() {
- thrown.expect( UnavailableOptionException.class );
-
- parser.parse( "-a", "-n" );
- }
-
- @Test
- public void rejectsCommandLineExistingOtherForbiddenOption() {
- thrown.expect( UnavailableOptionException.class );
-
- parser.parse( "-c", "-n" );
- }
-
- @Test
- public void rejectsCommandLineOnlyForbiddenOption() {
- OptionSet options = parser.parse( "-n" );
-
- assertOptionDetected( options, "n" );
- }
-
- @Test
- public void rejectsCommandLineWithNotAllConditionallyRequiredOptionsPresent() {
- thrown.expect( UnavailableOptionException.class );
-
- parser.parse( "-a", "-c", "-n" );
- }
-
- @Test
- public void acceptsCommandLineWithAllowedOptionsPresent() {
- OptionSet options = parser.parse( "-d", "-b", "-n" );
-
- assertOptionDetected( options, "b" );
- assertOptionDetected( options, "d" );
- assertOptionDetected( options, "n" );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ClusterVersusLongOptionTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ClusterVersusLongOptionTest.java
deleted file mode 100644
index be71a1e..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ClusterVersusLongOptionTest.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ClusterVersusLongOptionTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "fox" );
- parser.accepts( "f" );
- parser.accepts( "o" );
- parser.accepts( "x" );
- }
-
- @Test
- public void resolvesToLongOptionEvenWithMatchingShortOptions() {
- OptionSet options = parser.parse( "--fox" );
- assertTrue( options.has( "fox" ) );
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertFalse( options.has( "x" ) );
- }
-
- @Test
- public void resolvesToLongOptionWithSingleDashEvenWithMatchingShortOptions() {
- OptionSet options = parser.parse( "-fox" );
- assertTrue( options.has( "fox" ) );
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertFalse( options.has( "x" ) );
- }
-
- @Test
- public void resolvesAbbreviationToLongOption() {
- OptionSet options = parser.parse( "-fo" );
- assertTrue( options.has( "fox" ) );
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- }
-
- @Test
- public void resolvesShortOptionToShortOption() {
- OptionSet options = parser.parse( "-f" );
- assertFalse( options.has( "fox" ) );
- assertTrue( options.has( "f" ) );
- }
-
- @Test
- public void resolvesShortOptionToShortOptionEvenWithDoubleHyphen() {
- OptionSet options = parser.parse( "--f" );
- assertFalse( options.has( "fox" ) );
- assertTrue( options.has( "f" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ClusterVersusLongOptionWithOptionalArgumentTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ClusterVersusLongOptionWithOptionalArgumentTest.java
deleted file mode 100644
index 4e91764..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ClusterVersusLongOptionWithOptionalArgumentTest.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ClusterVersusLongOptionWithOptionalArgumentTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "fox" );
- parser.accepts( "f" );
- parser.accepts( "o" );
- parser.accepts( "x" ).withOptionalArg();
- }
-
- @Test
- public void resolvesToLongOptionEvenWithMatchingShortOptions() {
- OptionSet options = parser.parse( "--fox" );
- assertTrue( options.has( "fox" ) );
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertFalse( options.has( "x" ) );
- }
-
- @Test
- public void resolvesToLongOptionWithSingleDashEvenWithMatchingShortOptions() {
- OptionSet options = parser.parse( "-fox" );
- assertTrue( options.has( "fox" ) );
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertFalse( options.has( "x" ) );
- }
-
- @Test
- public void resolvesAbbreviationToLongOption() {
- OptionSet options = parser.parse( "-fo" );
- assertTrue( options.has( "fox" ) );
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- }
-
- @Test
- public void resolvesShortOptionToShortOption() {
- OptionSet options = parser.parse( "-f" );
- assertFalse( options.has( "fox" ) );
- assertTrue( options.has( "f" ) );
- }
-
- @Test
- public void resolvesShortOptionToShortOptionEvenWithDoubleHyphen() {
- OptionSet options = parser.parse( "--f" );
- assertFalse( options.has( "fox" ) );
- assertTrue( options.has( "f" ) );
- }
-
- @Test
- public void resolvesToShortOptionsWithArgumentFollowingX() {
- OptionSet options = parser.parse( "-foxbar" );
- assertFalse( options.has( "fox" ) );
- assertTrue( options.has( "f" ) );
- assertTrue( options.has( "o" ) );
- assertTrue( options.has( "x" ) );
- assertEquals( singletonList( "bar" ), options.valuesOf( "x" ) );
- }
-
- @Test
- public void shortOptionsInDifferentOrder() {
- OptionSet options = parser.parse( "-fxo" );
- assertFalse( options.has( "fox" ) );
- assertTrue( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertTrue( options.has( "x" ) );
- assertEquals( singletonList( "o" ), options.valuesOf( "x" ) );
- }
-
- @Test( expected = UnrecognizedOptionException.class )
- public void longOptionWithMessedUpOrder() {
- parser.parse( "--fxo" );
- }
-
- @Test
- public void withArgumentComingAfterCluster() {
- OptionSet options = parser.parse( "-fox", "bar" );
-
- assertTrue( options.has( "fox" ) );
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertFalse( options.has( "x" ) );
- assertEquals( singletonList( "bar" ), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ClusterVersusLongOptionWithRequiredArgumentTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ClusterVersusLongOptionWithRequiredArgumentTest.java
deleted file mode 100644
index b20fe67..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ClusterVersusLongOptionWithRequiredArgumentTest.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ClusterVersusLongOptionWithRequiredArgumentTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "fox" );
- parser.accepts( "f" );
- parser.accepts( "o" );
- parser.accepts( "x" ).withRequiredArg();
- }
-
- @Test
- public void resolvesToLongOptionEvenWithMatchingShortOptions() {
- OptionSet options = parser.parse( "--fox" );
- assertTrue( options.has( "fox" ) );
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertFalse( options.has( "x" ) );
- }
-
- @Test
- public void resolvesToLongOptionWithSingleDashEvenWithMatchingShortOptions() {
- OptionSet options = parser.parse( "-fox" );
- assertTrue( options.has( "fox" ) );
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertFalse( options.has( "x" ) );
- }
-
- @Test
- public void resolvesAbbreviationToLongOption() {
- OptionSet options = parser.parse( "-fo" );
- assertTrue( options.has( "fox" ) );
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- }
-
- @Test
- public void resolvesShortOptionToShortOption() {
- OptionSet options = parser.parse( "-f" );
- assertFalse( options.has( "fox" ) );
- assertTrue( options.has( "f" ) );
- }
-
- @Test
- public void resolvesShortOptionToShortOptionEvenWithDoubleHyphen() {
- OptionSet options = parser.parse( "--f" );
- assertFalse( options.has( "fox" ) );
- assertTrue( options.has( "f" ) );
- }
-
- @Test
- public void resolvesToShortOptionsWithArgumentFollowingX() {
- OptionSet options = parser.parse( "-foxbar" );
- assertFalse( options.has( "fox" ) );
- assertTrue( options.has( "f" ) );
- assertTrue( options.has( "o" ) );
- assertTrue( options.has( "x" ) );
- assertEquals( singletonList( "bar" ), options.valuesOf( "x" ) );
- }
-
- @Test
- public void shortOptionsInDifferentOrder() {
- OptionSet options = parser.parse( "-fxo" );
- assertFalse( options.has( "fox" ) );
- assertTrue( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertTrue( options.has( "x" ) );
- assertEquals( singletonList( "o" ), options.valuesOf( "x" ) );
- }
-
- @Test( expected = UnrecognizedOptionException.class )
- public void longOptionWithMessedUpOrder() {
- parser.parse( "--fxo" );
- }
-
- @Test
- public void withArgumentComingAfterCluster() {
- OptionSet options = parser.parse( "-fox", "bar" );
-
- assertTrue( options.has( "fox" ) );
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertFalse( options.has( "x" ) );
- assertEquals( singletonList( "bar" ), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ClusterWhereManyOptionsAcceptArgumentsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ClusterWhereManyOptionsAcceptArgumentsTest.java
deleted file mode 100644
index ae82f27..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ClusterWhereManyOptionsAcceptArgumentsTest.java
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ClusterWhereManyOptionsAcceptArgumentsTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "f" );
- parser.accepts( "o" ).withOptionalArg();
- parser.accepts( "x" ).withRequiredArg();
- }
-
- @Test
- public void foxPermutation() {
- OptionSet options = parser.parse( "-fox" );
-
- assertTrue( options.has( "f" ) );
- assertTrue( options.has( "o" ) );
- assertFalse( options.has( "x" ) );
-
- assertEquals( singletonList( "x" ), options.valuesOf( "o" ) );
- }
-
- @Test
- public void fxoPermutation() {
- OptionSet options = parser.parse( "-fxo" );
-
- assertTrue( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertTrue( options.has( "x" ) );
-
- assertEquals( singletonList( "o" ), options.valuesOf( "x" ) );
- }
-
- @Test
- public void ofxPermutation() {
- OptionSet options = parser.parse( "-ofx" );
-
- assertFalse( options.has( "f" ) );
- assertTrue( options.has( "o" ) );
- assertFalse( options.has( "x" ) );
-
- assertEquals( singletonList( "fx" ), options.valuesOf( "o" ) );
- }
-
- @Test
- public void oxfPermutation() {
- OptionSet options = parser.parse( "-oxf" );
-
- assertFalse( options.has( "f" ) );
- assertTrue( options.has( "o" ) );
- assertFalse( options.has( "x" ) );
-
- assertEquals( singletonList( "xf" ), options.valuesOf( "o" ) );
- }
-
- @Test
- public void xofPermutation() {
- OptionSet options = parser.parse( "-xof" );
-
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertTrue( options.has( "x" ) );
-
- assertEquals( singletonList( "of" ), options.valuesOf( "x" ) );
- }
-
- @Test
- public void xfoPermutation() {
- OptionSet options = parser.parse( "-xfo" );
-
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertTrue( options.has( "x" ) );
-
- assertEquals( singletonList( "fo" ), options.valuesOf( "x" ) );
- }
-
- @Test
- public void foxPermutationWithFollowingArg() {
- OptionSet options = parser.parse( "-fox", "bar" );
-
- assertTrue( options.has( "f" ) );
- assertTrue( options.has( "o" ) );
- assertFalse( options.has( "x" ) );
-
- assertEquals( singletonList( "x" ), options.valuesOf( "o" ) );
- assertEquals( singletonList( "bar" ), options.nonOptionArguments() );
- }
-
- @Test
- public void fxoPermutationWithFollowingArg() {
- OptionSet options = parser.parse( "-fxo", "bar" );
-
- assertTrue( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertTrue( options.has( "x" ) );
-
- assertEquals( singletonList( "o" ), options.valuesOf( "x" ) );
- assertEquals( singletonList( "bar" ), options.nonOptionArguments() );
- }
-
- @Test
- public void ofxPermutationWithFollowingArg() {
- OptionSet options = parser.parse( "-ofx", "bar" );
-
- assertFalse( options.has( "f" ) );
- assertTrue( options.has( "o" ) );
- assertFalse( options.has( "x" ) );
-
- assertEquals( singletonList( "fx" ), options.valuesOf( "o" ) );
- assertEquals( singletonList( "bar" ), options.nonOptionArguments() );
- }
-
- @Test
- public void oxfPermutationWithFollowingArg() {
- OptionSet options = parser.parse( "-oxf", "bar" );
-
- assertFalse( options.has( "f" ) );
- assertTrue( options.has( "o" ) );
- assertFalse( options.has( "x" ) );
-
- assertEquals( singletonList( "xf" ), options.valuesOf( "o" ) );
- assertEquals( singletonList( "bar" ), options.nonOptionArguments() );
- }
-
- @Test
- public void xofPermutationWithFollowingArg() {
- OptionSet options = parser.parse( "-xof", "bar" );
-
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertTrue( options.has( "x" ) );
-
- assertEquals( singletonList( "of" ), options.valuesOf( "x" ) );
- assertEquals( singletonList( "bar" ), options.nonOptionArguments() );
- }
-
- @Test
- public void xfoPermutationWithFollowingArg() {
- OptionSet options = parser.parse( "-xfo", "bar" );
-
- assertFalse( options.has( "f" ) );
- assertFalse( options.has( "o" ) );
- assertTrue( options.has( "x" ) );
-
- assertEquals( singletonList( "fo" ), options.valuesOf( "x" ) );
- assertEquals( singletonList( "bar" ), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ConfigurableOptionParserHelpTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ConfigurableOptionParserHelpTest.java
deleted file mode 100644
index 066ca28..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ConfigurableOptionParserHelpTest.java
+++ /dev/null
@@ -1,484 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.io.StringWriter;
-import java.math.BigDecimal;
-import java.util.Date;
-import java.util.List;
-
-import static java.math.BigDecimal.*;
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static joptsimple.internal.Strings.*;
-import static joptsimple.util.DateConverter.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ConfigurableOptionParserHelpTest extends AbstractOptionParserFixture {
- private StringWriter sink;
-
- @Before
- public final void createSink() {
- parser.formatHelpWith( new BuiltinHelpFormatter( 120, 3 ) );
- sink = new StringWriter();
- }
-
- @Test
- public void unconfiguredParser() throws Exception {
- parser.printHelpOn( sink );
-
- assertHelpLines( "No options specified ", EMPTY );
- }
-
- @Test
- public void oneOptionNoArgNoDescription() throws Exception {
- parser.accepts( "apple" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "--apple ",
- EMPTY );
- }
-
- @Test
- public void oneOptionNoArgWithDescription() throws Exception {
- parser.accepts( "a", "some description" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-a some description",
- EMPTY );
- }
-
- @Test
- public void twoOptionsNoArgWithDescription() throws Exception {
- parser.accepts( "a", "some description" );
- parser.accepts( "verbose", "even more description" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-a some description ",
- "--verbose even more description",
- EMPTY );
- }
-
- @Test
- public void oneOptionRequiredArgNoDescription() throws Exception {
- parser.accepts( "a" ).withRequiredArg();
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "-a <String> ",
- EMPTY );
- }
-
- @Test
- public void oneOptionRequiredArgNoDescriptionWithType() throws Exception {
- parser.accepts( "a" ).withRequiredArg().ofType( Integer.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "-a <Integer> ",
- EMPTY );
- }
-
- @Test
- public void oneOptionRequiredArgWithDescription() throws Exception {
- parser.accepts( "a", "some value you need" ).withRequiredArg().describedAs( "numerical" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-a <String: numerical> some value you need",
- EMPTY );
- }
-
- @Test
- public void oneOptionRequiredArgWithDescriptionAndType() throws Exception {
- parser.accepts( "a", "some value you need" ).withRequiredArg().describedAs( "numerical" )
- .ofType( Integer.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-a <Integer: numerical> some value you need",
- EMPTY );
- }
-
- @Test
- public void oneOptionOptionalArgNoDescription() throws Exception {
- parser.accepts( "threshold" ).withOptionalArg();
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "--threshold [String] ",
- EMPTY );
- }
-
- @Test
- public void oneOptionOptionalArgNoDescriptionWithType() throws Exception {
- parser.accepts( "a" ).withOptionalArg().ofType( Float.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "-a [Float] ",
- EMPTY );
- }
-
- @Test
- public void oneOptionOptionalArgWithDescription() throws Exception {
- parser.accepts( "threshold", "some value you need" ).withOptionalArg().describedAs( "positive integer" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "--threshold [String: positive integer] some value you need",
- EMPTY );
- }
-
- @Test
- public void oneOptionOptionalArgWithDescriptionAndType() throws Exception {
- parser.accepts( "threshold", "some value you need" ).withOptionalArg().describedAs( "positive decimal" )
- .ofType( Double.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "--threshold [Double: positive decimal] some value you need",
- EMPTY );
- }
-
- @Test
- public void alternativeLongOptions() throws Exception {
- parser.recognizeAlternativeLongOptions( true );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-W <String: opt=value> Alternative form of long options",
- EMPTY );
- }
-
- @Test
- public void optionSynonymsWithoutArguments() throws Exception {
- parser.acceptsAll( asList( "v", "chatty" ), "be verbose" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "-v, --chatty be verbose ",
- EMPTY );
- }
-
- @Test
- public void optionSynonymsWithRequiredArgument() throws Exception {
- parser.acceptsAll( asList( "L", "index" ), "set level" ).withRequiredArg().ofType( Integer.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "-L, --index <Integer> set level ",
- EMPTY );
- }
-
- @Test
- public void optionSynonymsWithOptionalArgument() throws Exception {
- parser.acceptsAll( asList( "d", "since" ), "date filter" ).withOptionalArg().describedAs( "yyyyMMdd" )
- .ofType( Date.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "-d, --since [Date: yyyyMMdd] date filter",
- EMPTY );
- }
-
- @Test
- public void optionSynonymsSortedByShortOptionThenLexicographical() throws Exception {
- parser.acceptsAll( asList( "v", "prolix", "chatty" ) );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "-v, --chatty, --prolix ",
- EMPTY );
- }
-
- @Test
- public void bothColumnsExceedingAllocatedWidths() throws Exception {
- parser.acceptsAll( asList( "t", "threshold", "cutoff" ),
- "a threshold value beyond which a certain level of the application should cease to write logs" )
- .withRequiredArg()
- .describedAs( "a positive decimal number that will represent the threshold that has been outlined" )
- .ofType( Double.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-t, --cutoff, --threshold <Double: a positive decimal a threshold value beyond which a certain level of the",
- " number that will represent the threshold that has been application should cease to write logs ",
- " outlined> ",
- EMPTY );
- }
-
- // Bug 2018262
- @Test
- public void gradleHelp() throws Exception {
- parser.acceptsAll( asList( "n", "non-recursive" ), "Do not execute primary tasks of child projects." );
- parser.acceptsAll( singletonList( "S" ),
- "Don't trigger a System.exit(0) for normal termination. Used for Gradle's internal testing." );
- parser.acceptsAll( asList( "I", "no-imports" ), "Disable usage of default imports for build script files." );
- parser.acceptsAll( asList( "u", "no-search-upward" ),
- "Don't search in parent folders for a settings.gradle file." );
- parser.acceptsAll( asList( "x", "cache-off" ), "No caching of compiled build scripts." );
- parser.acceptsAll( asList( "r", "rebuild-cache" ), "Rebuild the cache of compiled build scripts." );
- parser.acceptsAll( asList( "v", "version" ), "Print version info." );
- parser.acceptsAll( asList( "d", "debug" ), "Log in debug mode (includes normal stacktrace)." );
- parser.acceptsAll( asList( "q", "quiet" ), "Log errors only." );
- parser.acceptsAll( asList( "j", "ivy-debug" ), "Set Ivy log level to debug (very verbose)." );
- parser.acceptsAll( asList( "i", "ivy-quiet" ), "Set Ivy log level to quiet." );
- parser.acceptsAll( asList( "s", "stacktrace" ),
- "Print out the stacktrace also for user exceptions (e.g. compile error)." );
- parser.acceptsAll( asList( "f", "full-stacktrace" ),
- "Print out the full (very verbose) stacktrace for any exceptions." );
- parser.acceptsAll( asList( "t", "tasks" ), "Show list of all available tasks and their dependencies." );
- parser.acceptsAll( asList( "p", "project-dir" ),
- "Specifies the start dir for Gradle. Defaults to current dir." ).withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "g", "gradle-user-home" ), "Specifies the gradle user home dir." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "l", "plugin-properties-file" ), "Specifies the plugin.properties file." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "b", "buildfile" ),
- "Specifies the build file name (also for subprojects). Defaults to build.gradle." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "D", "systemprop" ), "Set system property of the JVM (e.g. -Dmyprop=myvalue)." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "P", "projectprop" ),
- "Set project property for the build script (e.g. -Pmyprop=myvalue)." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "e", "embedded" ), "Specify an embedded build script." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "B", "bootstrap-debug" ),
- "Specify a text to be logged at the beginning (e.g. used by Gradle's bootstrap class)." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "h", "?" ), "Shows this help message." ).forHelp();
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-?, -h Shows this help message. ",
- "-B, --bootstrap-debug <String> Specify a text to be logged at the beginning (e.g. used by Gradle's bootstrap ",
- " class). ",
- "-D, --systemprop <String> Set system property of the JVM (e.g. -Dmyprop=myvalue). ",
- "-I, --no-imports Disable usage of default imports for build script files. ",
- "-P, --projectprop <String> Set project property for the build script (e.g. -Pmyprop=myvalue). ",
- "-S Don't trigger a System.exit(0) for normal termination. Used for Gradle's ",
- " internal testing. ",
- "-b, --buildfile <String> Specifies the build file name (also for subprojects). Defaults to build.gradle.",
- "-d, --debug Log in debug mode (includes normal stacktrace). ",
- "-e, --embedded <String> Specify an embedded build script. ",
- "-f, --full-stacktrace Print out the full (very verbose) stacktrace for any exceptions. ",
- "-g, --gradle-user-home <String> Specifies the gradle user home dir. ",
- "-i, --ivy-quiet Set Ivy log level to quiet. ",
- "-j, --ivy-debug Set Ivy log level to debug (very verbose). ",
- "-l, --plugin-properties-file <String> Specifies the plugin.properties file. ",
- "-n, --non-recursive Do not execute primary tasks of child projects. ",
- "-p, --project-dir <String> Specifies the start dir for Gradle. Defaults to current dir. ",
- "-q, --quiet Log errors only. ",
- "-r, --rebuild-cache Rebuild the cache of compiled build scripts. ",
- "-s, --stacktrace Print out the stacktrace also for user exceptions (e.g. compile error). ",
- "-t, --tasks Show list of all available tasks and their dependencies. ",
- "-u, --no-search-upward Don't search in parent folders for a settings.gradle file. ",
- "-v, --version Print version info. ",
- "-x, --cache-off No caching of compiled build scripts. ",
- EMPTY );
- }
-
- @Test
- public void dateConverterShowsDatePattern() throws Exception {
- parser.accepts( "date", "a date" ).withRequiredArg().withValuesConvertedBy( datePattern( "MM/dd/yy" ) );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "--date <MM/dd/yy> a date ",
- EMPTY );
- }
-
- @Test
- public void dateConverterShowsDatePatternInCombinationWithDescription() throws Exception {
- parser.accepts( "date", "a date" ).withOptionalArg().describedAs( "your basic date pattern" )
- .withValuesConvertedBy( datePattern( "MM/dd/yy" ) );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "--date [MM/dd/yy: your basic date pattern] a date ",
- EMPTY );
- }
-
- @Test
- public void leavesEmbeddedNewlinesInDescriptionsAlone() throws Exception {
- List<String> descriptionPieces =
- asList( "Specify the output type.", "'raw' = raw data.", "'java' = java class" );
- parser.accepts( "type", join( descriptionPieces, LINE_SEPARATOR ) );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "--type Specify the output type.",
- " 'raw' = raw data. ",
- " 'java' = java class ",
- EMPTY );
- }
-
- @Test
- public void includesDefaultValueForRequiredOptionArgument() throws Exception {
- parser.accepts( "a" ).withRequiredArg().defaultsTo( "boo" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-a <String> (default: boo)",
- EMPTY );
- }
-
- @Test
- public void includesDefaultValueForOptionalOptionArgument() throws Exception {
- parser.accepts( "b" ).withOptionalArg().ofType( Integer.class ).defaultsTo( 5 );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-b [Integer] (default: 5)",
- EMPTY );
- }
-
- @Test
- public void includesDefaultValueForArgumentWithDescription() throws Exception {
- parser.accepts( "c", "a quantity" ).withOptionalArg().ofType( BigDecimal.class )
- .describedAs( "quantity" ).defaultsTo( TEN );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-c [BigDecimal: quantity] a quantity (default: 10)",
- EMPTY );
- }
-
- @Test
- public void includesListOfDefaultsForArgumentWithDescription() throws Exception {
- parser.accepts( "d", "dizzle" ).withOptionalArg().ofType( Integer.class )
- .describedAs( "double dizzle" ).defaultsTo( 2, 3, 5, 7 );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-d [Integer: double dizzle] dizzle (default: [2, 3, 5, 7])",
- EMPTY );
- }
-
- @Test
- public void marksRequiredOptionsSpecially() throws Exception {
- parser.accepts( "e" ).withRequiredArg().required();
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option (* = required) Description",
- "--------------------- -----------",
- "* -e <String> ",
- EMPTY );
- }
-
- private void assertHelpLines( String... expectedLines ) {
- assertEquals( join( expectedLines, LINE_SEPARATOR ), sink.toString() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/CreateWithOptionSpecificationStringTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/CreateWithOptionSpecificationStringTest.java
deleted file mode 100644
index 545676a..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/CreateWithOptionSpecificationStringTest.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class CreateWithOptionSpecificationStringTest {
- @Test
- public void createsParserWithOptionSpecificationString() {
- OptionParser first = new OptionParser() {
- {
- accepts( "i" ).withOptionalArg();
- accepts( "j" ).withRequiredArg();
- accepts( "k" );
- }
- };
-
- OptionParser second = new OptionParser( "i::j:k" );
-
- String[] args = { "-k", "-ifoo", "-jbar" };
- assertEquals( first.parse( args ), second.parse( args ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/Ctor.java b/third_party/java/jopt-simple/src/test/java/joptsimple/Ctor.java
deleted file mode 100644
index ad26a4d..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/Ctor.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class Ctor {
- private String s;
-
- public Ctor( String s ) {
- this.s = s;
- }
-
- public String getS() {
- return s;
- }
-
- static Ctor valueOf( String s ) {
- return new Ctor( s );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/DefaultSettingsOptionParserHelpTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/DefaultSettingsOptionParserHelpTest.java
deleted file mode 100644
index e9fd215..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/DefaultSettingsOptionParserHelpTest.java
+++ /dev/null
@@ -1,753 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.StringWriter;
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-
-import joptsimple.util.InetAddressConverter;
-import org.junit.Before;
-import org.junit.Test;
-
-import static java.math.BigDecimal.*;
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-import static joptsimple.internal.Strings.*;
-import static joptsimple.util.DateConverter.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class DefaultSettingsOptionParserHelpTest extends AbstractOptionParserFixture {
- private StringWriter sink;
-
- @Before
- public final void createSink() {
- sink = new StringWriter();
- }
-
- @Test
- public void unconfiguredParser() throws Exception {
- parser.printHelpOn( sink );
-
- assertHelpLines( "No options specified ", EMPTY );
- }
-
- @Test
- public void repeatedCalls() throws Exception {
- parser.accepts( "apple" );
-
- parser.printHelpOn( sink );
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "--apple ",
- "Option Description",
- "------ -----------",
- "--apple ",
- EMPTY );
- }
-
- @Test
- public void oneOptionNoArgNoDescription() throws Exception {
- parser.accepts( "apple" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "--apple ",
- EMPTY );
- }
-
- @Test
- public void oneOptionNoArgWithDescription() throws Exception {
- parser.accepts( "a", "some description" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-a some description",
- EMPTY );
- }
-
- @Test
- public void twoOptionsNoArgWithDescription() throws Exception {
- parser.accepts( "a", "some description" );
- parser.accepts( "verbose", "even more description" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-a some description ",
- "--verbose even more description",
- EMPTY );
- }
-
- @Test
- public void oneOptionRequiredArgNoDescription() throws Exception {
- parser.accepts( "a" ).withRequiredArg();
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "-a <String> ",
- EMPTY );
- }
-
- @Test
- public void oneOptionRequiredArgNoDescriptionWithType() throws Exception {
- parser.accepts( "a" ).withRequiredArg().ofType( Integer.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "-a <Integer> ",
- EMPTY );
- }
-
- @Test
- public void oneOptionRequiredArgWithDescription() throws Exception {
- parser.accepts( "a", "some value you need" ).withRequiredArg().describedAs( "numerical" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-a <String: numerical> some value you need",
- EMPTY );
- }
-
- @Test
- public void oneOptionRequiredArgWithDescriptionAndType() throws Exception {
- parser.accepts( "a", "some value you need" )
- .withRequiredArg().describedAs( "numerical" ).ofType( Integer.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-a <Integer: numerical> some value you need",
- EMPTY );
- }
-
- @Test
- public void oneOptionOptionalArgNoDescription() throws Exception {
- parser.accepts( "threshold" ).withOptionalArg();
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "--threshold [String] ",
- EMPTY );
- }
-
- @Test
- public void oneOptionOptionalArgNoDescriptionWithType() throws Exception {
- parser.accepts( "a" ).withOptionalArg().ofType( Float.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "-a [Float] ",
- EMPTY );
- }
-
- @Test
- public void oneOptionOptionalArgWithDescription() throws Exception {
- parser.accepts( "threshold", "some value you need" ).withOptionalArg().describedAs( "positive integer" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "--threshold [String: positive integer] some value you need",
- EMPTY );
- }
-
- @Test
- public void oneOptionOptionalArgWithDescriptionAndType() throws Exception {
- parser.accepts( "threshold", "some value you need" )
- .withOptionalArg().describedAs( "positive decimal" ).ofType( Double.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "--threshold [Double: positive decimal] some value you need",
- EMPTY );
- }
-
- @Test
- public void alternativeLongOptions() throws Exception {
- parser.recognizeAlternativeLongOptions( true );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-W <String: opt=value> Alternative form of long options",
- EMPTY );
- }
-
- @Test
- public void optionSynonymsWithoutArguments() throws Exception {
- parser.acceptsAll( asList( "v", "chatty" ), "be verbose" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "-v, --chatty be verbose ",
- EMPTY );
- }
-
- @Test
- public void optionSynonymsWithRequiredArgument() throws Exception {
- parser.acceptsAll( asList( "L", "index" ), "set level" ).withRequiredArg().ofType( Integer.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "-L, --index <Integer> set level ",
- EMPTY );
- }
-
- @Test
- public void optionSynonymsWithOptionalArgument() throws Exception {
- parser.acceptsAll( asList( "d", "since" ), "date filter" )
- .withOptionalArg().describedAs( "yyyyMMdd" ).ofType( Date.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "-d, --since [Date: yyyyMMdd] date filter",
- EMPTY );
- }
-
- @Test
- public void optionSynonymsSortedByShortOptionThenLexicographical() throws Exception {
- parser.acceptsAll( asList( "v", "prolix", "chatty" ) );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "-v, --chatty, --prolix ",
- EMPTY );
- }
-
- @Test
- public void writingToOutputStream() throws Exception {
- ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
-
- parser.printHelpOn( bytesOut );
-
- assertEquals( "No options specified " + LINE_SEPARATOR, bytesOut.toString() );
- }
-
- // Bug 1956418
- @Test
- public void outputStreamFlushedButNotClosedWhenPrintingHelp() throws Exception {
- FakeOutputStream fake = new FakeOutputStream();
-
- parser.printHelpOn( fake );
-
- assertTrue( fake.flushed );
- assertFalse( fake.closed );
- }
-
- @Test
- public void bothColumnsExceedingAllocatedWidths() throws Exception {
- parser.acceptsAll( asList( "t", "threshold", "cutoff" ),
- "a threshold value beyond which a certain level of the application should cease to write logs" )
- .withRequiredArg()
- .describedAs( "a positive decimal number that will represent the threshold that has been outlined" )
- .ofType( Double.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-t, --cutoff, --threshold <Double: a a threshold value beyond which a ",
- " positive decimal number that will certain level of the application",
- " represent the threshold that has should cease to write logs ",
- " been outlined> ",
- EMPTY );
- }
-
- // Bug 2018262
- @Test
- public void gradleHelp() throws Exception {
- parser.acceptsAll( asList( "n", "non-recursive" ),
- "Do not execute primary tasks of child projects." );
- parser.acceptsAll( singletonList( "S" ),
- "Don't trigger a System.exit(0) for normal termination. Used for Gradle's internal testing." );
- parser.acceptsAll( asList( "I", "no-imports" ),
- "Disable usage of default imports for build script files." );
- parser.acceptsAll( asList( "u", "no-search-upward" ),
- "Don't search in parent folders for a settings.gradle file." );
- parser.acceptsAll( asList( "x", "cache-off" ),
- "No caching of compiled build scripts." );
- parser.acceptsAll( asList( "r", "rebuild-cache" ),
- "Rebuild the cache of compiled build scripts." );
- parser.acceptsAll( asList( "v", "version" ), "Print version info." );
- parser.acceptsAll( asList( "d", "debug" ),
- "Log in debug mode (includes normal stacktrace)." );
- parser.acceptsAll( asList( "q", "quiet" ), "Log errors only." );
- parser.acceptsAll( asList( "j", "ivy-debug" ),
- "Set Ivy log level to debug (very verbose)." );
- parser.acceptsAll( asList( "i", "ivy-quiet" ), "Set Ivy log level to quiet." );
- parser.acceptsAll( asList( "s", "stacktrace" ),
- "Print out the stacktrace also for user exceptions (e.g. compile error)." );
- parser.acceptsAll( asList( "f", "full-stacktrace" ),
- "Print out the full (very verbose) stacktrace for any exceptions." );
- parser.acceptsAll( asList( "t", "tasks" ),
- "Show list of all available tasks and their dependencies." );
- parser.acceptsAll( asList( "p", "project-dir" ),
- "Specifies the start dir for Gradle. Defaults to current dir." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "g", "gradle-user-home" ),
- "Specifies the gradle user home dir." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "l", "plugin-properties-file" ),
- "Specifies the plugin.properties file." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "b", "buildfile" ),
- "Specifies the build file name (also for subprojects). Defaults to build.gradle." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "D", "systemprop" ),
- "Set system property of the JVM (e.g. -Dmyprop=myvalue)." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "P", "projectprop" ),
- "Set project property for the build script (e.g. -Pmyprop=myvalue)." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "e", "embedded" ),
- "Specify an embedded build script." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "B", "bootstrap-debug" ),
- "Specify a text to be logged at the beginning (e.g. used by Gradle's bootstrap class)." )
- .withRequiredArg().ofType( String.class );
- parser.acceptsAll( asList( "h", "?" ), "Shows this help message" ).forHelp();
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-?, -h Shows this help message ",
- "-B, --bootstrap-debug <String> Specify a text to be logged at the ",
- " beginning (e.g. used by Gradle's ",
- " bootstrap class). ",
- "-D, --systemprop <String> Set system property of the JVM (e.g. - ",
- " Dmyprop=myvalue). ",
- "-I, --no-imports Disable usage of default imports for ",
- " build script files. ",
- "-P, --projectprop <String> Set project property for the build ",
- " script (e.g. -Pmyprop=myvalue). ",
- "-S Don't trigger a System.exit(0) for ",
- " normal termination. Used for Gradle's ",
- " internal testing. ",
- "-b, --buildfile <String> Specifies the build file name (also for ",
- " subprojects). Defaults to build.gradle.",
- "-d, --debug Log in debug mode (includes normal ",
- " stacktrace). ",
- "-e, --embedded <String> Specify an embedded build script. ",
- "-f, --full-stacktrace Print out the full (very verbose) ",
- " stacktrace for any exceptions. ",
- "-g, --gradle-user-home <String> Specifies the gradle user home dir. ",
- "-i, --ivy-quiet Set Ivy log level to quiet. ",
- "-j, --ivy-debug Set Ivy log level to debug (very ",
- " verbose). ",
- "-l, --plugin-properties-file <String> Specifies the plugin.properties file. ",
- "-n, --non-recursive Do not execute primary tasks of child ",
- " projects. ",
- "-p, --project-dir <String> Specifies the start dir for Gradle. ",
- " Defaults to current dir. ",
- "-q, --quiet Log errors only. ",
- "-r, --rebuild-cache Rebuild the cache of compiled build ",
- " scripts. ",
- "-s, --stacktrace Print out the stacktrace also for user ",
- " exceptions (e.g. compile error). ",
- "-t, --tasks Show list of all available tasks and ",
- " their dependencies. ",
- "-u, --no-search-upward Don't search in parent folders for a ",
- " settings.gradle file. ",
- "-v, --version Print version info. ",
- "-x, --cache-off No caching of compiled build scripts. ",
- EMPTY );
- }
-
- @Test
- public void dateConverterShowsDatePattern() throws Exception {
- parser.accepts( "date", "a date" )
- .withRequiredArg()
- .withValuesConvertedBy( datePattern( "MM/dd/yy" ) );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "--date <MM/dd/yy> a date ",
- EMPTY );
- }
-
- @Test
- public void dateConverterShowsDatePatternInCombinationWithDescription() throws Exception {
- parser.accepts( "date", "a date" ).withOptionalArg()
- .describedAs( "your basic date pattern" )
- .withValuesConvertedBy( datePattern( "MM/dd/yy" ) );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description",
- "------ -----------",
- "--date [MM/dd/yy: your basic date a date ",
- " pattern] ",
- EMPTY );
- }
-
- @Test
- public void inetAddressConverterShowsType() throws Exception {
- parser.accepts( "addr", "an internet address" )
- .withRequiredArg()
- .withValuesConvertedBy( new InetAddressConverter() );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "--addr <InetAddress> an internet address",
- EMPTY );
- }
-
- @Test
- public void leavesEmbeddedNewlinesInDescriptionsAlone() throws Exception {
- List<String> descriptionPieces =
- asList( "Specify the output type.", "'raw' = raw data.", "'java' = java class" );
- parser.accepts( "type", join( descriptionPieces, LINE_SEPARATOR ) );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "--type Specify the output type.",
- " 'raw' = raw data. ",
- " 'java' = java class ",
- EMPTY );
- }
-
- @Test
- public void includesDefaultValueForRequiredOptionArgument() throws Exception {
- parser.accepts( "a" ).withRequiredArg().defaultsTo( "boo" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-a <String> (default: boo)",
- EMPTY );
- }
-
- @Test
- public void includesDefaultValueForOptionalOptionArgument() throws Exception {
- parser.accepts( "b" ).withOptionalArg().ofType( Integer.class ).defaultsTo( 5 );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-b [Integer] (default: 5)",
- EMPTY );
- }
-
- @Test
- public void includesDefaultValueForArgumentWithDescription() throws Exception {
- parser.accepts( "c", "a quantity" ).withOptionalArg().ofType( BigDecimal.class )
- .describedAs( "quantity" ).defaultsTo( TEN );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-c [BigDecimal: quantity] a quantity (default: 10)",
- EMPTY );
- }
-
- @Test
- public void includesListOfDefaultsForArgumentWithDescription() throws Exception {
- parser.accepts( "d", "dizzle" ).withOptionalArg().ofType( Integer.class )
- .describedAs( "double dizzle" ).defaultsTo( 2, 3, 5, 7 );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-d [Integer: double dizzle] dizzle (default: [2, 3, 5, 7])",
- EMPTY );
- }
-
- @Test
- public void marksRequiredOptionsSpecially() throws Exception {
- parser.accepts( "e" ).withRequiredArg().required();
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option (* = required) Description",
- "--------------------- -----------",
- "* -e <String> ",
- EMPTY );
- }
-
- @Test
- public void showsNonOptionArgumentDescription() throws Exception {
- parser.nonOptions( "stuff" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Non-option arguments:",
- "[String] -- stuff ",
- EMPTY,
- "No options specified ",
- EMPTY );
- }
-
- @Test
- public void showsNonOptionArgumentType() throws Exception {
- parser.nonOptions().ofType( File.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Non-option arguments:",
- "[File] ",
- EMPTY,
- "No options specified ",
- EMPTY );
- }
-
- @Test
- public void showsNonOptionArgumentTypeDescribedAs() throws Exception {
- parser.nonOptions().describedAs( "files" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Non-option arguments:",
- "[String: files] ",
- EMPTY,
- "No options specified ",
- EMPTY );
- }
-
- @Test
- public void showsNonOptionArgumentTypeAndArgumentDescription() throws Exception {
- parser.nonOptions().ofType( File.class ).describedAs( "files" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Non-option arguments:",
- "[File: files] ",
- EMPTY,
- "No options specified ",
- EMPTY );
- }
-
- @Test
- public void showsNonOptionArgumentTypeAndDescription() throws Exception {
- parser.nonOptions( "some files to operate on" ).ofType( File.class );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Non-option arguments: ",
- "[File] -- some files to operate on",
- EMPTY,
- "No options specified ",
- EMPTY );
- }
-
- @Test
- public void showsNonOptionArgumentTypeAndDescriptionAndArgumentDescription() throws Exception {
- parser.nonOptions( "some files to operate on" ).ofType( File.class ).describedAs( "files" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Non-option arguments: ",
- "[File: files] -- some files to operate on",
- EMPTY,
- "No options specified ",
- EMPTY );
- }
-
- @Test
- public void canUseCustomHelpFormatter() {
- parser.accepts( "f" );
-
- parser.formatHelpWith( new HelpFormatter() {
- public String format( Map<String, ? extends OptionDescriptor> options ) {
- assertEquals( 1, options.size() );
- OptionDescriptor only = options.get( "f" );
- assertEquals( asList( "f" ), new ArrayList<>( only.options() ) );
- assertFalse( only.acceptsArguments() );
- assertEquals( "", only.argumentDescription() );
- assertEquals( "", only.argumentTypeIndicator() );
- assertEquals( emptyList(), only.defaultValues() );
- assertEquals( "", only.description() );
- assertFalse( only.isRequired() );
- assertFalse( only.requiresArgument() );
- return null;
- }
- } );
- }
-
- @Test( expected = NullPointerException.class )
- public void rejectsNullHelpFormatter() {
- parser.formatHelpWith( null );
- }
-
- @Test
- public void fixForIssue56() throws Exception {
- parser.accepts( "password", "Server Password" ).withRequiredArg().ofType( String.class );
- parser.accepts( "F", "Forward port mapping (ie: localhost:5900:localhost:5900)" ).withRequiredArg();
- parser.accepts( "R", "Reverse port mapping (ie: localhost:5900:localhost:5900)" ).withRequiredArg();
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-F <String> Forward port mapping (ie: localhost:5900:localhost:5900)",
- "-R <String> Reverse port mapping (ie: localhost:5900:localhost:5900)",
- "--password <String> Server Password ",
- EMPTY );
- }
-
- @Test
- public void fixForIssue85() throws Exception {
- parser.acceptsAll( asList( "?", "help" ), "Display this help text" ).forHelp();
- parser.acceptsAll( asList( "c", "check-avail" ),
- "Check Galileo homepage for available books, compare with known ones" );
- parser.acceptsAll( asList( "d", "download-dir" ),
- "Download directory for openbooks; must exist" )
- .withRequiredArg().ofType( File.class ).defaultsTo( new File( "." ) );
- parser.acceptsAll( asList( "l", "log-level" ),
- "Log level (0=normal, 1=verbose, 2=debug, 3=trace" )
- .withRequiredArg().ofType( int.class ).defaultsTo( 0 );
- parser.acceptsAll( asList( "m", "check-md5" ),
- "Download all known books without storing them, verifying their MD5 checksum (slow! >1 Gb download)" );
- parser.acceptsAll( asList( "t", "threading" ),
- "Threading mode (0=single, 1=multi); single is slower, but better for diagnostics)" )
- .withRequiredArg().ofType( int.class ).defaultsTo( 1 );
- parser.acceptsAll( asList( "w", "write-config" ),
- "Write editable book list to config.xml, enabling you to update MD5 checksums or add new books" );
-
- parser.printHelpOn( sink );
-
- assertHelpLines(
- "Option Description ",
- "------ ----------- ",
- "-?, --help Display this help text ",
- "-c, --check-avail Check Galileo homepage for available books, compare ",
- " with known ones ",
- "-d, --download-dir <File> Download directory for openbooks; must exist ",
- " (default: .) ",
- "-l, --log-level <Integer> Log level (0=normal, 1=verbose, 2=debug, 3=trace ",
- " (default: 0) ",
- "-m, --check-md5 Download all known books without storing them, ",
- " verifying their MD5 checksum (slow! >1 Gb download)",
- "-t, --threading <Integer> Threading mode (0=single, 1=multi); single is ",
- " slower, but better for diagnostics) (default: 1) ",
- "-w, --write-config Write editable book list to config.xml, enabling you ",
- " to update MD5 checksums or add new books ",
- EMPTY );
- }
-
- private void assertHelpLines( String... expectedLines ) {
- assertEquals( join( expectedLines, LINE_SEPARATOR ), sink.toString() );
- }
-
- static class FakeOutputStream extends ByteArrayOutputStream {
- boolean closed;
- boolean flushed;
-
- @Override
- public void close() {
- this.closed = true;
- }
-
- @Override
- public void flush() {
- this.flushed = true;
- }
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/EmptyOptionSetTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/EmptyOptionSetTest.java
deleted file mode 100644
index 640f0ff..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/EmptyOptionSetTest.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.Collections;
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class EmptyOptionSetTest {
- private OptionSet empty;
-
- @Before
- public void setUp() {
- empty = new OptionSet( Collections.<String, AbstractOptionSpec<?>> emptyMap() );
- empty.add( new NonOptionArgumentSpec<>() );
- }
-
- @Test
- public void valueOf() {
- assertNull( empty.valueOf( "a" ) );
- }
-
- @Test
- public void valuesOf() {
- assertEquals( emptyList(), empty.valuesOf( "a" ) );
- }
-
- @Test
- public void hasArgument() {
- assertFalse( empty.hasArgument( "a" ) );
- }
-
- @Test
- public void hasOptions() {
- assertFalse( empty.hasOptions() );
- }
-
- @Test( expected = NullPointerException.class )
- public void valueOfWithNullString() {
- empty.valueOf( (String) null );
- }
-
- @Test( expected = NullPointerException.class )
- public void valueOfWithNullOptionSpec() {
- empty.valueOf( (OptionSpec<?>) null );
- }
-
- @Test( expected = NullPointerException.class )
- public void valuesOfWithNullString() {
- empty.valuesOf( (String) null );
- }
-
- @Test( expected = NullPointerException.class )
- public void valuesOfWithNullOptionSpec() {
- empty.valuesOf( (OptionSpec<?>) null );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ExceptionMatchers.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ExceptionMatchers.java
deleted file mode 100644
index 5299fef..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ExceptionMatchers.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.hamcrest.Description;
-import org.hamcrest.Matcher;
-import org.hamcrest.TypeSafeMatcher;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ExceptionMatchers {
- private ExceptionMatchers() {
- throw new UnsupportedOperationException();
- }
-
- public static Matcher<OptionException> withOption( final String option ) {
- return new TypeSafeMatcher<OptionException>() {
- @Override
- public boolean matchesSafely( OptionException target ) {
- return target.options().contains( option );
- }
-
- public void describeTo( Description description ) {
- description.appendText( "an OptionException indicating the option ");
- description.appendValue( option );
- }
- };
- }
-
- public static Matcher<Throwable> withCauseOfType( final Class<? extends Throwable> type ) {
- return new TypeSafeMatcher<Throwable>() {
- @Override
- public boolean matchesSafely( Throwable target ) {
- return type.isInstance( target.getCause() );
- }
-
- public void describeTo( Description description ) {
- description.appendText( "an exception with cause of type " );
- description.appendValue( type );
- }
- };
- }
-
- public static Matcher<InvocationTargetException> withTargetOfType( final Class<? extends Throwable> type ) {
- return new TypeSafeMatcher<InvocationTargetException>() {
- @Override
- public boolean matchesSafely( InvocationTargetException target ) {
- return type.isInstance( target.getTargetException() );
- }
-
- public void describeTo( Description description ) {
- description.appendText( "an InvocationTargetException with target of type " );
- description.appendValue( type );
- }
- };
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/HandlingDefaultValuesForOptionArgumentsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/HandlingDefaultValuesForOptionArgumentsTest.java
deleted file mode 100644
index 5ed3141..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/HandlingDefaultValuesForOptionArgumentsTest.java
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.math.BigDecimal;
-import java.util.List;
-
-import static java.math.BigDecimal.*;
-import static java.util.Arrays.*;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class HandlingDefaultValuesForOptionArgumentsTest extends AbstractOptionParserFixture {
- @Test
- public void requiredArgOptionWithDefaultGivesArgIfArgSpecifiedOnCommandLine() {
- OptionSpec<Integer> optionA =
- parser.accepts( "a" ).withRequiredArg().ofType( Integer.class ).defaultsTo( 2 );
-
- OptionSet options = parser.parse( "-a", "1" );
-
- assertTrue( options.has( "a" ) );
- assertTrue( options.has( optionA ) );
- assertTrue( options.hasArgument( "a" ) );
- assertTrue( options.hasArgument( optionA ) );
- Integer expectedArgument = 1;
- assertEquals( expectedArgument, options.valueOf( "a" ) );
- assertEquals( expectedArgument, options.valueOf( optionA ) );
- assertEquals( expectedArgument, optionA.value( options ) );
- assertEquals( asList( expectedArgument ), options.valuesOf( "a" ) );
- assertEquals( asList( expectedArgument ), options.valuesOf( optionA ) );
- assertEquals( asList( expectedArgument ), optionA.values( options ) );
- }
-
- @Test( expected = OptionMissingRequiredArgumentException.class )
- public void requiredArgOptionWithDefaultStillsFailToParseIfArgNotSpecifiedOnCommandLine() {
- parser.accepts( "a" ).withRequiredArg().defaultsTo( "boo" );
-
- parser.parse( "-a" );
- }
-
- @Test
- public void optionalArgOptionWithDefaultGivesDefaultIfArgNotSpecifiedOnCommandLine() {
- OptionSpec<Long> optionA =
- parser.accepts( "a" ).withOptionalArg().ofType( Long.class ).defaultsTo( -1L );
-
- OptionSet options = parser.parse( "-a" );
-
- assertTrue( options.has( "a" ) );
- assertTrue( options.has( optionA ) );
- assertFalse( options.hasArgument( "a" ) );
- assertFalse( options.hasArgument( optionA ) );
- Long expectedArgument = -1L;
- assertEquals( expectedArgument, options.valueOf( "a" ) );
- assertEquals( expectedArgument, options.valueOf( optionA ) );
- assertEquals( expectedArgument, optionA.value( options ) );
- assertEquals( asList( expectedArgument ), options.valuesOf( "a" ) );
- assertEquals( asList( expectedArgument ), options.valuesOf( optionA ) );
- assertEquals( asList( expectedArgument ), optionA.values( options ) );
- }
-
- @Test
- public void optionalArgOptionWithDefaultGivesArgIfSpecifiedOnCommandLine() {
- OptionSpec<Long> optionA =
- parser.accepts( "a" ).withOptionalArg().ofType( Long.class ).defaultsTo( -1L );
-
- OptionSet options = parser.parse( "-a", "2" );
-
- assertTrue( options.has( "a" ) );
- assertTrue( options.has( optionA ) );
- assertTrue( options.hasArgument( "a" ) );
- assertTrue( options.hasArgument( optionA ) );
- Long expectedArgument = 2L;
- assertEquals( expectedArgument, options.valueOf( "a" ) );
- assertEquals( expectedArgument, options.valueOf( optionA ) );
- assertEquals( expectedArgument, optionA.value( options ) );
- assertEquals( asList( expectedArgument ), options.valuesOf( "a" ) );
- assertEquals( asList( expectedArgument ), options.valuesOf( optionA ) );
- assertEquals( asList( expectedArgument ), optionA.values( options ) );
- }
-
- @Test
- public void requiredArgOptionWithDefaultGivesDefaultIfOptionNotOnCommandLine() {
- OptionSpec<BigDecimal> optionA =
- parser.accepts( "a" ).withRequiredArg().ofType( BigDecimal.class ).defaultsTo( TEN );
-
- OptionSet options = parser.parse();
-
- assertFalse( options.has( "a" ) );
- assertFalse( options.has( optionA ) );
- assertFalse( options.hasArgument( "a" ) );
- assertFalse( options.hasArgument( optionA ) );
- assertEquals( TEN, options.valueOf( "a" ) );
- assertEquals( TEN, options.valueOf( optionA ) );
- assertEquals( TEN, optionA.value( options ) );
- assertEquals( asList( TEN ), options.valuesOf( "a" ) );
- assertEquals( asList( TEN ), options.valuesOf( optionA ) );
- assertEquals( asList( TEN ), optionA.values( options ) );
- }
-
- @Test
- public void optionalArgOptionWithDefaultGivesDefaultIfOptionNotOnCommandLine() {
- OptionSpec<BigDecimal> optionA =
- parser.accepts( "a" ).withOptionalArg().ofType( BigDecimal.class ).defaultsTo( TEN );
-
- OptionSet options = parser.parse();
-
- assertFalse( options.has( "a" ) );
- assertFalse( options.has( optionA ) );
- assertFalse( options.hasArgument( "a" ) );
- assertFalse( options.hasArgument( optionA ) );
- assertEquals( TEN, options.valueOf( "a" ) );
- assertEquals( TEN, options.valueOf( optionA ) );
- assertEquals( TEN, optionA.value( options ) );
- assertEquals( asList( TEN ), options.valuesOf( "a" ) );
- assertEquals( asList( TEN ), options.valuesOf( optionA ) );
- assertEquals( asList( TEN ), optionA.values( options ) );
- }
-
- @Test
- public void allowsListOfDefaults() {
- OptionSpec<Integer> optionC =
- parser.accepts( "c" ).withOptionalArg().ofType( Integer.class ).defaultsTo( 1, 2, 3 );
-
- OptionSet options = parser.parse();
-
- List<Integer> expected = asList( 1, 2, 3 );
- assertEquals( expected, optionC.values( options ) );
- assertEquals( expected, options.valuesOf( optionC ) );
- }
-
- @Test
- public void specifiedOptionArgumentsTrumpsListOfDefaults() {
- OptionSpec<Integer> optionC =
- parser.accepts( "c" ).withRequiredArg().ofType( Integer.class )
- .defaultsTo( 1, 2, 3 ).withValuesSeparatedBy( ',' );
-
- OptionSet options = parser.parse( "-c", "4", "-c", "5", "-c", "6,7,8" );
-
- List<Integer> expected = asList( 4, 5, 6, 7, 8 );
- assertEquals( expected, optionC.values( options ) );
- assertEquals( expected, options.valuesOf( optionC ) );
- }
-
- @Test
- public void withCompileTimeArraySpecifyingDefaults() {
- OptionSpec<Integer> optionD =
- parser.accepts( "d" ).withRequiredArg().ofType( Integer.class ).defaultsTo( new Integer[] { 1, 2, 3 } );
-
- OptionSet options = parser.parse();
-
- List<Integer> expected = asList( 1, 2, 3 );
- assertEquals( expected, optionD.values( options ) );
- assertEquals( expected, options.valuesOf( optionD ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/InterleavedArgumentsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/InterleavedArgumentsTest.java
deleted file mode 100644
index e91fbd3..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/InterleavedArgumentsTest.java
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class InterleavedArgumentsTest {
- @Test
- public void onlyAppearingToHaveOptionArguments() {
- OptionParser parser = new OptionParser( "c" );
-
- OptionSet options = parser.parse( "-c", "a", "-c", "b", "-c", "c", "-c", "d" );
-
- assertTrue( options.has( "c" ) );
- assertEquals( emptyList(), options.valuesOf( "c" ) );
- assertEquals( asList( "a", "b", "c", "d" ), options.nonOptionArguments() );
- }
-
- @Test
- public void onlyAppearingToHaveOptionArgumentsButPosixlyCorrect() {
- OptionParser parser = new OptionParser( "+c" );
-
- OptionSet options = parser.parse( "-c", "a", "-c", "b", "-c", "c", "-c", "d" );
-
- assertTrue( options.has( "c" ) );
- assertEquals( emptyList(), options.valuesOf( "c" ) );
- assertEquals(
- asList( "a", "-c", "b", "-c", "c", "-c", "d" ),
- options.nonOptionArguments() );
- }
-
- @Test
- public void requiredArgument() {
- OptionParser parser = new OptionParser( "c:" );
-
- OptionSet options = parser.parse( "-c", "a", "-c", "b", "-c", "c", "-c", "d" );
-
- assertTrue( options.has( "c" ) );
- assertEquals( asList( "a", "b", "c", "d" ), options.valuesOf( "c" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void requiredArgumentAndPosixlyCorrect() {
- OptionParser parser = new OptionParser( "+c:" );
-
- OptionSet options = parser.parse( "-c", "a", "-c", "b", "-c", "c", "-c", "d" );
-
- assertTrue( options.has( "c" ) );
- assertEquals( asList( "a", "b", "c", "d" ), options.valuesOf( "c" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void optionalArgument() {
- OptionParser parser = new OptionParser( "c::" );
-
- OptionSet options = parser.parse( "-c", "a", "-c", "b", "-c", "c", "-c", "d" );
-
- assertTrue( options.has( "c" ) );
- assertEquals( asList( "a", "b", "c", "d" ), options.valuesOf( "c" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void optionalArgumentAndPosixlyCorrect() {
- OptionParser parser = new OptionParser( "+c::" );
-
- OptionSet options = parser.parse( "-c", "a", "-c", "b", "-c", "c", "-c", "d" );
-
- assertTrue( options.has( "c" ) );
- assertEquals( emptyList(), options.valuesOf( "c" ) );
- assertEquals( asList( "a", "-c", "b", "-c", "c", "-c", "d" ), options.nonOptionArguments() );
- }
-
- @Test
- public void leadingNonOptionCausesPosixlyCorrectToIgnoreRemainder() {
- OptionParser parser = new OptionParser( "+c:" );
- String[] args = { "boo", "-c", "a", "-c", "b", "-c", "c", "-c", "d" };
-
- OptionSet options = parser.parse( args );
-
- assertFalse( options.has( "c" ) );
- assertEquals( emptyList(), options.valuesOf( "c" ) );
- assertEquals( asList( args ), options.nonOptionArguments() );
- }
-
- @Test
- public void optionalAbuttedArgumentVersusPosixlyCorrect() {
- OptionParser parser = new OptionParser( "+c::" );
-
- OptionSet options = parser.parse( "-ca", "-cb", "-c", "c", "-c", "d" );
-
- assertTrue( options.has( "c" ) );
- assertEquals( asList( "a", "b" ), options.valuesOf( "c" ) );
- assertEquals( asList( "c", "-c", "d" ), options.nonOptionArguments() );
- }
-
- @Test
- public void optionalKeyValuePairArgumentVersusPosixlyCorrect() {
- OptionParser parser = new OptionParser( "+c::" );
-
- OptionSet options = parser.parse( "-c=a", "-c=b", "-c", "c", "-c", "d" );
-
- assertTrue( options.has( "c" ) );
- assertEquals( asList( "a", "b" ), options.valuesOf( "c" ) );
- assertEquals( asList( "c", "-c", "d" ), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/Issue76Test.java b/third_party/java/jopt-simple/src/test/java/joptsimple/Issue76Test.java
deleted file mode 100644
index 31221de..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/Issue76Test.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static java.util.Arrays.asList;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class Issue76Test {
- private OptionParser parser;
- private OptionSpec<Integer> nonOptions;
-
- @Before
- public void setUp() {
- parser = new OptionParser();
- parser.accepts( "flag" ).withOptionalArg().withValuesConvertedBy( new ValueConverter<Boolean>() {
- public Boolean convert( String value ) {
- if ( "true".equals( value ) )
- return true;
- if ( "false".equals( value ) )
- return false;
- throw new ValueConversionException( "need 'true' or 'false'" );
- }
-
- public Class<? extends Boolean> valueType() {
- return boolean.class;
- }
-
- public String valuePattern() {
- return null;
- }
- });
- nonOptions = parser.nonOptions().ofType( Integer.class );
- }
-
- @Test
- public void suppliedExample() {
- OptionSet parsed = parser.parse( "--flag", "1", "2" );
-
- assertTrue( parsed.has( "flag" ) );
- assertEquals( asList( 1, 2 ), nonOptions.values( parsed ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/JVMSystemPropertiesArgumentParsingTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/JVMSystemPropertiesArgumentParsingTest.java
deleted file mode 100644
index 49366cf..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/JVMSystemPropertiesArgumentParsingTest.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-
-import joptsimple.util.KeyValuePair;
-import org.junit.Before;
-import org.junit.Test;
-
-import static joptsimple.util.KeyValuePair.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class JVMSystemPropertiesArgumentParsingTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "D" ).withRequiredArg().ofType( KeyValuePair.class );
- }
-
- @Test
- public void parsingJVMSystemPropertiesArguments() {
- OptionSet options = parser.parse( "-Dfile.encoding=UTF-8", "-Dpath.separator=:" );
- assertEquals(
- asList( valueOf( "file.encoding=UTF-8" ), valueOf( "path.separator=:" ) ),
- options.valuesOf( "D" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/LongOptionNoArgumentTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/LongOptionNoArgumentTest.java
deleted file mode 100644
index c41f9bb..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/LongOptionNoArgumentTest.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static joptsimple.ExceptionMatchers.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class LongOptionNoArgumentTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "verbose" );
- parser.accepts( "verb" );
- }
-
- @Test
- public void singleLongOption() {
- OptionSet options = parser.parse( "--verbose" );
-
- assertTrue( options.has( "verbose" ) );
- assertEquals( emptyList(), options.valuesOf( "verbose" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void singleLongOptionAbbreviated() {
- OptionSet options = parser.parse( "--verbo" );
-
- assertTrue( options.has( "verbose" ) );
- assertFalse( options.has( "verb" ) );
- assertEquals( emptyList(), options.valuesOf( "verbose" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void abbreviationIsALegalOption() {
- OptionSet options = parser.parse( "--verb" );
-
- assertFalse( options.has( "verbose" ) );
- assertTrue( options.has( "verb" ) );
- assertEquals( emptyList(), options.valuesOf( "verb" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void ambiguousAbbreviation() {
- thrown.expect( UnrecognizedOptionException.class );
- thrown.expect( withOption( "ver" ) );
-
- parser.parse( "--ver" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/LongOptionOptionalArgumentTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/LongOptionOptionalArgumentTest.java
deleted file mode 100644
index 93e4b4d..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/LongOptionOptionalArgumentTest.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class LongOptionOptionalArgumentTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "output" ).withOptionalArg();
- parser.accepts( "a" );
- }
-
- @Test
- public void argumentMissingTrailedByAnotherOption() {
- OptionSet options = parser.parse( "--output", "-a" );
-
- assertTrue( options.has( "output" ) );
- assertTrue( options.has( "a" ) );
- assertEquals( emptyList(), options.valuesOf( "output" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void argumentSeparate() {
- OptionSet options = parser.parse( "--output", "opt" );
-
- assertTrue( options.has( "output" ) );
- assertEquals( singletonList( "opt" ), options.valuesOf( "output" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void argumentTogether() {
- OptionSet options = parser.parse( "--output=opt" );
-
- assertTrue( options.has( "output" ) );
- assertEquals( singletonList( "opt" ), options.valuesOf( "output" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/LongOptionRequiredArgumentTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/LongOptionRequiredArgumentTest.java
deleted file mode 100644
index fe77f06..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/LongOptionRequiredArgumentTest.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static joptsimple.ExceptionMatchers.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class LongOptionRequiredArgumentTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "quiet" ).withRequiredArg();
- parser.accepts( "a" ).withOptionalArg();
- parser.accepts( "y" ).withRequiredArg();
- }
-
- @Test
- public void argumentSeparate() {
- OptionSet options = parser.parse( "--quiet", "23" );
-
- assertOptionDetected( options, "quiet" );
- assertEquals( singletonList( "23" ), options.valuesOf( "quiet" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void argumentFollowedByLegalOption() {
- OptionSet options = parser.parse( "--quiet", "-a" );
-
- assertOptionDetected( options, "quiet" );
- assertOptionNotDetected( options, "a" );
- assertEquals( singletonList( "-a" ), options.valuesOf( "quiet" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void argumentTogether() {
- OptionSet options = parser.parse( "--quiet=23" );
-
- assertOptionDetected( options, "quiet" );
- assertEquals( singletonList( "23" ), options.valuesOf( "quiet" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void argumentMissing() {
- thrown.expect( OptionMissingRequiredArgumentException.class );
- thrown.expect( withOption( "quiet" ) );
-
- parser.parse( "--quiet" );
- }
-
- @Test
- public void shortOptionSpecifiedAsLongOptionWithArgument() {
- OptionSet options = parser.parse( "--y=bar" );
-
- assertOptionDetected( options, "y" );
- assertEquals( singletonList( "bar" ), options.valuesOf( "y" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void whenEndOfOptionsMarkerIsInPlaceOfRequiredArgument() {
- OptionSet options = parser.parse( "--quiet", "--", "-y", "foo", "-a" );
-
- assertOptionDetected( options, "quiet" );
- assertOptionDetected( options, "y" );
- assertOptionDetected( options, "a" );
- assertEquals( singletonList( "--" ), options.valuesOf( "quiet" ) );
- assertEquals( singletonList( "foo" ), options.valuesOf( "y" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/NoArgumentOptionSpecOptionsImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/NoArgumentOptionSpecOptionsImmutabilityTest.java
deleted file mode 100644
index ec9e6a7..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/NoArgumentOptionSpecOptionsImmutabilityTest.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class NoArgumentOptionSpecOptionsImmutabilityTest extends AbstractOptionSpecOptionsImmutabilityTestCase {
- @Override
- protected AbstractOptionSpec<?> newOptionSpec( String option ) {
- return new NoArgumentOptionSpec( option );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/NoArgumentOptionSpecTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/NoArgumentOptionSpecTest.java
deleted file mode 100644
index e128308..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/NoArgumentOptionSpecTest.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-
-import org.junit.Test;
-
-import static org.infinitest.toolkit.CollectionMatchers.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class NoArgumentOptionSpecTest extends AbstractOptionSpecFixture {
- @Override
- protected NoArgumentOptionSpec createEqualOptionSpecInstance() {
- return new NoArgumentOptionSpec( "a" );
- }
-
- @Override
- protected NoArgumentOptionSpec createNotEqualOptionSpecInstance() {
- return new NoArgumentOptionSpec( "b" );
- }
-
- @Test
- public void optionsContents() {
- assertThat( createNotEqualOptionSpecInstance().options(), hasSameContentsAs( asList( "b" ) ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/NoArgumentOptionSpecValuesImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/NoArgumentOptionSpecValuesImmutabilityTest.java
deleted file mode 100644
index c2212b3..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/NoArgumentOptionSpecValuesImmutabilityTest.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class NoArgumentOptionSpecValuesImmutabilityTest extends AbstractOptionSpecValuesImmutabilityTestCase<Void> {
- @Override
- protected AbstractOptionSpec<Void> newOptionSpec() {
- return new NoArgumentOptionSpec( "verbose" );
- }
-
- @Override
- protected String firstArg() {
- return "1";
- }
-
- @Override
- protected String secondArg() {
- return "2";
- }
-
- @Override
- protected Void newItem() {
- return null;
- }
-
- @Override
- protected Void containedItem() {
- return null;
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/NonOptionArgumentSpecTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/NonOptionArgumentSpecTest.java
deleted file mode 100644
index feef727..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/NonOptionArgumentSpecTest.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Test;
-
-import java.io.File;
-import java.text.SimpleDateFormat;
-import java.util.*;
-
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-import static joptsimple.util.DateConverter.*;
-import static org.junit.Assert.*;
-
-public class NonOptionArgumentSpecTest extends AbstractOptionParserFixture {
- @Test
- public void allowsTypingOfNonOptionArguments() {
- OptionSpec<File> nonOptions = parser.nonOptions().ofType( File.class );
-
- OptionSet options = parser.parse( "/opt", "/var" );
-
- assertEquals( asList( new File( "/opt" ), new File( "/var" ) ), nonOptions.values( options ) );
- }
-
- @Test
- public void allowsDescriptionOfNonOptionArguments() {
- OptionSpec<String> nonOptions = parser.nonOptions( "directories" );
-
- OptionSet options = parser.parse( "/opt", "/var" );
-
- assertEquals( asList( "/opt", "/var" ), nonOptions.values( options ) );
- }
-
- @Test
- public void allowsTypeAndDescriptionOfNonOptionArguments() {
- OptionSpec<File> nonOptions = parser.nonOptions( "directories" ).ofType( File.class );
-
- OptionSet options = parser.parse( "/opt", "/var" );
-
- assertEquals( asList( new File( "/opt" ), new File( "/var" ) ), nonOptions.values( options ) );
- }
-
- @Test
- public void allowsArgumentDescriptionForNonOptionArguments() {
- OptionSpec<String> nonOptions = parser.nonOptions().describedAs( "dirs" );
-
- OptionSet options = parser.parse( "/opt", "/var" );
-
- assertEquals( asList( "/opt", "/var" ), nonOptions.values( options ) );
- }
-
- @Test
- public void doesNotAcceptArguments() {
- OptionDescriptor nonOptions = parser.nonOptions().describedAs( "dirs" );
-
- assertFalse( nonOptions.acceptsArguments() );
- }
-
- @Test
- public void convertingUsingConverter() throws Exception {
- OptionSpec<Date> date = parser.nonOptions().withValuesConvertedBy( datePattern( "MM/dd/yyyy" ) );
-
- OptionSet options = parser.parse( "01/24/2013" );
-
- assertEquals(
- singletonList( new SimpleDateFormat( "MM/dd/yyyy" ).parse( "01/24/2013" ) ),
- date.values( options ) );
- }
-
- @Test( expected = NullPointerException.class )
- public void convertingUsingNullConverter() {
- parser.nonOptions().withValuesConvertedBy( null );
- }
-
- @Test
- public void noSpecsCorrespondingToNonOptions() {
- OptionParser parser = new OptionParser();
- parser.nonOptions();
-
- OptionSet options = parser.parse( "one", "two" );
-
- assertEquals( emptyList(), options.specs() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionExceptionLocalizedMessageTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionExceptionLocalizedMessageTest.java
deleted file mode 100644
index e4cd337..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionExceptionLocalizedMessageTest.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Locale;
-
-import static java.util.Arrays.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-@RunWith( Parameterized.class )
-public class OptionExceptionLocalizedMessageTest {
- private final OptionException subject;
- private final String expectedMessage;
-
- public OptionExceptionLocalizedMessageTest( OptionException subject, String expectedMessage ) {
- this.subject = subject;
- this.expectedMessage = expectedMessage;
- }
-
- @Parameterized.Parameters
- public static Collection<?> exceptionsAndMessages() {
- return asList(
- new Object[] { new IllegalOptionSpecificationException( "," ), "illegal option specification exception" },
- new Object[] { new MultipleArgumentsForOptionException(
- new RequiredArgumentOptionSpec<>( asList( "b", "c" ), "d" ) ),
- "multiple arguments for option exception" },
- new Object[] { new OptionArgumentConversionException(
- new RequiredArgumentOptionSpec<>( asList( "c", "number" ), "x" ), "d", null ),
- "option argument conversion exception" },
- new Object[] { new OptionMissingRequiredArgumentException(
- new RequiredArgumentOptionSpec<>( asList( "e", "honest" ), "" ) ),
- "option missing required argument exception" },
- new Object[] { new UnrecognizedOptionException( "f" ), "unrecognized option exception" },
- new Object[] { new MissingRequiredOptionsException(
- Arrays.<AbstractOptionSpec<?>> asList(
- new NoArgumentOptionSpec( "g" ), new NoArgumentOptionSpec( "h" ) ) ),
- "missing required option exception" },
- new Object[] { new MissingRequiredOptionsException(
- Arrays.<AbstractOptionSpec<?>> asList(
- new RequiredArgumentOptionSpec<>( asList( "p", "place" ), "spot" ),
- new RequiredArgumentOptionSpec<>( asList( "d", "data-dir" ), "dir" ) ) ),
- "missing required option exception" },
- new Object[] { new UnconfiguredOptionException( asList( "i", "j" ) ),
- "unconfigured option exception" }
- );
- }
-
- @Test
- public void givesCorrectExceptionMessage() {
- assertEquals( expectedMessage, subject.localizedMessage( new Locale( "xx", "YY" ) ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionExceptionMessageTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionExceptionMessageTest.java
deleted file mode 100644
index 3afdd83..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionExceptionMessageTest.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.Arrays;
-import java.util.Collection;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-import static com.google.common.collect.Lists.newArrayList;
-import static java.util.Arrays.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-@RunWith( Parameterized.class )
-public class OptionExceptionMessageTest {
- private final OptionException subject;
- private final String expectedMessage;
-
- public OptionExceptionMessageTest( OptionException subject, String expectedMessage ) {
- this.subject = subject;
- this.expectedMessage = expectedMessage;
- }
-
- @Parameterized.Parameters
- public static Collection<?> exceptionsAndMessages() {
- return asList(
- new Object[] { new IllegalOptionSpecificationException( "," ), ", is not a legal option character" },
- new Object[] { new MultipleArgumentsForOptionException(
- new RequiredArgumentOptionSpec<>( asList( "b", "c" ), "d" ) ),
- "Found multiple arguments for option b/c, but you asked for only one" },
- new Object[] { new OptionArgumentConversionException(
- new RequiredArgumentOptionSpec<>( asList( "c", "number" ), "x" ), "d", null ),
- "Cannot parse argument 'd' of option c/number" },
- new Object[] { new OptionMissingRequiredArgumentException(
- new RequiredArgumentOptionSpec<>( asList( "e", "honest" ), "" ) ),
- "Option e/honest requires an argument" },
- new Object[] { new UnrecognizedOptionException( "f" ), "f is not a recognized option" },
- new Object[] { new MissingRequiredOptionsException(
- Arrays.<AbstractOptionSpec<?>> asList(
- new NoArgumentOptionSpec( "g" ), new NoArgumentOptionSpec( "h" ) ) ),
- "Missing required option(s) [g, h]" },
- new Object[] { new MissingRequiredOptionsException(
- Arrays.<AbstractOptionSpec<?>> asList(
- new RequiredArgumentOptionSpec<>( asList( "p", "place" ), "spot" ),
- new RequiredArgumentOptionSpec<>( asList( "d", "data-dir" ), "dir" ) ) ),
- "Missing required option(s) [p/place, d/data-dir]" },
- new Object[] { new UnconfiguredOptionException( asList( "i", "j" ) ),
- "Option(s) [i, j] not configured on this parser" },
- new Object[] {
- new UnavailableOptionException(
- newArrayList( new NoArgumentOptionSpec( "a" ), new NoArgumentOptionSpec( "b" ) ) ),
- "Option(s) [a, b] are unavailable given other options on the command line"
- }
- );
- }
-
- @Test
- public void givesCorrectExceptionMessage() {
- assertEquals( expectedMessage, subject.getLocalizedMessage() );
- assertEquals( expectedMessage, subject.getMessage() );
- assertEquals( subject.getClass().getName() + ": " + expectedMessage, subject.toString() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionExceptionOptionsImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionExceptionOptionsImmutabilityTest.java
deleted file mode 100644
index 465d960..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionExceptionOptionsImmutabilityTest.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.List;
-
-import org.infinitest.toolkit.UnmodifiableListTestSupport;
-
-import static java.util.Arrays.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionExceptionOptionsImmutabilityTest extends UnmodifiableListTestSupport<String> {
- @Override
- protected List<String> newList() {
- return new OptionException( asList( "a", "b" ) ) {
- private static final long serialVersionUID = -1L;
-
- @Override
- Object[] messageArguments() {
- return new Object[0];
- }
- }.options();
- }
-
- @Override
- protected String newItem() {
- return "c";
- }
-
- @Override
- protected String containedItem() {
- return "a";
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserAlternateHelpFormatterTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserAlternateHelpFormatterTest.java
deleted file mode 100644
index b799df6..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserAlternateHelpFormatterTest.java
+++ /dev/null
@@ -1,61 +0,0 @@
-package joptsimple;
-
-import java.io.StringWriter;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-
-import static java.util.Arrays.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.infinitest.toolkit.CollectionMatchers.*;
-import static org.junit.Assert.*;
-
-public class OptionParserAlternateHelpFormatterTest extends AbstractOptionParserFixture {
- private StringWriter sink;
- private Map<String, ? extends OptionDescriptor> captured;
-
- @Before
- public void primeParser() throws Exception {
- captured = new HashMap<>();
-
- parser.accepts( "b", "boo" );
-
- parser.formatHelpWith( new HelpFormatter() {
- public String format( Map<String, ? extends OptionDescriptor> options ) {
- captured = options;
- return "some help you are";
- }
- } );
-
- sink = new StringWriter();
-
- parser.printHelpOn( sink );
- }
-
- @Test
- public void asksAlternateFormatterForHelpString() {
- assertEquals( "some help you are", sink.toString() );
- }
-
- @Test
- public void getsFedOptionDescriptorsForRecognizedOptions() {
- assertEquals( 2, captured.size() );
- Iterator<? extends Map.Entry<String,? extends OptionDescriptor>> iterator = captured.entrySet().iterator();
- Map.Entry<String, ? extends OptionDescriptor> first = iterator.next();
- assertEquals( "[arguments]", first.getKey() );
- Map.Entry<String, ? extends OptionDescriptor> second = iterator.next();
- assertEquals("b", second.getKey());
- OptionDescriptor descriptor = second.getValue();
- assertThat( descriptor.options(), hasSameContentsAs( asList( "b" ) ) );
- assertEquals( "boo", descriptor.description() );
- assertFalse( descriptor.acceptsArguments() );
- assertFalse( descriptor.requiresArgument() );
- assertEquals( "", descriptor.argumentDescription() );
- assertEquals( "", descriptor.argumentTypeIndicator() );
- assertEquals( Collections.emptyList(), descriptor.defaultValues() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserArgumentExceptionTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserArgumentExceptionTest.java
deleted file mode 100644
index 4661795..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserArgumentExceptionTest.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.Collections;
-
-import static java.util.Collections.*;
-
-import org.junit.Test;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionParserArgumentExceptionTest extends AbstractOptionParserFixture {
- @Test( expected = NullPointerException.class )
- public void createWithNullOptionSpec() {
- new OptionParser( null );
- }
-
- @Test( expected = NullPointerException.class )
- public void parseNull() {
- parser.parse( (String[]) null );
- }
-
- @Test( expected = NullPointerException.class )
- public void nullOptionToAccepts() {
- parser.accepts( null );
- }
-
- @Test( expected = NullPointerException.class )
- public void nullOptionToAcceptsWithDescription() {
- parser.accepts( null, "a weird option" );
- }
-
- @Test( expected = NullPointerException.class )
- public void nullOptionListToAcceptsAll() {
- parser.acceptsAll( null );
- }
-
- @Test( expected = IllegalArgumentException.class )
- public void emptyOptionListToAcceptsAll() {
- parser.acceptsAll( Collections.<String> emptyList() );
- }
-
- @Test( expected = NullPointerException.class )
- public void optionListContainingNullToAcceptsAll() {
- parser.acceptsAll( singletonList( (String) null ) );
- }
-
- @Test( expected = NullPointerException.class )
- public void nullOptionListToAcceptsAllWithDescription() {
- parser.acceptsAll( null, "some weird options" );
- }
-
- @Test( expected = NullPointerException.class )
- public void optionListContainingNullToAcceptsAllWithDescription() {
- parser.acceptsAll( singletonList( (String) null ), "some weird options" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserNewDeclarationTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserNewDeclarationTest.java
deleted file mode 100644
index 0381af2..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserNewDeclarationTest.java
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.math.BigInteger;
-import java.sql.Time;
-import java.sql.Timestamp;
-
-import static java.lang.Boolean.*;
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionParserNewDeclarationTest extends AbstractOptionParserFixture {
- @Test( expected = IllegalOptionSpecificationException.class )
- public void acceptsIllegalCharacters() {
- parser.accepts( "!" );
- }
-
- @Test
- public void booleanArgumentType() {
- parser.accepts( "a" ).withRequiredArg().ofType( Boolean.class );
- parser.accepts( "b" ).withOptionalArg().ofType( Boolean.class );
-
- OptionSet options = parser.parse( "-a", "true", "-b", "false" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertEquals( TRUE, options.valueOf( "a" ) );
- assertEquals( singletonList( TRUE ), options.valuesOf( "a" ) );
- assertEquals( FALSE, options.valueOf( "b" ) );
- assertEquals( singletonList( FALSE ), options.valuesOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void byteArgumentType() {
- parser.accepts( "a" ).withRequiredArg().ofType( Byte.class );
- parser.accepts( "b" ).withOptionalArg().ofType( Byte.class );
-
- OptionSet options = parser.parse( "-a", "-1", "-b", "-2" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertEquals( Byte.valueOf( "-1" ), options.valueOf( "a" ) );
- assertEquals( singletonList( Byte.valueOf( "-1" ) ), options.valuesOf( "a" ) );
- assertEquals( Byte.valueOf( "-2" ), options.valueOf( "b" ) );
- assertEquals( singletonList( Byte.valueOf( "-2" ) ), options.valuesOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void doubleArgumentType() {
- parser.accepts( "a" ).withRequiredArg().ofType( Double.class );
- parser.accepts( "b" ).withOptionalArg().ofType( Double.class );
-
- OptionSet options = parser.parse( "-a", "3.1415926D", "-b", "6.02E23" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertEquals( Double.valueOf( "3.1415926D" ), options.valueOf( "a" ) );
- assertEquals( asList( Double.valueOf( "3.1415926D" ) ), options.valuesOf( "a" ) );
- assertEquals( Double.valueOf( "6.02E23" ), options.valueOf( "b" ) );
- assertEquals( asList( Double.valueOf( "6.02E23" ) ), options.valuesOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void floatArgumentType() {
- parser.accepts( "a" ).withRequiredArg().ofType( Float.class );
- parser.accepts( "b" ).withOptionalArg().ofType( Float.class );
-
- OptionSet options = parser.parse( "-a", "3.1415926F", "-b", "6.02E23F" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertEquals( Float.valueOf( "3.1415926F" ), options.valueOf( "a" ) );
- assertEquals( asList( Float.valueOf( "3.1415926F" ) ), options.valuesOf( "a" ) );
- assertEquals( Float.valueOf( "6.02E23F" ), options.valueOf( "b" ) );
- assertEquals( asList( Float.valueOf( "6.02E23F" ) ), options.valuesOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void integerArgumentType() {
- parser.accepts( "a" ).withRequiredArg().ofType( Integer.class );
- parser.accepts( "b" ).withOptionalArg().ofType( Integer.class );
-
- OptionSet options = parser.parse( "-a", "12", "-b", "34" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertEquals( Integer.valueOf( "12" ), options.valueOf( "a" ) );
- assertEquals( asList( Integer.valueOf( "12" ) ), options.valuesOf( "a" ) );
- assertEquals( Integer.valueOf( "34" ), options.valueOf( "b" ) );
- assertEquals( asList( Integer.valueOf( "34" ) ), options.valuesOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void longArgumentType() {
- parser.accepts( "a" ).withRequiredArg().ofType( Long.class );
- parser.accepts( "b" ).withOptionalArg().ofType( Long.class );
-
- OptionSet options = parser.parse( "-a", "123454678901234", "-b", "98765432109876" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertEquals( Long.valueOf( "123454678901234" ), options.valueOf( "a" ) );
- assertEquals( singletonList( Long.valueOf( "123454678901234" ) ), options.valuesOf( "a" ) );
- assertEquals( Long.valueOf( "98765432109876" ), options.valueOf( "b" ) );
- assertEquals( singletonList( Long.valueOf( "98765432109876" ) ), options.valuesOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void shortArgumentType() {
- parser.accepts( "a" ).withRequiredArg().ofType( Short.class );
- parser.accepts( "b" ).withOptionalArg().ofType( Short.class );
-
- OptionSet options = parser.parse( "-a", "5675", "-b", "345" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertEquals( Short.valueOf( "5675" ), options.valueOf( "a" ) );
- assertEquals( asList( Short.valueOf( "5675" ) ), options.valuesOf( "a" ) );
- assertEquals( Short.valueOf( "345" ), options.valueOf( "b" ) );
- assertEquals( asList( Short.valueOf( "345" ) ), options.valuesOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void sqlDateArgumentType() {
- parser.accepts( "a" ).withRequiredArg().ofType( java.sql.Date.class );
- parser.accepts( "b" ).withOptionalArg().ofType( java.sql.Date.class );
-
- OptionSet options = parser.parse( "-a", "2001-09-11", "-b", "1941-12-07" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertEquals( java.sql.Date.valueOf( "2001-09-11" ), options.valueOf( "a" ) );
- assertEquals( singletonList( java.sql.Date.valueOf( "2001-09-11" ) ), options.valuesOf( "a" ) );
- assertEquals( java.sql.Date.valueOf( "1941-12-07" ), options.valueOf( "b" ) );
- assertEquals( singletonList( java.sql.Date.valueOf( "1941-12-07" ) ), options.valuesOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void sqlTimeArgumentType() {
- parser.accepts( "a" ).withRequiredArg().ofType( Time.class );
- parser.accepts( "b" ).withOptionalArg().ofType( Time.class );
-
- OptionSet options = parser.parse( "-a", "08:57:39", "-b", "23:59:59" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertEquals( Time.valueOf( "08:57:39" ), options.valueOf( "a" ) );
- assertEquals( asList( Time.valueOf( "08:57:39" ) ), options.valuesOf( "a" ) );
- assertEquals( Time.valueOf( "23:59:59" ), options.valueOf( "b" ) );
- assertEquals( asList( Time.valueOf( "23:59:59" ) ), options.valuesOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void sqlTimestampArgumentType() {
- parser.accepts( "a" ).withRequiredArg().ofType( Timestamp.class );
- parser.accepts( "b" ).withOptionalArg().ofType( Timestamp.class );
-
- OptionSet options = parser.parse( "-a", "1970-01-01 00:00:00", "-b", "1979-12-31 23:59:59.0123456" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertEquals( Timestamp.valueOf( "1970-01-01 00:00:00" ), options.valueOf( "a" ) );
- assertEquals( singletonList( Timestamp.valueOf( "1970-01-01 00:00:00" ) ), options.valuesOf( "a" ) );
- assertEquals( Timestamp.valueOf( "1979-12-31 23:59:59.0123456" ), options.valueOf( "b" ) );
- assertEquals( singletonList( Timestamp.valueOf( "1979-12-31 23:59:59.0123456" ) ), options.valuesOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test( expected = OptionException.class )
- public void illegalOptionArgumentMethodConversion() {
- parser.accepts( "a" ).withRequiredArg().ofType( Integer.class );
-
- OptionSet options = parser.parse( "-a", "foo" );
-
- options.valueOf( "a" );
- }
-
- @Test( expected = OptionException.class )
- public void illegalOptionArgumentConstructorConversion() {
- parser.accepts( "a" ).withRequiredArg().ofType( BigInteger.class );
-
- OptionSet options = parser.parse( "-a", "foo" );
-
- options.valueOf( "a" );
- }
-
- @Test
- public void optionsWithOptionalNegativeNumberArguments() {
- parser.accepts( "a" ).withOptionalArg().ofType( Integer.class );
- parser.accepts( "b" ).withOptionalArg().ofType( Integer.class );
- parser.accepts( "1" );
- parser.accepts( "2" );
-
- OptionSet options = parser.parse( "-a", "-1", "-b", "-2" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertEquals( Integer.valueOf( "-1" ), options.valueOf( "a" ) );
- assertEquals( asList( Integer.valueOf( "-1" ) ), options.valuesOf( "a" ) );
- assertEquals( Integer.valueOf( "-2" ), options.valueOf( "b" ) );
- assertEquals( asList( Integer.valueOf( "-2" ) ), options.valuesOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void optionsWithOptionalNegativeNumberArgumentsAndNumberOptions() {
- parser.accepts( "a" ).withOptionalArg().ofType( Integer.class );
- parser.accepts( "b" ).withOptionalArg().ofType( Integer.class );
- parser.accepts( "1" );
- parser.accepts( "2" );
-
- OptionSet options = parser.parse( "-1", "-2", "-a", "-b" );
-
- assertOptionDetected( options, "1" );
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "2" );
- assertOptionDetected( options, "b" );
- assertNull( options.valueOf( "1" ) );
- assertNull( options.valueOf( "a" ) );
- assertNull( options.valueOf( "2" ) );
- assertNull( options.valueOf( "b" ) );
- assertEquals( emptyList(), options.valuesOf( "1" ) );
- assertEquals( emptyList(), options.valuesOf( "a" ) );
- assertEquals( emptyList(), options.valuesOf( "2" ) );
- assertEquals( emptyList(), options.valuesOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void optionsWithNegativeNumberArgumentsAndNonNumberOptions() {
- parser.accepts( "a" ).withOptionalArg().ofType( Integer.class );
- parser.accepts( "b" ).withOptionalArg().ofType( Integer.class );
- parser.accepts( "1" );
- parser.accepts( "2" );
-
- OptionSet options = parser.parse( "-1", "-a", "-b", "-2" );
-
- assertOptionDetected( options, "1" );
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertOptionNotDetected( options, "2" );
- assertNull( options.valueOf( "1" ) );
- assertNull( options.valueOf( "a" ) );
- assertEquals( Integer.valueOf( "-2" ), options.valueOf( "b" ) );
- assertEquals( emptyList(), options.valuesOf( "1" ) );
- assertEquals( emptyList(), options.valuesOf( "a" ) );
- assertEquals( asList( Integer.valueOf( "-2" ) ), options.valuesOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserOptionExceptionTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserOptionExceptionTest.java
deleted file mode 100644
index 3e219d52..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserOptionExceptionTest.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Test;
-
-import static joptsimple.ExceptionMatchers.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionParserOptionExceptionTest extends AbstractOptionParserFixture {
- @Test
- public void unrecognizedOption() {
- thrown.expect( UnrecognizedOptionException.class );
- thrown.expect( withOption( "a" ) );
-
- parser.parse( "-a" );
- }
-
- @Test
- public void illegalOptionCharacter() {
- thrown.expect( IllegalOptionSpecificationException.class );
- thrown.expect( withOption( "%" ) );
-
- parser.accepts( "%" );
- }
-
- @Test
- public void asteriskIsIllegalOptionCharacter() {
- thrown.expect( IllegalOptionSpecificationException.class );
- thrown.expect( withOption( "*" ) );
-
- parser.accepts( "*" );
- }
-
- @Test
- public void tooManyHyphens() {
- parser.accepts( "b" );
- thrown.expect( UnrecognizedOptionException.class );
- thrown.expect( withOption( "-b" ) );
-
- parser.parse( "---b" );
- }
-
- @Test
- public void valueOfWhenMultiples() {
- parser.accepts( "e" ).withRequiredArg();
- OptionSet options = parser.parse( "-e", "foo", "-e", "bar" );
- thrown.expect( MultipleArgumentsForOptionException.class );
- thrown.expect( withOption( "e" ) );
-
- options.valueOf( "e" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserRecognizedOptionsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserRecognizedOptionsTest.java
deleted file mode 100644
index 3bddfb9..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserRecognizedOptionsTest.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-package joptsimple;
-
-import org.junit.Test;
-
-import java.util.ArrayList;
-import java.util.Map;
-
-import static java.util.Arrays.asList;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-public class OptionParserRecognizedOptionsTest extends AbstractOptionParserFixture {
- @Test
- public void basicOptionsRecognized() {
- parser.accepts( "first" ).withRequiredArg().required();
- parser.accepts( "second" ).withOptionalArg();
- parser.accepts( "third" ).forHelp();
-
- Map<String, OptionSpec<?>> recognizedOptions = parser.recognizedOptions();
-
- assertEquals( 4, recognizedOptions.size() );
- assertTrue( recognizedOptions.keySet().contains( "first" ) );
- assertTrue( recognizedOptions.keySet().contains( "second" ) );
- assertTrue( recognizedOptions.keySet().contains( "third" ) );
- assertTrue( recognizedOptions.keySet().contains( "[arguments]" ) );
- assertTrue( recognizedOptions.get( "third" ).isForHelp() );
- assertFalse( recognizedOptions.get( "second" ).isForHelp() );
- assertNotNull( recognizedOptions.get( "first" ).options() );
- }
-
- @Test
- public void parserPreservesTrainingOrder() {
- final OptionSpecBuilder z = parser.acceptsAll( asList( "zebra", "aardvark" ) );
- final OptionSpecBuilder y = parser.accepts( "yak" );
- final OptionSpecBuilder x = parser.acceptsAll( asList( "baboon", "xantus" ) );
-
- assertEquals( asList( "[arguments]", "aardvark", "zebra", "yak", "baboon", "xantus" ), new ArrayList<String>(
- parser.recognizedOptions().keySet() ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserTest.java
deleted file mode 100644
index 5538f2d..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserTest.java
+++ /dev/null
@@ -1,318 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.lang.Boolean.*;
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import org.hamcrest.Description;
-import org.hamcrest.TypeSafeMatcher;
-import org.junit.Test;
-
-import static joptsimple.ExceptionMatchers.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionParserTest extends AbstractOptionParserFixture {
- @Test
- public void optionsAndNonOptionsInterspersed() {
- parser.accepts( "i" ).withOptionalArg();
- parser.accepts( "j" ).withOptionalArg();
- parser.accepts( "k" );
-
- OptionSet options =
- parser.parse( "-ibar", "-i", "junk", "xyz", "-jixnay", "foo", "-k", "blah", "--", "yermom" );
-
- assertOptionDetected( options, "i" );
- assertOptionDetected( options, "j" );
- assertOptionDetected( options, "k" );
- assertEquals( asList( "bar", "junk" ), options.valuesOf( "i" ) );
- assertEquals( singletonList( "ixnay" ), options.valuesOf( "j" ) );
- assertEquals( emptyList(), options.valuesOf( "k" ) );
- assertEquals( asList( "xyz", "foo", "blah", "yermom" ), options.nonOptionArguments() );
- }
-
- @Test
- public void shortOptionSpecifiedAsLongOptionWithoutArgument() {
- parser.accepts( "x" );
-
- OptionSet options = parser.parse( "--x" );
- assertOptionDetected( options, "x" );
- assertEquals( emptyList(), options.valuesOf( "x" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void longOptionLeadsWithSingleDash() {
- parser.accepts( "quiet" );
- parser.accepts( "queen" );
-
- OptionSet options = parser.parse( "-quiet" );
- assertOptionDetected( options, "quiet" );
- assertEquals( emptyList(), options.valuesOf( "quiet" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void parsesLongOptionAsAbbreviatedShortOption() {
- parser.accepts( "queen" );
-
- parser.parse( "-que" );
- }
-
- @Test
- public void parsesLongOptionAsAbbreviatedLongOption() {
- parser.accepts( "queen" );
-
- parser.parse( "--que" );
- }
-
- @Test
- public void longOptionLeadsWithSingleDashAmbiguous() {
- parser.accepts( "quiet" );
- parser.accepts( "queen" );
- thrown.expect( UnrecognizedOptionException.class );
- thrown.expect( withOption( "q" ) );
-
- parser.parse( "-q" );
- }
-
- @Test
- public void longOptionLeadsWithSingleDashAmbiguousButShortsAreLegal() {
- parser.accepts( "quiet" );
- parser.accepts( "queen" );
- parser.accepts( "q" );
- parser.accepts( "u" );
-
- OptionSet options = parser.parse( "-qu" );
- assertOptionDetected( options, "q" );
- assertOptionDetected( options, "u" );
- assertOptionNotDetected( options, "quiet" );
- assertOptionNotDetected( options, "queen" );
- assertEquals( emptyList(), options.valuesOf( "q" ) );
- assertEquals( emptyList(), options.valuesOf( "u" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void longOptionLeadsWithSingleDashAmbiguousButAShortIsIllegal() {
- parser.accepts( "quiet" );
- parser.accepts( "queen" );
- parser.accepts( "q" );
- thrown.expect( UnrecognizedOptionException.class );
- thrown.expect( withOption( "u" ) );
-
- parser.parse( "-qu" );
- }
-
- @Test
- public void longOptionLeadsWithSingleDashAmbiguousButAShortAcceptsAnArgument() {
- parser.accepts( "quiet" );
- parser.accepts( "queen" );
- parser.accepts( "q" ).withOptionalArg();
-
- OptionSet options = parser.parse( "-qu" );
- assertOptionDetected( options, "q" );
- assertOptionNotDetected( options, "quiet" );
- assertOptionNotDetected( options, "queen" );
- assertEquals( singletonList( "u" ), options.valuesOf( "q" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void resetHappensAfterParsing() {
- parser.accepts( "i" ).withOptionalArg();
- parser.accepts( "j" ).withOptionalArg();
- parser.accepts( "k" );
-
- String[] args = { "-ibar", "-i", "junk", "xyz", "-jixnay", "foo", "-k", "blah", "--", "yermom" };
-
- OptionSet options = parser.parse( args );
- assertEquals( options, parser.parse( args ) );
- }
-
- @Test
- public void typedArguments() {
- parser.accepts( "a" ).withRequiredArg().ofType( Boolean.class );
- parser.accepts( "b" ).withOptionalArg().ofType( Integer.class );
-
- OptionSet options = parser.parse( "-a", "false", "-b", "3", "extra" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertEquals( FALSE, options.valueOf( "a" ) );
- assertEquals( singletonList( FALSE ), options.valuesOf( "a" ) );
- assertEquals( Integer.valueOf( "3" ), options.valueOf( "b" ) );
- assertEquals( singletonList( Integer.valueOf( "3" ) ), options.valuesOf( "b" ) );
- assertEquals( singletonList( "extra" ), options.nonOptionArguments() );
- }
-
- @Test
- public void allowsMixingOfOptionsAndNonOptions() {
- parser.accepts( "i" ).withRequiredArg();
- parser.accepts( "j" ).withOptionalArg();
- parser.accepts( "k" );
-
- OptionSet options = parser.parse( "a", "b", "c", "-i", "boo", "d", "e", "-k", "f", "-j" );
-
- assertOptionDetected( options, "i" );
- assertEquals( singletonList( "boo" ), options.valuesOf( "i" ) );
- assertOptionDetected( options, "j" );
- assertEquals( emptyList(), options.valuesOf( "j" ) );
- assertOptionDetected( options, "k" );
- assertEquals( emptyList(), options.valuesOf( "k" ) );
- assertEquals( asList( "a", "b", "c", "d", "e", "f" ), options.nonOptionArguments() );
- }
-
- @Test
- public void disallowsMixingOfOptionsAndNonOptionsUnderPosixlyCorrect() {
- parser.accepts( "i" ).withRequiredArg();
- parser.accepts( "j" ).withOptionalArg();
- parser.accepts( "k" );
- parser.posixlyCorrect( true );
-
- OptionSet options = parser.parse( "a", "b", "c", "-i", "boo", "d", "e", "-k", "f", "-j" );
-
- assertOptionNotDetected( options, "i" );
- assertEquals( emptyList(), options.valuesOf( "i" ) );
- assertOptionNotDetected( options, "j" );
- assertEquals( emptyList(), options.valuesOf( "j" ) );
- assertOptionNotDetected( options, "k" );
- assertEquals( emptyList(), options.valuesOf( "j" ) );
- assertEquals( asList( "a", "b", "c", "-i", "boo", "d", "e", "-k", "f", "-j" ), options.nonOptionArguments() );
- }
-
- @Test
- public void doubleHyphenSignalsEndsOfOptions() {
- OptionSet options = new OptionParser( "ab:c::de:f::" ) {
- {
- accepts( "verbose" );
- }
- }.parse( "-a", "-b=foo", "-c=bar", "--", "-d", "-verbose", "-e", "baz", "-f", "biz" );
-
- assertOptionDetected( options, "a" );
- assertEquals( emptyList(), options.valuesOf( "a" ) );
- assertOptionDetected( options, "b" );
- assertEquals( singletonList( "foo" ), options.valuesOf( "b" ) );
- assertOptionDetected( options, "c" );
- assertEquals( singletonList( "bar" ), options.valuesOf( "c" ) );
- assertOptionNotDetected( options, "d" );
- assertOptionNotDetected( options, "verbose" );
- assertOptionNotDetected( options, "e" );
- assertOptionNotDetected( options, "f" );
- assertEquals( asList( "-d", "-verbose", "-e", "baz", "-f", "biz" ), options.nonOptionArguments() );
- }
-
- @Test
- public void allowsEmptyStringAsArgumentOfOption() {
- OptionSpec<String> optionI = parser.accepts( "i" ).withOptionalArg();
-
- OptionSet options = parser.parse( "-i", "" );
-
- assertOptionDetected( options, "i" );
- assertEquals( "", optionI.value( options ) );
- }
-
- @Test
- public void allowsWhitespaceyStringAsArgumentOfOption() {
- String whitespace = " \t\t\n\n\f\f \r\r ";
- OptionSpec<String> optionJ = parser.accepts( "j" ).withRequiredArg();
-
- OptionSet options = parser.parse( "-j", whitespace );
-
- assertOptionDetected( options, "j" );
- assertEquals( whitespace, optionJ.value( options ) );
- }
-
- @Test
- public void allowsEmbeddedWhitespaceInArgumentOfOption() {
- String withEmbeddedWhitespace = " look at me, I'm flaunting the rules! ";
- OptionSpec<String> optionJ = parser.accepts( "j" ).withRequiredArg();
-
- OptionSet options = parser.parse( "-j", withEmbeddedWhitespace );
-
- assertOptionDetected( options, "j" );
- assertEquals( withEmbeddedWhitespace, optionJ.value( options ) );
- }
-
- @Test
- public void requiredOptionWithArgMissing() {
- parser.accepts( "t" ).withOptionalArg().required();
- thrown.expect( MissingRequiredOptionsException.class );
- thrown.expect( withOption( "t" ) );
-
- parser.parse();
- }
-
- @Test
- public void requiredOptionButHelpOptionPresent() {
- parser.accepts( "t" ).withOptionalArg().required();
- parser.accepts( "h" ).forHelp();
-
- parser.parse( "-h" );
- }
-
- @Test
- public void configurationPerformedLaterOverrideThosePerformedEarlierForTheSameOption() {
- parser.accepts( "t" ).withRequiredArg();
- parser.accepts( "t" ).withOptionalArg();
-
- parser.parse( "-t" );
- }
-
- @Test
- public void requiredOptionWithSynonymsMissing() {
- parser.acceptsAll( asList( "h", "help", "?" ) );
- parser.acceptsAll( asList( "f", "ff", "csv-file-name" ) ).withRequiredArg().required();
-
- thrown.expect( MissingRequiredOptionsException.class );
- thrown.expectMessage( new TypeSafeMatcher<String>() {
- @Override
- protected boolean matchesSafely( String item ) {
- return "Missing required option(s) [f/csv-file-name/ff]".equals( item );
- }
-
- public void describeTo(Description description) {
- // purposely doing nothing here
- }
- } );
-
- parser.parse();
- }
-
- @Test
- public void abbreviationsCanBeDisallowed() {
- OptionParser parser = new OptionParser(false);
- parser.accepts( "abbreviatable" );
-
- thrown.expect( UnrecognizedOptionException.class );
-
- parser.parse( "--abb" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserUnrecognizedOptionsAllowedTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserUnrecognizedOptionsAllowedTest.java
deleted file mode 100644
index 8df74ca..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionParserUnrecognizedOptionsAllowedTest.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static joptsimple.ExceptionMatchers.withOption;
-import static java.util.Arrays.asList;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class OptionParserUnrecognizedOptionsAllowedTest extends AbstractOptionParserFixture {
- @Test
- public void unrecognizedOptionDisallowed() {
- assertFalse( parser.doesAllowsUnrecognizedOptions() );
-
- thrown.expect( UnrecognizedOptionException.class );
- thrown.expect( withOption( "a" ) );
-
- parser.parse( "-a" );
- }
-
- @Test
- public void unrecognizedOptionAllowed() {
- parser.allowsUnrecognizedOptions();
-
- OptionSet options = parser.parse( "-a" );
-
- assertEquals( asList( "-a" ), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetAsMapTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetAsMapTest.java
deleted file mode 100644
index 0a8c9a6..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetAsMapTest.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package joptsimple;
-
-import org.junit.Test;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static java.util.Arrays.asList;
-import static java.util.Collections.*;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
-
-/**
- * @author <a href="mailto:binkley@alumni.rice.edu">B. K. Oxley (binkley)</a>
- */
-public class OptionSetAsMapTest extends AbstractOptionParserFixture {
- @Test
- public void gives() {
- final OptionSpec<Void> a = parser.accepts( "a" );
- final OptionSpec<String> b = parser.accepts( "b" ).withRequiredArg();
- final OptionSpec<String> c = parser.accepts( "c" ).withOptionalArg();
- final OptionSpec<String> d = parser.accepts( "d" ).withRequiredArg().defaultsTo( "1" );
- final OptionSpec<String> e = parser.accepts( "e" ).withOptionalArg().defaultsTo( "2" );
- final OptionSpec<String> f = parser.accepts( "f" ).withRequiredArg().defaultsTo( "3" );
- final OptionSpec<String> g = parser.accepts( "g" ).withOptionalArg().defaultsTo( "4" );
- final OptionSpec<Void> h = parser.accepts( "h" );
-
- OptionSet options = parser.parse( "-a", "-e", "-c", "5", "-d", "6", "-b", "4", "-d", "7", "-e", "8" );
-
- Map<OptionSpec<?>, List<?>> expected = new HashMap<OptionSpec<?>, List<?>>() {
- private static final long serialVersionUID = Long.MIN_VALUE;
-
- {
- put( a, emptyList() );
- put( b, asList( "4" ) );
- put( c, asList( "5" ) );
- put( d, asList( "6", "7" ) );
- put( e, asList( "8" ) );
- put( f, asList( "3" ) );
- put( g, asList( "4" ) );
- put( h, emptyList() );
- }
- };
-
- assertThat( options.asMap(), is( equalTo( expected ) ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetDetectedOptionsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetDetectedOptionsTest.java
deleted file mode 100644
index 3a77664..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetDetectedOptionsTest.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.Arrays;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSetDetectedOptionsTest extends AbstractOptionParserFixture {
- @Test
- public void givesSpecsInOrderOfCommandLinePresentation() {
- OptionSpec<Void> a = parser.accepts( "a" );
- OptionSpec<String> b = parser.accepts( "b" ).withRequiredArg();
- OptionSpec<String> c = parser.accepts( "c" ).withOptionalArg();
- OptionSpec<String> d = parser.accepts( "d" ).withRequiredArg().defaultsTo( "1" );
- OptionSpec<String> e = parser.accepts( "e" ).withOptionalArg().defaultsTo( "2" );
-
- OptionSet options = parser.parse( "-a", "-e", "-c", "5", "-d", "6", "-b", "4", "-d", "7", "-e", "8" );
-
- assertEquals( Arrays.asList( a, e, c, d, b, d, e ), options.specs() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetEqualsHashCodeTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetEqualsHashCodeTest.java
deleted file mode 100644
index 28757ff..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetEqualsHashCodeTest.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.Collections;
-
-import org.infinitest.toolkit.StrictEqualsHashCodeTestSupport;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSetEqualsHashCodeTest extends StrictEqualsHashCodeTestSupport {
- @Override
- protected OptionSet equal() {
- OptionSet options = new OptionSet( Collections.<String, AbstractOptionSpec<?>> emptyMap() );
- options.addWithArgument( new RequiredArgumentOptionSpec<String>( "anOption" ), "anArg" );
- return options;
- }
-
- @Override
- protected OptionSet notEqual() {
- OptionSet options = new OptionSet( Collections.<String, AbstractOptionSpec<?>> emptyMap() );
- options.addWithArgument( new RequiredArgumentOptionSpec<String>( "anOption" ), "aDifferentArg" );
- return options;
- }
-
- @Override
- protected Object equalButDifferentClass() {
- OptionSet options =
- new OptionSet( Collections.<String, AbstractOptionSpec<?>> emptyMap() ) {
- // anonymous subclass
- };
- options.addWithArgument( new RequiredArgumentOptionSpec<String>( "anOption" ), "anArg" );
- return options;
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetNonOptionArgumentsImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetNonOptionArgumentsImmutabilityTest.java
deleted file mode 100644
index 7a2f352..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetNonOptionArgumentsImmutabilityTest.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.Collections;
-import java.util.List;
-
-import org.infinitest.toolkit.UnmodifiableListTestSupport;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSetNonOptionArgumentsImmutabilityTest extends UnmodifiableListTestSupport<String> {
- @SuppressWarnings( "unchecked" )
- @Override
- protected List<String> newList() {
- OptionSet options = new OptionSet( Collections.<String, AbstractOptionSpec<?>> emptyMap() );
- NonOptionArgumentSpec<String> nonOptions = new NonOptionArgumentSpec<>( null );
- options.addWithArgument( nonOptions, "1" );
- options.addWithArgument( nonOptions, "2" );
- return (List<String>) options.nonOptionArguments();
- }
-
- @Override
- protected String newItem() {
- return "3";
- }
-
- @Override
- protected String containedItem() {
- return "2";
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetSpecsImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetSpecsImmutabilityTest.java
deleted file mode 100644
index d728828..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetSpecsImmutabilityTest.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.Collections;
-import java.util.List;
-
-import org.infinitest.toolkit.UnmodifiableListTestSupport;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSetSpecsImmutabilityTest extends UnmodifiableListTestSupport<OptionSpec<?>> {
- @Override
- protected List<OptionSpec<?>> newList() {
- OptionSet options = new OptionSet( Collections.<String, AbstractOptionSpec<?>> emptyMap() );
- options.add( new NoArgumentOptionSpec( "a" ) );
- return options.specs();
- }
-
- @Override
- protected OptionSpec<?> newItem() {
- return new NoArgumentOptionSpec( "b" );
- }
-
- @Override
- protected OptionSpec<?> containedItem() {
- return new NoArgumentOptionSpec( "a" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetValuesOfOptionStringImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetValuesOfOptionStringImmutabilityTest.java
deleted file mode 100644
index 6f5189a..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetValuesOfOptionStringImmutabilityTest.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.Collections;
-import java.util.List;
-
-import org.infinitest.toolkit.UnmodifiableListTestSupport;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSetValuesOfOptionStringImmutabilityTest extends UnmodifiableListTestSupport<Object> {
- @SuppressWarnings( "unchecked" )
- @Override
- protected List<Object> newList() {
- RequiredArgumentOptionSpec<String> optionB = new RequiredArgumentOptionSpec<>( "b" );
- OptionSet options = new OptionSet( Collections.<String, AbstractOptionSpec<?>> emptyMap() );
- options.addWithArgument( optionB, "foo" );
- options.addWithArgument( optionB, "bar" );
-
- return (List<Object>) options.valuesOf( "b" );
- }
-
- @Override
- protected String newItem() {
- return "baz";
- }
-
- @Override
- protected String containedItem() {
- return "bar";
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetValuesOfSpecImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetValuesOfSpecImmutabilityTest.java
deleted file mode 100644
index 146652a..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSetValuesOfSpecImmutabilityTest.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.Collections;
-import java.util.List;
-
-import org.infinitest.toolkit.UnmodifiableListTestSupport;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSetValuesOfSpecImmutabilityTest extends UnmodifiableListTestSupport<String> {
- @Override
- protected List<String> newList() {
- RequiredArgumentOptionSpec<String> optionA = new RequiredArgumentOptionSpec<>( "a" );
- OptionSet options = new OptionSet( Collections.<String, AbstractOptionSpec<?>> emptyMap() );
- options.addWithArgument( optionA, "anArgument" );
- options.addWithArgument( optionA, "anotherArgument" );
- return options.valuesOf( optionA );
- }
-
- @Override
- protected String newItem() {
- return "yetAnotherArgument";
- }
-
- @Override
- protected String containedItem() {
- return "anArgument";
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSpecBuilderOptionsImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSpecBuilderOptionsImmutabilityTest.java
deleted file mode 100644
index 231e690..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSpecBuilderOptionsImmutabilityTest.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSpecBuilderOptionsImmutabilityTest extends AbstractOptionSpecOptionsImmutabilityTestCase {
- @Override
- protected AbstractOptionSpec<?> newOptionSpec( String option ) {
- return new OptionSpecBuilder( new OptionParser(), asList( option ), "" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSpecBuilderValuesImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSpecBuilderValuesImmutabilityTest.java
deleted file mode 100644
index 3adc17d..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSpecBuilderValuesImmutabilityTest.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSpecBuilderValuesImmutabilityTest extends AbstractOptionSpecValuesImmutabilityTestCase<Void> {
- @Override
- protected AbstractOptionSpec<Void> newOptionSpec() {
- return new OptionSpecBuilder( new OptionParser(), asList( "a" ), "" );
- }
-
- @Override
- protected String firstArg() {
- return "Q";
- }
-
- @Override
- protected String secondArg() {
- return "W";
- }
-
- @Override
- protected Void newItem() {
- return null;
- }
-
- @Override
- protected Void containedItem() {
- return null;
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSpecTokenizerTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSpecTokenizerTest.java
deleted file mode 100644
index 6e40307..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSpecTokenizerTest.java
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.NoSuchElementException;
-
-import static java.util.Collections.*;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-
-import static org.infinitest.toolkit.CollectionMatchers.*;
-import static org.junit.Assert.*;
-import static org.junit.rules.ExpectedException.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSpecTokenizerTest {
- @Rule public final ExpectedException thrown = none();
-
- @Test
- public void tokenizeEmpty() {
- assertNoMoreTokens( new OptionSpecTokenizer( "" ) );
- }
-
- @Test
- public void tokenizeOptionsWithoutArguments() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "ab" );
- assertNextTokenTakesNoArgument( lexer, 'a', false );
- assertNextTokenTakesNoArgument( lexer, 'b', false );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void tokenizeOptionsWithRequiredArguments() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "c:d:" );
- assertNextTokenRequiresAnArgument( lexer, 'c', false );
- assertNextTokenRequiresAnArgument( lexer, 'd', false );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void tokenizeOptionsWithOptionalArguments() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "e::f::" );
- assertNextTokenTakesAnOptionalArgument( lexer, 'e', false );
- assertNextTokenTakesAnOptionalArgument( lexer, 'f', false );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void tokenizeOptionsWithMixtureOfSpecTypes() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "gh:i::j" );
- assertNextTokenTakesNoArgument( lexer, 'g', false );
- assertNextTokenRequiresAnArgument( lexer, 'h', false );
- assertNextTokenTakesAnOptionalArgument( lexer, 'i', false );
- assertNextTokenTakesNoArgument( lexer, 'j', false );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void wByItself() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "W" );
- assertNextTokenTakesNoArgument( lexer, 'W', false );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void wRequiredArg() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "W:" );
- assertNextTokenRequiresAnArgument( lexer, 'W', false );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void wOptionalArg() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "W::" );
- assertNextTokenTakesAnOptionalArgument( lexer, 'W', false );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void alternativeLongOptionsMarker() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "W;" );
- assertNextTokenRequiresAnArgument( lexer, 'W', false );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void tokenizeOptionsWithoutArgumentsAndHelpMarker() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "ab*" );
- assertNextTokenTakesNoArgument( lexer, 'a', false );
- assertNextTokenTakesNoArgument( lexer, 'b', true );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void tokenizeOptionsWithRequiredArgumentsAndHelpMarker() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "c*:d:" );
- assertNextTokenRequiresAnArgument( lexer, 'c', true );
- assertNextTokenRequiresAnArgument( lexer, 'd', false );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void tokenizeOptionsWithOptionalArgumentsAndHelpMarker() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "e*::f*::" );
- assertNextTokenTakesAnOptionalArgument( lexer, 'e', true );
- assertNextTokenTakesAnOptionalArgument( lexer, 'f', true );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void tokenizeOptionsWithMixtureOfSpecTypesAndHelpMarker() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "g*h:i*::j" );
- assertNextTokenTakesNoArgument( lexer, 'g', true );
- assertNextTokenRequiresAnArgument( lexer, 'h', false );
- assertNextTokenTakesAnOptionalArgument( lexer, 'i', true );
- assertNextTokenTakesNoArgument( lexer, 'j', false );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void wByItselfWithHelpMarker() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "W*" );
- assertNextTokenTakesNoArgument( lexer, 'W', true );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void wRequiredArgWithHelpMarker() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "W*:" );
- assertNextTokenRequiresAnArgument( lexer, 'W', true );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void wOptionalArgWithHelpMarker() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "W*::" );
- assertNextTokenTakesAnOptionalArgument( lexer, 'W', true );
- assertNoMoreTokens( lexer );
- }
-
- @Test
- public void alternativeLongOptionsMarkerWithHelpMarker() {
- OptionSpecTokenizer lexer = new OptionSpecTokenizer( "W*;" );
- assertNextTokenTakesNoArgument( lexer, 'W', true );
- }
-
- private void assertNoMoreTokens( OptionSpecTokenizer lexer ) {
- assertFalse( lexer.hasMore() );
-
- thrown.expect( NoSuchElementException.class );
- lexer.next();
- }
-
- private static void assertNextTokenTakesNoArgument( OptionSpecTokenizer lexer, char option, boolean forHelp ) {
- assertNextToken( lexer, option, false, false, forHelp );
- }
-
- private static void assertNextTokenRequiresAnArgument( OptionSpecTokenizer lexer, char option, boolean forHelp ) {
- assertNextToken( lexer, option, true, true, forHelp );
- }
-
- private static void assertNextTokenTakesAnOptionalArgument( OptionSpecTokenizer lexer, char option,
- boolean forHelp ) {
-
- assertNextToken( lexer, option, true, false, forHelp );
- }
-
- private static void assertNextToken( OptionSpecTokenizer lexer, char option, boolean acceptsArguments,
- boolean requiresArgument, boolean forHelp ) {
-
- assertTrue( "no more tokens?", lexer.hasMore() );
- AbstractOptionSpec<?> spec = lexer.next();
- assertThat( "option?", spec.options(), hasSameContentsAs( singleton( String.valueOf( option ) ) ) );
- assertEquals( "accepts args?", acceptsArguments, spec.acceptsArguments() );
- assertEquals( "requires arg?", requiresArgument, spec.requiresArgument() );
- assertEquals( "for help?", forHelp, spec.isForHelp() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSpecsReportTheirOptionsSortedSpeciallyTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSpecsReportTheirOptionsSortedSpeciallyTest.java
deleted file mode 100644
index ff531dd..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSpecsReportTheirOptionsSortedSpeciallyTest.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static java.util.Arrays.*;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSpecsReportTheirOptionsSortedSpeciallyTest {
- @Test
- public void shortOptionsComeFirstFollowedByLongOptionsLexicographically() {
- AbstractOptionSpec<Void> spec = new NoArgumentOptionSpec( asList( "after-date", "n", "N", "past" ), "" );
-
- List<String> actualOptions = new ArrayList<>( spec.options() );
-
- assertEquals( asList( "N", "n", "after-date", "past" ), actualOptions );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymCommonPrefixesTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymCommonPrefixesTest.java
deleted file mode 100644
index 986761d..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymCommonPrefixesTest.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSynonymCommonPrefixesTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.acceptsAll( asList( "v", "verbose" ) );
- }
-
- @Test
- public void parsingFirstPrefix() {
- assertDetections( "-v" );
- }
-
- @Test
- public void parsingSecondPrefix() {
- assertDetections( "-ve" );
- }
-
- @Test
- public void parsingThirdPrefix() {
- assertDetections( "-ver" );
- }
-
- @Test
- public void parsingFourthPrefix() {
- assertDetections( "-verb" );
- }
-
- @Test
- public void parsingFifthPrefix() {
- assertDetections( "-verbo" );
- }
-
- @Test
- public void parsingSixthPrefix() {
- assertDetections( "-verbos" );
- }
-
- @Test
- public void parsingSeventhPrefix() {
- assertDetections( "-verbose" );
- }
-
- private void assertDetections( String option ) {
- OptionSet options = parser.parse( option );
-
- assertOptionDetected( options, "v" );
- assertOptionNotDetected( options, "ve" );
- assertOptionNotDetected( options, "ver" );
- assertOptionNotDetected( options, "verb" );
- assertOptionNotDetected( options, "verbo" );
- assertOptionNotDetected( options, "verbos" );
- assertOptionDetected( options, "verbose" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymNoArgumentTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymNoArgumentTest.java
deleted file mode 100644
index 2b66176..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymNoArgumentTest.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSynonymNoArgumentTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.acceptsAll( asList( "N", "after-date", "newer" ) );
- }
-
- @Test
- public void hasAllSynonymsWhenFirstSynonymParsed() {
- assertDetections( "-N" );
- }
-
- @Test
- public void hasAllSynonymsWhenSecondSynonymParsed() {
- assertDetections( "--after-d" );
- }
-
- @Test
- public void hasAllSynonymsWhenThirdSynonymParsed() {
- assertDetections( "--n" );
- }
-
- private void assertDetections( String option ) {
- OptionSet options = parser.parse( option );
-
- assertOptionDetected( options, "N" );
- assertOptionDetected( options, "after-date" );
- assertOptionDetected( options, "newer" );
- assertEquals( emptyList(), options.valuesOf( "N" ) );
- assertEquals( emptyList(), options.valuesOf( "after-date" ) );
- assertEquals( emptyList(), options.valuesOf( "newer" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymOptionalArgumentTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymOptionalArgumentTest.java
deleted file mode 100644
index 5ff03e5..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymOptionalArgumentTest.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.io.File;
-import java.util.List;
-
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSynonymOptionalArgumentTest extends AbstractOptionParserFixture {
- private String optionArgument;
-
- @Before
- public final void initializeParser() {
- parser.acceptsAll( asList( "d", "output-dir", "folder" ), "file" ).withRequiredArg().ofType( File.class );
- optionArgument = "tmp";
- }
-
- @Test
- public void hasAllSynonymsWhenFirstSynonymParsed() {
- assertDetections( new String[] { "-d", optionArgument }, singletonList( new File( optionArgument ) ) );
- }
-
- @Test
- public void hasAllSynonymsWhenSecondSynonymParsed() {
- assertDetections( new String[] { "--ou", optionArgument }, singletonList( new File( optionArgument ) ) );
- }
-
- @Test
- public void hasAllSynonymsWhenThirdSynonymParsed() {
- assertDetections( new String[] { "--fold", optionArgument }, singletonList( new File( optionArgument ) ) );
- }
-
- @Test
- public void reportsSameListOfArgumentsForEverySynonymOption() {
- assertDetections(
- new String[] { "-d", "opt", "--output-dir", "tmp", "--folder", "usr" },
- asList( new File( "opt" ), new File( "tmp" ), new File( "usr" ) ) );
- }
-
- private void assertDetections( String[] args, List<?> optionArguments ) {
- OptionSet options = parser.parse( args );
- assertEquals( optionArguments, options.valuesOf( "d" ) );
- assertEquals( optionArguments, options.valuesOf( "output-dir" ) );
- assertEquals( optionArguments, options.valuesOf( "folder" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymOverwritingTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymOverwritingTest.java
deleted file mode 100644
index 3294d34..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymOverwritingTest.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSynonymOverwritingTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.acceptsAll( asList( "h", "help" ) );
- parser.acceptsAll( asList( "h", "oops" ) );
- }
-
- @Test
- public void treatsHAsThoughItWereLastDefinedSynonymOfH() {
- OptionSet options = parser.parse( "-h" );
-
- assertOptionDetected( options, "h" );
- assertOptionDetected( options, "oops" );
- assertOptionNotDetected( options, "help" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymRequiredArgumentTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymRequiredArgumentTest.java
deleted file mode 100644
index 10d7889..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionSynonymRequiredArgumentTest.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.List;
-
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionSynonymRequiredArgumentTest extends AbstractOptionParserFixture {
- private String optionArgument;
-
- @Before
- public final void initializeParser() {
- parser.acceptsAll( asList( "N", "after-date", "newer" ), "date" ).withRequiredArg().ofType( Integer.class );
- optionArgument = "2000";
- }
-
- @Test
- public void hasAllSynonymsWhenFirstSynonymParsed() {
- assertDetections( new String[] { "-N", optionArgument }, singletonList( Integer.valueOf( optionArgument ) ) );
- }
-
- @Test
- public void hasAllSynonymsWhenSecondSynonymParsed() {
- assertDetections(
- new String[] { "--after-date", optionArgument },
- singletonList( Integer.valueOf( optionArgument ) ) );
- }
-
- @Test
- public void hasAllSynonymsWhenThirdSynonymParsed() {
- assertDetections(
- new String[] { "--newer", optionArgument },
- singletonList( Integer.valueOf( optionArgument ) ) );
- }
-
- @Test
- public void reportsSameListOfArgumentsForEverySynonymOption() {
- assertDetections( new String[] { "-N", "1", "-aft", "2", "--ne", "3" }, asList( 1, 2, 3 ) );
- }
-
- private void assertDetections( String[] args, List<?> optionArguments ) {
- OptionSet options = parser.parse( args );
-
- assertEquals( optionArguments, options.valuesOf( "N" ) );
- assertEquals( optionArguments, options.valuesOf( "after-date" ) );
- assertEquals( optionArguments, options.valuesOf( "newer" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionalArgumentOptionSpecOptionsImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionalArgumentOptionSpecOptionsImmutabilityTest.java
deleted file mode 100644
index 86765a5..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionalArgumentOptionSpecOptionsImmutabilityTest.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionalArgumentOptionSpecOptionsImmutabilityTest extends AbstractOptionSpecOptionsImmutabilityTestCase {
- @Override
- protected AbstractOptionSpec<?> newOptionSpec( String option ) {
- return new OptionalArgumentOptionSpec<Integer>( option );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionalArgumentOptionSpecTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionalArgumentOptionSpecTest.java
deleted file mode 100644
index 6f5c275..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionalArgumentOptionSpecTest.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-
-import org.junit.Test;
-
-import static org.infinitest.toolkit.CollectionMatchers.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionalArgumentOptionSpecTest extends AbstractOptionSpecFixture {
- @Override
- protected OptionalArgumentOptionSpec<?> createEqualOptionSpecInstance() {
- return new OptionalArgumentOptionSpec<Void>( "d" );
- }
-
- @Override
- protected OptionalArgumentOptionSpec<?> createNotEqualOptionSpecInstance() {
- return new OptionalArgumentOptionSpec<Void>( "c" );
- }
-
- @Test
- public void optionsContents() {
- assertThat( createNotEqualOptionSpecInstance().options(), hasSameContentsAs( asList( "c" ) ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionalArgumentOptionSpecValuesImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/OptionalArgumentOptionSpecValuesImmutabilityTest.java
deleted file mode 100644
index 841b946..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/OptionalArgumentOptionSpecValuesImmutabilityTest.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class OptionalArgumentOptionSpecValuesImmutabilityTest
- extends AbstractOptionSpecValuesImmutabilityTestCase<Integer> {
-
- @Override
- protected AbstractOptionSpec<Integer> newOptionSpec() {
- return new OptionalArgumentOptionSpec<Integer>( "life" ).ofType( Integer.class );
- }
-
- @Override
- protected String firstArg() {
- return "1";
- }
-
- @Override
- protected String secondArg() {
- return "2";
- }
-
- @Override
- protected Integer newItem() {
- return 3;
- }
-
- @Override
- protected Integer containedItem() {
- return 2;
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ParserRulesUtilityClassTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ParserRulesUtilityClassTest.java
deleted file mode 100644
index 82317be..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ParserRulesUtilityClassTest.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ParserRulesUtilityClassTest extends UtilityClassesUninstantiabilityHarness {
- public ParserRulesUtilityClassTest() {
- super( ParserRules.class );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ParsingSeparatedConvertedOptionValuesTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ParsingSeparatedConvertedOptionValuesTest.java
deleted file mode 100644
index 4e18003..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ParsingSeparatedConvertedOptionValuesTest.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.io.File;
-
-import static java.util.Arrays.*;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ParsingSeparatedConvertedOptionValuesTest extends AbstractOptionParserFixture {
- @Test
- public void parsesSeparatedValuesAsSeparateArgument() {
- assertCorrectParse( "classpath", ':', "--classpath", "/usr:/opt:/var" );
- }
-
- @Test
- public void parsesSeparatedValuesWhenArgumentAbuttedWithEquals() {
- assertCorrectParse( "classpath", ':', "--classpath=/usr:/opt:/var" );
- }
-
- @Test
- public void parsesEqualsSeparatedValuesWhenArgumentAbuttedWithEquals() {
- assertCorrectParse( "classpath", '=', "--classpath=/usr=/opt=/var" );
- }
-
- @Test
- public void parsesSeparatedValuesAbutting() {
- assertCorrectParse( "c", ':', "-c/usr:/opt:/var" );
- }
-
- private void assertCorrectParse( String option, char separator, String... args ) {
- parser.accepts( option ).withRequiredArg().withValuesSeparatedBy( separator )
- .withValuesConvertedBy( new ValueConverter<File>() {
- public File convert( String value ) {
- return new File( value );
- }
-
- public Class<File> valueType() {
- return File.class;
- }
-
- public String valuePattern() {
- return null;
- }
- } );
-
- OptionSet options = parser.parse( args );
-
- assertEquals(
- asList( new File( "/usr" ), new File( "/opt" ), new File( "/var" ) ),
- options.valuesOf( option ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ParsingSeparatedStringOptionValuesTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ParsingSeparatedStringOptionValuesTest.java
deleted file mode 100644
index 6cfe17f..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ParsingSeparatedStringOptionValuesTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ParsingSeparatedStringOptionValuesTest extends AbstractOptionParserFixture {
- @Test
- public void parsesSeparatedValuesAsSeparateArgument() {
- assertCorrectParse( "classpath", ":::", "--classpath", "/usr:::/opt:::/var" );
- }
-
- @Test
- public void parsesSeparatedValuesWhenArgumentAbuttedWithEquals() {
- assertCorrectParse( "classpath", ":", "--classpath=/usr:/opt:/var" );
- }
-
- @Test
- public void parsesEqualsSeparatedValuesWhenArgumentAbuttedWithEquals() {
- assertCorrectParse( "classpath", ":=", "--classpath=/usr:=/opt:=/var" );
- }
-
- @Test
- public void parsesSeparatedValuesAbutting() {
- assertCorrectParse( "c", ";", "-c/usr;/opt;/var" );
- }
-
- @Test
- public void parsesHyphenSeparatedValuesAbutting() {
- assertCorrectParse( "c", "--", "-c/usr--/opt--/var" );
- }
-
- @Test
- public void handlesConsecutiveDelimiters() {
- assertCorrectParse( "c", ",", "-c,/usr,,,/opt,,,/var,,,,," );
- }
-
- private void assertCorrectParse( String option, String separator, String... args ) {
- parser.accepts( option ).withRequiredArg().withValuesSeparatedBy( separator );
-
- OptionSet options = parser.parse( args );
-
- assertEquals( asList( "/usr", "/opt", "/var" ), options.valuesOf( option ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ParsingSeparatedTypedOptionValuesTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ParsingSeparatedTypedOptionValuesTest.java
deleted file mode 100644
index 0cfc1e9..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ParsingSeparatedTypedOptionValuesTest.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.io.File;
-
-import static java.util.Arrays.*;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ParsingSeparatedTypedOptionValuesTest extends AbstractOptionParserFixture {
- @Test
- public void parsesSeparatedValuesAsSeparateArgument() {
- assertCorrectParse( "classpath", ':', "--classpath", "/usr:/opt:/var" );
- }
-
- @Test
- public void parsesSeparatedValuesWhenArgumentAbuttedWithEquals() {
- assertCorrectParse( "classpath", ':', "--classpath=/usr:/opt:/var" );
- }
-
- @Test
- public void parsesEqualsSeparatedValuesWhenArgumentAbuttedWithEquals() {
- assertCorrectParse( "classpath", '=', "--classpath=/usr=/opt=/var" );
- }
-
- @Test
- public void parsesSeparatedValuesAbutting() {
- assertCorrectParse( "c", ':', "-c/usr:/opt:/var" );
- }
-
- private void assertCorrectParse( String option, char separator, String... args ) {
- parser.accepts( option ).withRequiredArg().ofType( File.class ).withValuesSeparatedBy( separator );
-
- OptionSet options = parser.parse( args );
-
- assertEquals(
- asList( new File( "/usr" ), new File( "/opt" ), new File( "/var" ) ),
- options.valuesOf( option ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/PlainOldOptionParserTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/PlainOldOptionParserTest.java
deleted file mode 100644
index 3fe8f50..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/PlainOldOptionParserTest.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class PlainOldOptionParserTest extends AbstractOptionParserFixture {
- @Test
- public void nonOptionsOnly() {
- String[] arguments = { "foo", "bar" };
-
- OptionSet options = parser.parse( arguments );
-
- assertEquals( asList( arguments ), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/PopulatedOptionSetTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/PopulatedOptionSetTest.java
deleted file mode 100644
index 5ac5036..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/PopulatedOptionSetTest.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-package joptsimple;
-
-import java.util.Collections;
-
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class PopulatedOptionSetTest {
- private OptionSet populated;
-
- @Before
- public void setUp() {
- populated = new OptionSet( Collections.<String, AbstractOptionSpec<?>> emptyMap() );
- populated.add( new NoArgumentOptionSpec( "a" ) );
- populated.addWithArgument( new RequiredArgumentOptionSpec<String>( "b" ), "arg-of-b" );
- }
-
- @Test
- public void hasArgument() {
- assertFalse( populated.hasArgument( "a" ) );
- assertTrue( populated.hasArgument( "b" ) );
- }
-
- @Test
- public void valueOf() {
- assertNull( populated.valueOf( "a" ) );
- assertEquals( "arg-of-b", populated.valueOf( "b" ) );
- }
-
- @Test
- public void valuesOf() {
- assertEquals( emptyList(), populated.valuesOf( "a" ) );
- assertEquals( singletonList( "arg-of-b" ), populated.valuesOf( "b" ) );
- }
-
- @Test
- public void hasOptions() {
- assertTrue( populated.hasOptions() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/PosixlyCorrectOptionParserTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/PosixlyCorrectOptionParserTest.java
deleted file mode 100644
index 027c0a2..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/PosixlyCorrectOptionParserTest.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.Collection;
-
-import static java.util.Arrays.*;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-@RunWith( Parameterized.class )
-public class PosixlyCorrectOptionParserTest {
- private final OptionParser parser;
-
- public PosixlyCorrectOptionParserTest( OptionParser parser ) {
- this.parser = parser;
- }
-
- @Parameterized.Parameters
- public static Collection<?> parsers() {
- return asList( new Object[] {
- new OptionParser() { {
- posixlyCorrect( true );
- accepts( "i" ).withRequiredArg();
- accepts( "j" ).withOptionalArg();
- accepts( "k" );
- } } },
- new Object[] { new OptionParser( "+i:j::k" ) } );
- }
-
- @Test
- public void parseWithPosixlyCorrect() {
- OptionSet options =
- parser.parse( "-ibar", "-i", "junk", "xyz", "-jixnay", "foo", "-k", "blah", "--", "yermom" );
-
- assertTrue( "i?", options.has( "i" ) );
- assertFalse( "j?", options.has( "j" ) );
- assertFalse( "k?", options.has( "k" ) );
- assertEquals( "args of i?", asList( "bar", "junk" ), options.valuesOf( "i" ) );
- assertEquals( "non-option args?",
- asList( "xyz", "-jixnay", "foo", "-k", "blah", "--", "yermom" ),
- options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/PunctuationInLongOptionTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/PunctuationInLongOptionTest.java
deleted file mode 100644
index 94e4e23..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/PunctuationInLongOptionTest.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class PunctuationInLongOptionTest extends AbstractOptionParserFixture {
- @Test
- public void allowsHyphensInTheMiddleOfOptionNames() {
- assertOptionAllowed( "hyphenated-option" );
- }
-
- @Test
- public void allowsHyphensPrettyMuchAnywhereButTheFront() {
- assertOptionAllowed( "a-cra-zy-but-le--gal---o-p-t-i-o--n-----" );
- }
-
- @Test( expected = IllegalOptionSpecificationException.class )
- public void disallowsHyphensAtFrontOfOptionName() {
- parser.accepts( "-weird-option" );
- }
-
- @Test
- public void allowsDotInOptionNames() {
- assertOptionAllowed( "..what.is.the.d..e...a....l..." );
- }
-
- @Test
- public void allowsQuestionMarkInOptionNames() {
- assertOptionAllowed( "??who?k??n???e????w?" );
- }
-
- @Test
- public void allowsUnderscoreInOptionNames() {
- assertOptionAllowed( "super_long_option_name" );
- }
-
- private void assertOptionAllowed( String option ) {
- parser.accepts( option );
-
- OptionSet options = parser.parse( "--" + option );
-
- assertTrue( options.has( option ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/PunctuationInShortOptionTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/PunctuationInShortOptionTest.java
deleted file mode 100644
index 20565b9..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/PunctuationInShortOptionTest.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class PunctuationInShortOptionTest {
- @Test( expected = IllegalOptionSpecificationException.class )
- public void disallowsHyphenAsShortOption() {
- new OptionParser( "-" );
- }
-
- @Test
- public void allowsQuestionMarkAsShortOption() {
- assertOptionAllowed( "?" );
- }
-
- @Test
- public void allowsDotAsShortOption() {
- assertOptionAllowed( "." );
- }
-
- @Test
- public void allowsUnderscoreAsShortOption() {
- assertOptionAllowed( "_" );
- }
-
- private void assertOptionAllowed( String option ) {
- OptionSet options = new OptionParser( option ).parse( '-' + option );
-
- assertTrue( options.has( option ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredArgumentOptionSpecEqualsHashCodeTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredArgumentOptionSpecEqualsHashCodeTest.java
deleted file mode 100644
index 9235d5c..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredArgumentOptionSpecEqualsHashCodeTest.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class RequiredArgumentOptionSpecEqualsHashCodeTest extends AbstractOptionSpecFixture {
- @Override
- protected RequiredArgumentOptionSpec<?> createEqualOptionSpecInstance() {
- return new RequiredArgumentOptionSpec<Void>( "a" );
- }
-
- @Override
- protected RequiredArgumentOptionSpec<?> createNotEqualOptionSpecInstance() {
- return new RequiredArgumentOptionSpec<Void>( "b" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredArgumentOptionSpecOptionsImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredArgumentOptionSpecOptionsImmutabilityTest.java
deleted file mode 100644
index e834d1b..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredArgumentOptionSpecOptionsImmutabilityTest.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class RequiredArgumentOptionSpecOptionsImmutabilityTest extends AbstractOptionSpecOptionsImmutabilityTestCase {
- @Override
- protected AbstractOptionSpec<?> newOptionSpec( String option ) {
- return new RequiredArgumentOptionSpec<String>( option );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredArgumentOptionSpecValuesImmutabilityTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredArgumentOptionSpecValuesImmutabilityTest.java
deleted file mode 100644
index f75a068..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredArgumentOptionSpecValuesImmutabilityTest.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class RequiredArgumentOptionSpecValuesImmutabilityTest
- extends AbstractOptionSpecValuesImmutabilityTestCase<String> {
-
- @Override
- protected AbstractOptionSpec<String> newOptionSpec() {
- return new RequiredArgumentOptionSpec<>( "file" );
- }
-
- @Override
- protected String firstArg() {
- return "arg1";
- }
-
- @Override
- protected String secondArg() {
- return "arg2";
- }
-
- @Override
- protected String newItem() {
- return "arg3";
- }
-
- @Override
- protected String containedItem() {
- return "arg1";
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredIfAnyTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredIfAnyTest.java
deleted file mode 100644
index 75c39d8..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredIfAnyTest.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class RequiredIfAnyTest extends AbstractOptionParserFixture {
- @Before
- public void configureParser() {
- parser.accepts( "a" );
- parser.accepts( "b" );
- OptionSpec<Void> c = parser.accepts( "c" );
- OptionSpec<Void> d = parser.accepts( "d" );
- parser.accepts( "e" );
- parser.accepts( "n" ).requiredIf( "a", "b" ).requiredIf( c, d );
- }
-
- @Test
- public void rejectsCommandLineMissingConditionallyRequiredOption() {
- thrown.expect( MissingRequiredOptionsException.class );
-
- parser.parse( "-a" );
- }
-
- @Test
- public void rejectsCommandLineMissingOtherConditionallyRequiredOption() {
- thrown.expect( MissingRequiredOptionsException.class );
-
- parser.parse( "-b" );
- }
-
- @Test
- public void rejectsCommandLineWithNotAllConditionallyRequiredOptionsPresent() {
- thrown.expect( MissingRequiredOptionsException.class );
-
- parser.parse( "-a", "-b", "-c", "-d" );
- }
-
- @Test
- public void acceptsCommandLineWithConditionallyRequiredOptionsPresent() {
- OptionSet options = parser.parse( "-b", "-n" );
-
- assertOptionDetected( options, "b" );
- assertOptionDetected( options, "n" );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void acceptsOptionWithPrerequisiteAsNormalIfPrerequisiteNotInPlay() {
- OptionSet options = parser.parse( "-n" );
-
- assertOptionDetected( options, "n" );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredIfTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredIfTest.java
deleted file mode 100644
index d5cbb17..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredIfTest.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class RequiredIfTest extends AbstractOptionParserFixture {
- @Before
- public void configureParser() {
- OptionSpec<Void> ftp = parser.acceptsAll( asList( "ftp", "file-transfer" ) );
- parser.acceptsAll( asList( "username", "userid" ) ).requiredIf( "file-transfer" ).withRequiredArg();
- parser.acceptsAll( asList( "password", "pwd" ) ).requiredIf( ftp ).withRequiredArg();
- parser.accepts( "?" ).forHelp();
- }
-
- @Test
- public void rejectsCommandLineMissingConditionallyRequiredOption() {
- thrown.expect( MissingRequiredOptionsException.class );
-
- parser.parse( "--ftp" );
- }
-
- @Test
- public void rejectsCommandLineMissingConditionallyRequiredOptionSynonym() {
- thrown.expect( MissingRequiredOptionsException.class );
-
- parser.parse( "--file-transfer" );
- }
-
- @Test
- public void rejectsCommandLineWithNotAllConditionallyRequiredOptionsPresent() {
- thrown.expect( MissingRequiredOptionsException.class );
-
- parser.parse( "--ftp", "--username", "joe" );
- }
-
- @Test
- public void acceptsCommandLineWithConditionallyRequiredOptionsPresent() {
- OptionSet options = parser.parse( "--ftp", "--userid", "joe", "--password=secret" );
-
- assertOptionDetected( options, "ftp" );
- assertOptionDetected( options, "username" );
- assertOptionDetected( options, "password" );
- assertEquals( singletonList( "joe" ), options.valuesOf( "username" ) );
- assertEquals( singletonList( "secret" ), options.valuesOf( "password" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void acceptsOptionWithPrerequisiteAsNormalIfPrerequisiteNotInPlay() {
- OptionSet options = parser.parse( "--pwd", "secret" );
-
- assertOptionDetected( options, "pwd" );
- assertEquals( singletonList( "secret" ), options.valuesOf( "pwd" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void rejectsOptionNotAlreadyConfigured() {
- thrown.expect( UnconfiguredOptionException.class );
-
- parser.accepts( "foo" ).requiredIf( "bar" );
- }
-
- @Test
- public void rejectsOptionSpecNotAlreadyConfigured() {
- thrown.expect( UnconfiguredOptionException.class );
-
- parser.accepts( "foo" ).requiredIf( "bar" );
- }
-
- @Test
- public void presenceOfHelpOptionNegatesRequiredIfness() {
- OptionSet options = parser.parse( "--ftp", "-?" );
-
- assertOptionDetected( options, "ftp" );
- assertOptionDetected( options, "?" );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredUnlessAnyTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredUnlessAnyTest.java
deleted file mode 100644
index d61dd78..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredUnlessAnyTest.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static java.util.Collections.emptyList;
-import static org.junit.Assert.assertEquals;
-
-public class RequiredUnlessAnyTest extends AbstractOptionParserFixture {
- @Before
- public void configureParser() {
- parser.accepts( "a" );
- parser.accepts( "b" );
- OptionSpec<Void> c = parser.accepts( "c" );
- OptionSpec<Void> d = parser.accepts( "d" );
- parser.accepts( "e" );
- parser.accepts( "n" ).requiredUnless( "a", "b" ).requiredUnless( c, d );
- }
-
- @Test
- public void commandLineMissingConditionallyRequiredOption() {
- OptionSet options = parser.parse( "-a" );
- assertOptionDetected( options, "a" );
- assertOptionNotDetected( options, "n" );
- }
-
- @Test
- public void commandLineWithNotAllConditionallyRequiredOptionsPresent() {
- OptionSet options = parser.parse( "-a", "-b", "-c", "-d" );
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertOptionDetected( options, "c" );
- assertOptionDetected( options, "d" );
- assertOptionNotDetected( options, "n" );
- }
-
- @Test
- public void acceptsCommandLineWithConditionallyRequiredOptionsPresent() {
- OptionSet options = parser.parse( "-n" );
-
- assertOptionDetected( options, "n" );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void acceptsOptionWithPrerequisiteAsNormalIfPrerequisiteNotInPlay() {
- OptionSet options = parser.parse( "-a", "-n" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "n" );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredUnlessTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredUnlessTest.java
deleted file mode 100644
index ed5b47b..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/RequiredUnlessTest.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static java.util.Arrays.asList;
-import static java.util.Collections.emptyList;
-import static java.util.Collections.singletonList;
-import static org.junit.Assert.assertEquals;
-
-public class RequiredUnlessTest extends AbstractOptionParserFixture {
- @Before
- public void configureParser() {
- OptionSpec<Void> anonymous = parser.accepts( "anonymous" );
- parser.acceptsAll( asList( "username", "userid" ) ).requiredUnless( "anonymous" ).withRequiredArg();
- parser.acceptsAll( asList( "password", "pwd" ) ).requiredUnless( anonymous ).withRequiredArg();
- parser.accepts( "?" ).forHelp();
- }
-
- @Test
- public void rejectsCommandLineMissingConditionallyRequiredOption() {
- thrown.expect( MissingRequiredOptionsException.class );
-
- parser.parse( "" );
- }
-
- @Test
- public void rejectsCommandLineWithNotAllConditionallyRequiredOptionsPresent() {
- thrown.expect( MissingRequiredOptionsException.class );
-
- parser.parse( "--username", "joe" );
- }
-
- @Test
- public void acceptsCommandLineWithConditionallyRequiredOptionsPresent() {
- OptionSet options = parser.parse( "--userid", "joe", "--password=secret" );
-
- assertOptionNotDetected( options, "anonymous" );
- assertOptionDetected( options, "username" );
- assertOptionDetected( options, "password" );
- assertEquals( singletonList( "joe" ), options.valuesOf( "username" ) );
- assertEquals( singletonList( "secret" ), options.valuesOf( "password" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void acceptsOptionWithPrerequisite() {
- OptionSet options = parser.parse( "--anonymous" );
-
- assertOptionDetected( options, "anonymous" );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void acceptsOptionWithPrerequisiteAsNormal() {
- OptionSet options = parser.parse( "--anonymous", "--pwd", "secret" );
-
- assertOptionDetected( options, "anonymous" );
- assertOptionDetected( options, "pwd" );
- assertEquals( singletonList( "secret" ), options.valuesOf( "pwd" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void rejectsOptionNotAlreadyConfigured() {
- thrown.expect( UnconfiguredOptionException.class );
-
- parser.accepts( "foo" ).requiredIf( "bar" );
- }
-
- @Test
- public void rejectsOptionSpecNotAlreadyConfigured() {
- thrown.expect( UnconfiguredOptionException.class );
-
- parser.accepts( "foo" ).requiredIf( "bar" );
- }
-
- @Test
- public void presenceOfHelpOptionNegatesRequiredUnlessness() {
- OptionSet options = parser.parse( "-?" );
-
- assertOptionDetected( options, "?" );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ShortOptionsNoArgumentTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ShortOptionsNoArgumentTest.java
deleted file mode 100644
index 6c2af89..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ShortOptionsNoArgumentTest.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static joptsimple.ParserRules.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ShortOptionsNoArgumentTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "a" );
- parser.accepts( "b" );
- parser.accepts( "c" );
- }
-
- @Test
- public void singleOption() {
- OptionSet options = parser.parse( "-a" );
-
- assertOptionDetected( options, "a" );
- assertNull( options.valueOf( "a" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void twoSingleOptions() {
- OptionSet options = parser.parse( "-a", "-b" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertNull( options.valueOf( "a" ) );
- assertNull( options.valueOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void singleOptionWithOneNonOptionArgument() {
- OptionSet options = parser.parse( "-c", "foo" );
-
- assertOptionDetected( options, "c" );
- assertNull( options.valueOf( "c" ) );
- assertEquals( singletonList( "foo" ), options.nonOptionArguments() );
- }
-
- @Test
- public void clusteredOptions() {
- OptionSet options = parser.parse( "-bac" );
-
- assertOptionDetected( options, "a" );
- assertOptionDetected( options, "b" );
- assertOptionDetected( options, "c" );
- assertNull( options.valueOf( "a" ) );
- assertNull( options.valueOf( "b" ) );
- assertNull( options.valueOf( "c" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void optionsTerminator() {
- OptionSet options = parser.parse( "-a", OPTION_TERMINATOR, "-a", "-b" );
-
- assertOptionDetected( options, "a" );
- assertNull( options.valueOf( "a" ) );
- assertOptionNotDetected( options, "b" );
- assertEquals( asList( "-a", "-b" ), options.nonOptionArguments() );
- }
-
- @Test
- public void appearingMultipleTimes() {
- OptionSet options = parser.parse( "-b", "-b", "-b" );
-
- assertOptionDetected( options, "b" );
- assertNull( options.valueOf( "b" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ShortOptionsOptionalArgumentTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ShortOptionsOptionalArgumentTest.java
deleted file mode 100644
index 3616d88..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ShortOptionsOptionalArgumentTest.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static joptsimple.ExceptionMatchers.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ShortOptionsOptionalArgumentTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "f" ).withOptionalArg();
- parser.accepts( "g" ).withOptionalArg();
- parser.accepts( "bar" ).withOptionalArg();
- }
-
- @Test
- public void optionWithOptionalArgumentNotPresent() {
- OptionSet options = parser.parse( "-f" );
-
- assertOptionDetected( options, "f" );
- assertEquals( emptyList(), options.valuesOf( "f" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void optionWithOptionalArgumentPresent() {
- OptionSet options = parser.parse( "-f", "bar" );
-
- assertOptionDetected( options, "f" );
- assertEquals( singletonList( "bar" ), options.valuesOf( "f" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void optionWithOptionalArgumentThatLooksLikeAnInvalidOption() {
- thrown.expect( UnrecognizedOptionException.class );
- thrown.expect( withOption( "biz" ) );
-
- parser.parse( "-f", "--biz" );
- }
-
- @Test
- public void optionWithOptionalArgumentThatLooksLikeAValidOption() {
- OptionSet options = parser.parse( "-f", "--bar" );
-
- assertOptionDetected( options, "f" );
- assertOptionDetected( options, "bar" );
- assertEquals( emptyList(), options.valuesOf( "f" ) );
- assertEquals( emptyList(), options.valuesOf( "bar" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void optionWithOptionalArgumentFollowedByLegalOption() {
- OptionSet options = parser.parse( "-f", "-g" );
-
- assertOptionDetected( options, "f" );
- assertOptionDetected( options, "g" );
- assertEquals( emptyList(), options.valuesOf( "f" ) );
- assertEquals( emptyList(), options.valuesOf( "g" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void multipleOfSameOptionSomeWithArgsAndSomeWithout() {
- OptionSet options = parser.parse( "-f", "-f", "foo", "-f", "-f", "bar", "-f" );
-
- assertEquals( asList( "foo", "bar" ), options.valuesOf( "f" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ShortOptionsRequiredArgumentTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ShortOptionsRequiredArgumentTest.java
deleted file mode 100644
index dea86ca..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ShortOptionsRequiredArgumentTest.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static joptsimple.ExceptionMatchers.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ShortOptionsRequiredArgumentTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "d" ).withRequiredArg();
- parser.accepts( "e" );
- parser.accepts( "f" );
- parser.accepts( "infile" ).withOptionalArg();
- }
-
- @Test
- public void argumentNotPresent() {
- thrown.expect( OptionMissingRequiredArgumentException.class );
- thrown.expect( withOption( "d" ) );
-
- parser.parse( "-d" );
- }
-
- @Test
- public void withArgument() {
- OptionSet options = parser.parse( "-d", "foo" );
-
- assertOptionDetected( options, "d" );
- assertEquals( "foo", options.valueOf( "d" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void clusteredOptionsWithLastOneAcceptingAnArgumentButMissing() {
- thrown.expect( OptionMissingRequiredArgumentException.class );
-
- parser.parse( "-fed" );
- }
-
- @Test
- public void clusteredOptionsWithLastOneAcceptingAnArgument() {
- OptionSet options = parser.parse( "-fed", "foo" );
-
- assertOptionDetected( options, "d" );
- assertOptionDetected( options, "f" );
- assertOptionDetected( options, "e" );
- assertEquals( "foo", options.valueOf( "d" ) );
- }
-
- @Test
- public void clusteredOptionsWithOneAcceptingAnArgument() {
- OptionSet options = parser.parse( "-fde" );
-
- assertOptionDetected( options, "f" );
- assertOptionDetected( options, "d" );
- assertOptionNotDetected( options, "e" );
-
- assertEquals( "e", options.valueOf( "d" ) );
- }
-
- @Test
- public void argumentNotPresentFollowedByAnotherOption() {
- OptionSet options = parser.parse( "-d", "--infile" );
-
- assertOptionDetected( options, "d" );
- assertOptionNotDetected( options, "infile" );
- assertEquals( "--infile", options.valueOf( "d" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void appearingMultipleTimes() {
- OptionSet options = parser.parse( "-d", "foo", "-d", "bar" );
-
- assertOptionDetected( options, "d" );
- assertEquals( asList( "foo", "bar" ), options.valuesOf( "d" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void inSameToken() {
- OptionSet options = parser.parse( "-dfoo" );
-
- assertOptionDetected( options, "d" );
- assertEquals( singletonList( "foo" ), options.valuesOf( "d" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void whenEndOfOptionsMarkerIsInPlaceOfRequiredArgument() {
- OptionSet options = parser.parse( "-d", "--", "foo", "bar" );
-
- assertOptionDetected( options, "d" );
- assertEquals( singletonList( "--" ), options.valuesOf( "d" ) );
- assertEquals( asList( "foo", "bar" ), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/SingleHyphenTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/SingleHyphenTest.java
deleted file mode 100644
index 7c88a7d..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/SingleHyphenTest.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class SingleHyphenTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "o" ).withOptionalArg();
- }
-
- @Test
- public void singleHyphen() {
- OptionSet options = parser.parse( "-" );
-
- assertEquals( singletonList( "-" ), options.nonOptionArguments() );
- }
-
- @Test
- public void asArgumentOfOption() {
- OptionSet options = parser.parse( "-o", "-" );
-
- assertOptionDetected( options, "o" );
- assertEquals( singletonList( "-" ), options.valuesOf( "o" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void asArgumentOfOptionInSameToken() {
- OptionSet options = parser.parse( "-o-" );
-
- assertOptionDetected( options, "o" );
- assertEquals( singletonList( "-" ), options.valuesOf( "o" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ToStringTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ToStringTest.java
deleted file mode 100644
index 0b01a78..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ToStringTest.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.Collection;
-
-import static com.google.common.collect.Lists.newArrayList;
-import static java.util.Arrays.*;
-
-import joptsimple.util.KeyValuePair;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-import static org.hamcrest.CoreMatchers.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-@RunWith( Parameterized.class )
-public class ToStringTest {
- private final Object subject;
- private final String[] substrings;
-
- public ToStringTest( Object subject, String[] substrings ) {
- this.subject = subject;
- this.substrings = substrings.clone();
- }
-
- @Parameterized.Parameters
- public static Collection<?> objectsAndStringRepresentations() {
- return asList( new Object[][] {
- { KeyValuePair.valueOf( "key=value" ), new String[] { "key", "=", "value" } },
- { new UnrecognizedOptionException( "a" ), new String[] { "a" } },
- { new NoArgumentOptionSpec( asList( "a", "b" ), "" ), new String[] { "[a, b]" } },
- { new UnavailableOptionException(
- newArrayList( new NoArgumentOptionSpec( "a" ), new NoArgumentOptionSpec( "b" ) ) ),
- new String[] { "[a, b]" } },
- } );
- }
-
- @Test
- public void givesUsefulStringRepresentations() {
- String stringRepresentation = subject.toString();
-
- for ( String each : substrings )
- assertThat( stringRepresentation, containsString( each ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/TypesafeOptionArgumentRetrievalTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/TypesafeOptionArgumentRetrievalTest.java
deleted file mode 100644
index cea1e72..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/TypesafeOptionArgumentRetrievalTest.java
+++ /dev/null
@@ -1,317 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.util.List;
-
-import org.junit.Test;
-
-import static java.lang.Short.*;
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-import static joptsimple.ExceptionMatchers.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class TypesafeOptionArgumentRetrievalTest extends AbstractOptionParserFixture {
- @Test
- public void retrievalOfTypedRequiredArgumentsInATypesafeManner() {
- OptionSpec<Integer> optionA = parser.accepts( "a" ).withRequiredArg().ofType( Integer.class );
-
- OptionSet options = parser.parse( "-a", "1" );
-
- assertTrue( options.has( optionA ) );
- Integer valueFromOption = optionA.value( options );
- assertEquals( Integer.valueOf( 1 ), valueFromOption );
- Integer valueFromOptionSet = options.valueOf( optionA );
- assertEquals( valueFromOption, valueFromOptionSet );
-
- List<Integer> valuesFromOption = optionA.values( options );
- assertEquals( asList( 1 ), valuesFromOption );
- List<Integer> valuesFromOptionSet = options.valuesOf( optionA );
- assertEquals( valuesFromOption, valuesFromOptionSet );
- }
-
- @Test
- public void retrievalOfTypedOptionalArgumentsInATypesafeManner() {
- OptionSpec<Double> optionB = parser.accepts( "b" ).withOptionalArg().ofType( Double.class );
-
- OptionSet options = parser.parse( "-b", "3.14D" );
-
- assertTrue( options.has( optionB ) );
- assertEquals( Double.valueOf( 3.14D ), optionB.value( options ) );
- assertEquals( asList( 3.14D ), optionB.values( options ) );
- }
-
- @Test
- public void retrievalOfUntypedRequiredArgumentsInATypesafeManner() {
- OptionSpec<String> optionC = parser.accepts( "c" ).withRequiredArg();
-
- OptionSet options = parser.parse( "-c", "foo", "-c", "bar" );
-
- assertTrue( options.has( optionC ) );
- assertEquals( asList( "foo", "bar" ), optionC.values( options ) );
- }
-
- @Test
- public void retrievalOfUntypedOptionalArgumentsInATypesafeManner() {
- OptionSpec<String> optionD = parser.accepts( "d" ).withRequiredArg();
-
- OptionSet options = parser.parse( "-d", "foo", "-d", "bar", "-d", "baz" );
-
- assertTrue( options.has( optionD ) );
- List<String> valuesFromOption = optionD.values( options );
- assertEquals( asList( "foo", "bar", "baz" ), valuesFromOption );
- List<String> valuesFromOptionSet = options.valuesOf( optionD );
- assertEquals( valuesFromOption, valuesFromOptionSet );
- }
-
- @Test
- public void retrievalWithVoidOption() {
- OptionSpec<Void> optionE = parser.accepts( "e" );
-
- OptionSet options = parser.parse( "-e" );
-
- assertTrue( options.has( optionE ) );
- assertEquals( emptyList(), options.valuesOf( optionE ) );
- }
-
- @Test
- public void primitiveBooleanAllowedAsTypeSpecifier() {
- OptionSpec<Boolean> optionA = parser.accepts( "a" ).withRequiredArg().ofType( boolean.class );
-
- OptionSet options = parser.parse( "-a", "false" );
-
- assertTrue( options.has( optionA ) );
- assertEquals( asList( false ), options.valuesOf( optionA ) );
- }
-
- @Test
- public void primitiveByteAllowedAsTypeSpecifier() {
- OptionSpec<Byte> optionB = parser.accepts( "b" ).withOptionalArg().ofType( byte.class );
-
- OptionSet options = parser.parse( "-b", "3" );
-
- assertTrue( options.has( optionB ) );
- assertEquals( asList( Byte.valueOf( "3" ) ), options.valuesOf( optionB ) );
- }
-
- @Test( expected = IllegalArgumentException.class )
- public void primitiveCharAllowedAsTypeSpecifier() {
- parser.accepts( "c" ).withRequiredArg().ofType( char.class );
- }
-
- @Test
- public void primitiveDoubleAllowedAsTypeSpecifier() {
- OptionSpec<Double> optionD = parser.accepts( "d" ).withOptionalArg().ofType( double.class );
-
- OptionSet options = parser.parse( "-d", "3.1" );
-
- assertTrue( options.has( optionD ) );
- assertEquals( asList( 3.1D ), options.valuesOf( optionD ) );
- }
-
- @Test
- public void primitiveFloatAllowedAsTypeSpecifier() {
- OptionSpec<Float> optionE = parser.accepts( "e" ).withRequiredArg().ofType( float.class );
-
- OptionSet options = parser.parse( "-e", "2.09" );
-
- assertTrue( options.has( optionE ) );
- assertEquals( asList( 2.09F ), options.valuesOf( optionE ) );
- }
-
- @Test
- public void primitiveIntAllowedAsTypeSpecifier() {
- OptionSpec<Integer> optionF = parser.accepts( "F" ).withRequiredArg().ofType( int.class );
-
- OptionSet options = parser.parse( "-F", "91" );
-
- assertTrue( options.has( optionF ) );
- assertEquals( asList( 91 ), options.valuesOf( optionF ) );
- }
-
- @Test
- public void primitiveLongAllowedAsTypeSpecifier() {
- OptionSpec<Long> optionG = parser.accepts( "g" ).withOptionalArg().ofType( long.class );
-
- OptionSet options = parser.parse("-g", "12");
-
- assertTrue( options.has( optionG ) );
- assertEquals( asList( 12L ), options.valuesOf( optionG ) );
- }
-
- @Test
- public void primitiveShortAllowedAsTypeSpecifier() {
- OptionSpec<Short> optionH = parser.accepts( "H" ).withRequiredArg().ofType( short.class );
-
- OptionSet options = parser.parse( "-H", "8" );
-
- assertTrue( options.has( optionH ) );
- assertEquals( asList( Short.valueOf( "8" ) ), options.valuesOf( optionH ) );
- }
-
- @Test
- public void cannotFoolHasWithAnOptionNotIssuedFromBuilder() {
- parser.accepts( "e" );
-
- OptionSet options = parser.parse( "-e" );
-
- assertFalse( options.has( new FakeOptionSpec<Void>( "e" ) ) );
- }
-
- @Test
- public void cannotFoolHasArgumentWithAnOptionNotIssuedFromBuilder() {
- parser.accepts( "f" ).withRequiredArg();
- OptionSpec<String> fakeOptionF = new FakeOptionSpec<>( "f" );
-
- OptionSet options = parser.parse( "-f", "boo" );
-
- assertFalse( options.hasArgument( fakeOptionF ) );
- }
-
- @Test
- public void cannotFoolValueOfWithAnOptionNotIssuedFromBuilder() {
- parser.accepts( "g" ).withRequiredArg();
-
- OptionSet options = parser.parse( "-g", "foo" );
-
- assertNull( options.valueOf( new FakeOptionSpec<String>( "g" ) ) );
- }
-
- @Test
- public void cannotFoolValuesOfWithAnOptionNotIssuedFromBuilder() {
- parser.accepts( "h" ).withRequiredArg();
-
- OptionSet options = parser.parse( "-h", "foo", "-h", "bar" );
-
- assertEquals( emptyList(), options.valuesOf( new FakeOptionSpec<String>( "h" ) ) );
- }
-
- @Test( expected = ClassCastException.class )
- public void canSubvertTypeSafetyIfYouUseAnOptionSpecAsTheWrongType() {
- ArgumentAcceptingOptionSpec<String> optionI = parser.accepts( "i" ).withRequiredArg();
- optionI.ofType( Integer.class );
-
- OptionSet options = parser.parse( "-i", "2" );
-
- @SuppressWarnings( "unused" )
- String value = optionI.value( options );
- }
-
- @Test( expected = ClassCastException.class )
- public void canSubvertTypeSafetyIfYouGiveAnOptionSpecToOptionSetAsTheWrongType() {
- ArgumentAcceptingOptionSpec<String> optionJ = parser.accepts( "j" ).withRequiredArg();
- optionJ.ofType( Integer.class );
-
- OptionSet options = parser.parse( "-j", "3" );
-
- @SuppressWarnings( "unused" )
- String value = options.valuesOf( optionJ ).get( 0 );
- }
-
- @Test
- public void canUseBooleanType() {
- OptionSpec<Boolean> optionK = parser.accepts( "k" ).withRequiredArg().ofType( Boolean.class );
-
- OptionSet options = parser.parse( "-k", "true" );
-
- assertTrue( optionK.value( options ) );
- }
-
- @Test
- public void usesConverterIfProvided() {
- OptionSpec<Short> optionL = parser.accepts( "L" ).withRequiredArg().withValuesConvertedBy(
- new ValueConverter<Short>() {
- public Short convert( String value ) {
- return parseShort( value );
- }
-
- public Class<Short> valueType() {
- return Short.class;
- }
-
- public String valuePattern() {
- return null;
- }
- } );
-
- OptionSet options = parser.parse( "-L", "34" );
-
- assertEquals( new Short( (short) 34 ), optionL.value( options ) );
- }
-
- @Test
- public void wrapsValueConversionExceptionsRaisedByConverter() {
- OptionSpec<Character> optionM = parser.accepts( "m" ).withRequiredArg().withValuesConvertedBy(
- new ValueConverter<Character>() {
- public Character convert( String value ) {
- throw new ValueConversionException( value );
- }
-
- public Class<Character> valueType() {
- return Character.class;
- }
-
- public String valuePattern() {
- return null;
- }
- } );
-
- OptionSet options = parser.parse( "-m", "a" );
-
- thrown.expect( OptionArgumentConversionException.class );
- thrown.expect( withCauseOfType( ValueConversionException.class ) );
-
- optionM.value( options );
- }
-
- private static class FakeOptionSpec<V> implements OptionSpec<V> {
- private final String option;
-
- FakeOptionSpec( String option ) {
- this.option = option;
- }
-
- public List<String> options() {
- return asList( option );
- }
-
- public V value( OptionSet detectedOptions ) {
- return detectedOptions.valueOf( this );
- }
-
- public List<V> values( OptionSet detectedOptions ) {
- return detectedOptions.valuesOf( this );
- }
-
- public boolean isForHelp() {
- return false;
- }
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/UtilityClassesUninstantiabilityHarness.java b/third_party/java/jopt-simple/src/test/java/joptsimple/UtilityClassesUninstantiabilityHarness.java
deleted file mode 100644
index e70dba7..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/UtilityClassesUninstantiabilityHarness.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-
-import static joptsimple.ExceptionMatchers.*;
-import static org.junit.rules.ExpectedException.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public abstract class UtilityClassesUninstantiabilityHarness {
- @Rule public final ExpectedException thrown = none();
-
- private final Class<?> utility;
-
- protected UtilityClassesUninstantiabilityHarness( Class<?> utility ) {
- this.utility = utility;
- }
-
- @Test
- public final void attemptToInstantiate() throws Exception {
- Constructor<?> constructor = utility.getDeclaredConstructor();
- constructor.setAccessible( true );
-
- thrown.expect( InvocationTargetException.class );
- thrown.expect( withTargetOfType( UnsupportedOperationException.class ) );
-
- constructor.newInstance();
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ValueConverterAdmitsSubclassesOfValueTypeTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ValueConverterAdmitsSubclassesOfValueTypeTest.java
deleted file mode 100644
index a7e726e..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ValueConverterAdmitsSubclassesOfValueTypeTest.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import org.junit.Test;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ValueConverterAdmitsSubclassesOfValueTypeTest {
- @Test
- public void subclassOfValueType() {
- ValueConverter<List<String>> converter = new ValueConverter<List<String>>() {
- public List<String> convert( String value ) {
- return Collections.singletonList( value );
- }
-
- public Class<? extends List<String>> valueType() {
- return ListOfStrings.class;
- }
-
- public String valuePattern() {
- return null;
- }
- };
-
- assertEquals( Arrays.asList( "foo" ), converter.convert( "foo" ) );
- }
-
- static class ListOfStrings extends ArrayList<String> {
- private static final long serialVersionUID = 1L;
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/ValueOfHaver.java b/third_party/java/jopt-simple/src/test/java/joptsimple/ValueOfHaver.java
deleted file mode 100644
index a309260..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/ValueOfHaver.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ValueOfHaver {
- private ValueOfHaver() {
- // no-op
- }
-
- public static ValueOfHaver valueOf( String s ) {
- return null;
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/WAsAbbreviationForLongOptionTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/WAsAbbreviationForLongOptionTest.java
deleted file mode 100644
index 119c14b..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/WAsAbbreviationForLongOptionTest.java
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static joptsimple.ExceptionMatchers.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class WAsAbbreviationForLongOptionTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "Wally" ).withRequiredArg();
- }
-
- @Test
- public void abbreviation() {
- OptionSet options = parser.parse( "--W", "silent" );
-
- assertOptionDetected( options, "Wally" );
- assertOptionNotDetected( options, "W" );
- assertEquals( singletonList( "silent" ), options.valuesOf( "Wally" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void recognizeLongOptionsTrumpsLongOptionAbbreviation() {
- parser.recognizeAlternativeLongOptions( true );
-
- thrown.expect( UnrecognizedOptionException.class );
- thrown.expect( withOption( "silent" ) );
-
- parser.parse( "--W", "silent" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/WAsShortOptionTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/WAsShortOptionTest.java
deleted file mode 100644
index 8cfb523..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/WAsShortOptionTest.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static joptsimple.ExceptionMatchers.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class WAsShortOptionTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "W" );
- }
-
- @Test
- public void wIsLegal() {
- OptionSet options = parser.parse( "-W", "silent" );
-
- assertOptionDetected( options, "W" );
- assertEquals( emptyList(), options.valuesOf( "W" ) );
- assertEquals( singletonList( "silent" ), options.nonOptionArguments() );
- }
-
- @Test
- public void recognizeLongOptionsTrumpsShortOptionW() {
- parser.recognizeAlternativeLongOptions( true );
-
- thrown.expect( UnrecognizedOptionException.class );
- thrown.expect( withOption( "silent" ) );
-
- parser.parse( "-W", "silent" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/WExtensionNoArgumentTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/WExtensionNoArgumentTest.java
deleted file mode 100644
index cb8a5e9..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/WExtensionNoArgumentTest.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static joptsimple.ExceptionMatchers.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class WExtensionNoArgumentTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.accepts( "silent" );
- parser.recognizeAlternativeLongOptions( true );
- }
-
- @Test
- public void turnOffWExtension() {
- parser.recognizeAlternativeLongOptions( false );
-
- thrown.expect( UnrecognizedOptionException.class );
- thrown.expect( withOption( "W" ) );
-
- parser.parse( "-W", "silent" );
- }
-
- @Test
- public void wExtensionWithLongOptionWithoutAnArgument() {
- OptionSet options = parser.parse( "-W", "silent" );
-
- assertOptionNotDetected( options, "W" );
- assertOptionDetected( options, "silent" );
- assertEquals( emptyList(), options.valuesOf( "silent" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/WExtensionWithArgumentTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/WExtensionWithArgumentTest.java
deleted file mode 100644
index 76f247a..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/WExtensionWithArgumentTest.java
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple;
-
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static joptsimple.ExceptionMatchers.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class WExtensionWithArgumentTest extends AbstractOptionParserFixture {
- @Before
- public final void initializeParser() {
- parser.recognizeAlternativeLongOptions( true );
- parser.accepts( "silent" ).withOptionalArg();
- }
-
- @Test
- public void separateArgument() {
- OptionSet options = parser.parse( "-W", "silent", "4" );
-
- assertOptionNotDetected( options, "W" );
- assertOptionDetected( options, "silent" );
- assertEquals( singletonList( "4" ), options.valuesOf( "silent" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void togetherArgument() {
- OptionSet options = parser.parse( "-W", "silent=6" );
-
- assertOptionNotDetected( options, "W" );
- assertOptionDetected( options, "silent" );
- assertEquals( singletonList( "6" ), options.valuesOf( "silent" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void abbreviationWithTogetherArgument() {
- OptionSet options = parser.parse( "-W", "s=6" );
-
- assertOptionNotDetected( options, "W" );
- assertOptionDetected( options, "silent" );
- assertOptionNotDetected( options, "s" );
- assertEquals( singletonList( "6" ), options.valuesOf( "silent" ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void illegalLongOption() {
- thrown.expect( UnrecognizedOptionException.class );
- thrown.expect( withOption( "foo" ) );
-
- parser.parse( "-W", "foo=bar" );
- }
-
- @Test
- public void noMoreArguments() {
- thrown.expect( OptionMissingRequiredArgumentException.class );
- thrown.expect( withOption( "W" ) );
-
- parser.parse( "-W" );
- }
-
- @Test
- public void typedTogetherArg() {
- OptionSpec<Integer> level = parser.accepts( "level" ).withRequiredArg().ofType( Integer.class );
-
- OptionSet options = parser.parse( "-W", "level=4" );
-
- assertOptionNotDetected( options, "W" );
- assertOptionDetected( options, "level" );
- assertEquals( singletonList( 4 ), options.valuesOf( level ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-
- @Test
- public void typedSeparateArg() {
- OptionSpec<Integer> floor = parser.accepts( "floor" ).withRequiredArg().ofType( Integer.class );
-
- OptionSet options = parser.parse( "-W", "floor", "5" );
-
- assertOptionNotDetected( options, "W" );
- assertOptionDetected( options, "floor" );
- assertEquals( singletonList( 5 ), options.valuesOf( floor ) );
- assertEquals( emptyList(), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/AlternativeLongOptionsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/AlternativeLongOptionsTest.java
deleted file mode 100644
index 3657a40..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/AlternativeLongOptionsTest.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package joptsimple.examples;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class AlternativeLongOptionsTest {
- @Test
- public void handlesAlternativeLongOptions() {
- OptionParser parser = new OptionParser( "W;" );
- parser.recognizeAlternativeLongOptions( true ); // same effect as above
- parser.accepts( "level" ).withRequiredArg();
-
- OptionSet options = parser.parse( "-W", "level=5" );
-
- assertTrue( options.has( "level" ) );
- assertTrue( options.hasArgument( "level" ) );
- assertEquals( "5", options.valueOf( "level" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/DefaultValuesForOptionArgumentsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/DefaultValuesForOptionArgumentsTest.java
deleted file mode 100644
index cd11f07..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/DefaultValuesForOptionArgumentsTest.java
+++ /dev/null
@@ -1,58 +0,0 @@
-package joptsimple.examples;
-
-import java.io.File;
-
-import joptsimple.OptionException;
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import joptsimple.OptionSpec;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-
-import static joptsimple.examples.Level.*;
-import static org.junit.Assert.*;
-import static org.junit.rules.ExpectedException.*;
-
-public class DefaultValuesForOptionArgumentsTest {
- @Rule public final ExpectedException thrown = none();
-
- @Test
- public void allowsSpecificationOfDefaultValues() throws Exception {
- File tempDir = new File( System.getProperty( "java.io.tmpdir" ) );
- File tempFile = File.createTempFile( "aFile", ".txt" );
- OptionParser parser = new OptionParser();
- OptionSpec<File> infile =
- parser.accepts( "infile" ).withRequiredArg().ofType( File.class ).defaultsTo( tempFile );
- OptionSpec<File> outdir =
- parser.accepts( "outdir" ).withRequiredArg().ofType( File.class ).defaultsTo( tempDir );
- OptionSpec<Integer> bufferSize =
- parser.accepts( "buffer-size" ).withOptionalArg().ofType( Integer.class ).defaultsTo( 4096 );
- OptionSpec<Level> level =
- parser.accepts( "level" ).withOptionalArg().ofType( Level.class ).defaultsTo( INFO );
- OptionSpec<Integer> count =
- parser.accepts( "count" ).withOptionalArg().ofType( Integer.class ).defaultsTo( 10 );
-
- OptionSet options = parser.parse( "--level", "WARNING", "--count", "--infile", "/etc/passwd" );
-
- assertEquals( new File( "/etc/passwd" ), infile.value( options ) );
- assertTrue( options.has( infile ) );
- assertTrue( options.hasArgument( infile ) );
- assertEquals( tempDir, outdir.value( options ) );
- assertFalse( options.has( outdir ) );
- assertFalse( options.hasArgument( outdir ) );
- assertEquals( Integer.valueOf( 4096 ), bufferSize.value( options ) );
- assertFalse( options.has( bufferSize ) );
- assertFalse( options.hasArgument( bufferSize ) );
- assertEquals( WARNING, level.value( options ) );
- assertTrue( options.has( level ) );
- assertTrue( options.hasArgument( level ) );
- assertEquals( Integer.valueOf( 10 ), count.value( options ) );
- assertTrue( options.has( count ) );
- assertFalse( options.hasArgument( count ) );
-
- thrown.expect( OptionException.class );
-
- parser.parse( "--outdir" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ExceptionExample.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ExceptionExample.java
deleted file mode 100644
index fb4a9e7..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ExceptionExample.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package joptsimple.examples;
-
-import joptsimple.OptionParser;
-
-public class ExceptionExample {
- public static void main( String[] args ) {
- OptionParser parser = new OptionParser();
-
- parser.parse( "-x" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ExportOptionsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ExportOptionsTest.java
deleted file mode 100644
index 730e318..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ExportOptionsTest.java
+++ /dev/null
@@ -1,61 +0,0 @@
-package joptsimple.examples;
-
-import com.google.common.base.Joiner;
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import joptsimple.OptionSpec;
-import org.junit.Test;
-
-import java.io.File;
-import java.util.List;
-import java.util.Map.Entry;
-import java.util.Properties;
-
-import static org.junit.Assert.assertEquals;
-
-public class ExportOptionsTest {
- private static Properties asProperties( OptionSet options, String prefix ) {
- Properties properties = new Properties();
- for ( Entry<OptionSpec<?>, List<?>> entry : options.asMap().entrySet() ) {
- OptionSpec<?> spec = entry.getKey();
- properties.setProperty(
- asPropertyKey( prefix, spec ),
- asPropertyValue( entry.getValue(), options.has( spec ) ) );
- }
- return properties;
- }
-
- private static String asPropertyKey( String prefix, OptionSpec<?> spec ) {
- List<String> flags = spec.options();
- for ( String flag : flags )
- if ( 1 < flag.length() )
- return null == prefix ? flag : ( prefix + '.' + flag );
- throw new IllegalArgumentException( "No usable non-short flag: " + flags );
- }
-
- private static String asPropertyValue( List<?> values, boolean present ) {
- // Simple flags have no values; treat presence/absence as true/false
- return values.isEmpty() ? String.valueOf( present ) : Joiner.on( "," ).join( values );
- }
-
- @Test
- public void allowsExportOfOptions() {
- Properties expected = new Properties();
- expected.setProperty( "rice.count", "3" );
- // Cannot check path as string directly - Windows flips the leading slash
- expected.setProperty( "rice.output-dir", new File( "/tmp" ).toString() );
- expected.setProperty( "rice.fun", "false" );
- expected.setProperty( "rice.verbose", "true" );
-
- OptionParser parser = new OptionParser();
- OptionSpec<Integer> count = parser.accepts( "count" ).withRequiredArg().ofType( Integer.class );
- OptionSpec<File> outputDir = parser.accepts( "output-dir" ).withOptionalArg().ofType( File.class );
- OptionSpec<Void> verbose = parser.accepts( "verbose" );
- OptionSpec<Void> fun = parser.accepts( "fun" );
- OptionSpec<File> files = parser.nonOptions().ofType( File.class );
-
- OptionSet options = parser.parse( "--count", "3", "--output-dir", "/tmp", "--verbose", "a.txt", "b.txt" );
-
- assertEquals( expected, asProperties( options, "rice" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/HelpFormatterExample.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/HelpFormatterExample.java
deleted file mode 100644
index 0262d2a..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/HelpFormatterExample.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package joptsimple.examples;
-
-import java.io.File;
-import java.util.HashSet;
-import java.util.Map;
-
-import static java.io.File.*;
-import static java.util.Arrays.*;
-
-import joptsimple.HelpFormatter;
-import joptsimple.OptionDescriptor;
-import joptsimple.OptionParser;
-
-import static joptsimple.util.DateConverter.*;
-
-public class HelpFormatterExample {
- static class MyFormatter implements HelpFormatter {
- public String format( Map<String, ? extends OptionDescriptor> options ) {
- StringBuilder buffer = new StringBuilder();
- for ( OptionDescriptor each : new HashSet<>( options.values() ) ) {
- buffer.append( lineFor( each ) );
- }
- return buffer.toString();
- }
-
- private String lineFor( OptionDescriptor descriptor ) {
- if ( descriptor.representsNonOptions() ) {
- return descriptor.argumentDescription() + '(' + descriptor.argumentTypeIndicator() + "): "
- + descriptor.description() + System.getProperty( "line.separator" );
- }
-
- StringBuilder line = new StringBuilder( descriptor.options().toString() );
- line.append( ": description = " ).append( descriptor.description() );
- line.append( ", required = " ).append( descriptor.isRequired() );
- line.append( ", accepts arguments = " ).append( descriptor.acceptsArguments() );
- line.append( ", requires argument = " ).append( descriptor.requiresArgument() );
- line.append( ", argument description = " ).append( descriptor.argumentDescription() );
- line.append( ", argument type indicator = " ).append( descriptor.argumentTypeIndicator() );
- line.append( ", default values = " ).append( descriptor.defaultValues() );
- line.append( System.getProperty( "line.separator" ) );
- return line.toString();
- }
- }
-
- public static void main( String[] args ) throws Exception {
- OptionParser parser = new OptionParser() {
- {
- accepts( "c" ).withRequiredArg().ofType( Integer.class )
- .describedAs( "count" ).defaultsTo( 1 );
- accepts( "q" ).withOptionalArg().ofType( Double.class )
- .describedAs( "quantity" );
- accepts( "d", "some date" ).withRequiredArg().required()
- .withValuesConvertedBy( datePattern( "MM/dd/yy" ) );
- acceptsAll( asList( "v", "talkative", "chatty" ), "be more verbose" );
- accepts( "output-file" ).withOptionalArg().ofType( File.class )
- .describedAs( "file" );
- acceptsAll( asList( "h", "?" ), "show help" ).forHelp();
- acceptsAll( asList( "cp", "classpath" ) ).withRequiredArg()
- .describedAs( "path1" + pathSeparatorChar + "path2:..." )
- .ofType( File.class )
- .withValuesSeparatedBy( pathSeparatorChar );
- nonOptions( "files to chew on" ).ofType( File.class ).describedAs( "input files" );
- }
- };
-
- parser.formatHelpWith( new MyFormatter() );
- parser.printHelpOn( System.out );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/HelpScreenExample.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/HelpScreenExample.java
deleted file mode 100644
index 44f024b..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/HelpScreenExample.java
+++ /dev/null
@@ -1,35 +0,0 @@
-package joptsimple.examples;
-
-import java.io.File;
-
-import static java.io.File.*;
-import static java.util.Arrays.*;
-
-import joptsimple.OptionParser;
-
-import static joptsimple.util.DateConverter.*;
-
-public class HelpScreenExample {
- public static void main( String[] args ) throws Exception {
- OptionParser parser = new OptionParser() {
- {
- accepts( "c" ).withRequiredArg().ofType( Integer.class )
- .describedAs( "count" ).defaultsTo( 1 );
- accepts( "q" ).withOptionalArg().ofType( Double.class )
- .describedAs( "quantity" );
- accepts( "d", "some date" ).withRequiredArg().required()
- .withValuesConvertedBy( datePattern( "MM/dd/yy" ) );
- acceptsAll( asList( "v", "talkative", "chatty" ), "be more verbose" );
- accepts( "output-file" ).withOptionalArg().ofType( File.class )
- .describedAs( "file" );
- acceptsAll( asList( "h", "?" ), "show help" ).forHelp();
- acceptsAll( asList( "cp", "classpath" ) ).withRequiredArg()
- .describedAs( "path1" + pathSeparatorChar + "path2:..." )
- .ofType( File.class )
- .withValuesSeparatedBy( pathSeparatorChar );
- }
- };
-
- parser.printHelpOn( System.out );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/Level.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/Level.java
deleted file mode 100644
index b3d95d4..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/Level.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package joptsimple.examples;
-
-public enum Level {
- WARNING,
- INFO,
- DEBUG
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/LongOptionsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/LongOptionsTest.java
deleted file mode 100644
index 30fac0c..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/LongOptionsTest.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package joptsimple.examples;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class LongOptionsTest {
- @Test
- public void acceptsLongOptions() {
- OptionParser parser = new OptionParser();
- parser.accepts( "flag" );
- parser.accepts( "verbose" );
-
- OptionSet options = parser.parse( "--flag" );
-
- assertTrue( options.has( "flag" ) );
- assertFalse( options.has( "verbose" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/LongOptionsWithArgumentPositioningTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/LongOptionsWithArgumentPositioningTest.java
deleted file mode 100644
index 1cf018b..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/LongOptionsWithArgumentPositioningTest.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package joptsimple.examples;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class LongOptionsWithArgumentPositioningTest {
- @Test
- public void allowsDifferentFormsOfPairingArgumentWithOption() {
- OptionParser parser = new OptionParser();
- parser.accepts( "count" ).withRequiredArg();
- parser.accepts( "level" ).withOptionalArg();
-
- OptionSet options = parser.parse( "--count", "4", "--level=3" );
-
- assertTrue( options.has( "count" ) );
- assertTrue( options.hasArgument( "count" ) );
- assertEquals( "4", options.valueOf( "count" ) );
-
- assertTrue( options.has( "level" ) );
- assertTrue( options.hasArgument( "level" ) );
- assertEquals( "3", options.valueOf( "level" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/LongOptionsWithArgumentsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/LongOptionsWithArgumentsTest.java
deleted file mode 100644
index 38ef67c..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/LongOptionsWithArgumentsTest.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package joptsimple.examples;
-
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class LongOptionsWithArgumentsTest {
- @Test
- public void supportsLongOptionsWithArgumentsAndAbbreviations() {
- OptionParser parser = new OptionParser();
- parser.accepts( "flag" );
- parser.accepts( "count" ).withRequiredArg();
- parser.accepts( "level" ).withOptionalArg();
-
- OptionSet options = parser.parse( "-flag", "--co", "3", "--lev" );
-
- assertTrue( options.has( "flag" ) );
-
- assertTrue( options.has( "count" ) );
- assertTrue( options.hasArgument( "count" ) );
- assertEquals( "3", options.valueOf( "count" ) );
- assertEquals( asList( "3" ), options.valuesOf( "count" ) );
-
- assertTrue( options.has( "level" ) );
- assertFalse( options.hasArgument( "level" ) );
- assertNull( options.valueOf( "level" ) );
- assertEquals( emptyList(), options.valuesOf( "level" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/MultipleDelimitedArgumentsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/MultipleDelimitedArgumentsTest.java
deleted file mode 100644
index 47eefd0..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/MultipleDelimitedArgumentsTest.java
+++ /dev/null
@@ -1,29 +0,0 @@
-package joptsimple.examples;
-
-import java.io.File;
-
-import static java.io.File.*;
-import static java.util.Arrays.*;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import joptsimple.OptionSpec;
-import org.junit.Test;
-
-import static joptsimple.examples.Strings.*;
-import static org.junit.Assert.*;
-
-public class MultipleDelimitedArgumentsTest {
- @Test
- public void supportsMultipleDelimitedArguments() {
- OptionParser parser = new OptionParser();
- OptionSpec<File> path = parser.accepts( "path" ).withRequiredArg().ofType( File.class )
- .withValuesSeparatedBy( pathSeparatorChar );
-
- OptionSet options = parser.parse( "--path", join( pathSeparatorChar, "/tmp", "/var", "/opt" ) );
-
- assertTrue( options.has( path ) );
- assertTrue( options.hasArgument( path ) );
- assertEquals( asList( new File( "/tmp" ), new File( "/var" ), new File( "/opt" ) ), options.valuesOf( path ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/OptionArgumentConverterTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/OptionArgumentConverterTest.java
deleted file mode 100644
index 5841794..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/OptionArgumentConverterTest.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2014 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.examples;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.joda.time.LocalDate;
-import org.junit.Test;
-
-import static joptsimple.util.DateConverter.*;
-import static joptsimple.util.RegexMatcher.*;
-import static org.junit.Assert.*;
-
-public class OptionArgumentConverterTest {
- @Test
- public void usesConvertersOnOptionArgumentsWhenTold() {
- OptionParser parser = new OptionParser();
- parser.accepts( "birthdate" ).withRequiredArg().withValuesConvertedBy( datePattern( "MM/dd/yy" ) );
- parser.accepts( "ssn" ).withRequiredArg().withValuesConvertedBy( regex( "\\d{3}-\\d{2}-\\d{4}" ));
-
- OptionSet options = parser.parse( "--birthdate", "02/24/05", "--ssn", "123-45-6789" );
-
- assertEquals( new LocalDate( 2005, 2, 24 ).toDate(), options.valueOf( "birthdate" ) );
- assertEquals( "123-45-6789", options.valueOf( "ssn" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/OptionArgumentValueTypeTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/OptionArgumentValueTypeTest.java
deleted file mode 100644
index 2f8e51c..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/OptionArgumentValueTypeTest.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package joptsimple.examples;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class OptionArgumentValueTypeTest {
- @Test
- public void convertsArgumentsToJavaValueTypes() {
- OptionParser parser = new OptionParser();
- parser.accepts( "flag" );
- parser.accepts( "count" ).withRequiredArg().ofType( Integer.class );
- parser.accepts( "level" ).withOptionalArg().ofType( Level.class );
-
- OptionSet options = parser.parse( "--count", "3", "--level", "DEBUG" );
-
- assertTrue( options.has( "count" ) );
- assertTrue( options.hasArgument( "count" ) );
- assertEquals( 3, options.valueOf( "count" ) );
-
- assertTrue( options.has( "level" ) );
- assertTrue( options.hasArgument( "level" ) );
- assertEquals( Level.DEBUG, options.valueOf( "level" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/OptionSynonymTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/OptionSynonymTest.java
deleted file mode 100644
index 336c4d0..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/OptionSynonymTest.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package joptsimple.examples;
-
-import java.util.List;
-
-import static java.util.Arrays.*;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class OptionSynonymTest {
- @Test
- public void supportsOptionSynonyms() {
- OptionParser parser = new OptionParser();
- List<String> synonyms = asList( "message", "blurb", "greeting" );
- parser.acceptsAll( synonyms ).withRequiredArg();
- String expectedMessage = "Hello";
-
- OptionSet options = parser.parse( "--message", expectedMessage );
-
- for ( String each : synonyms ) {
- assertTrue( each, options.has( each ) );
- assertTrue( each, options.hasArgument( each ) );
- assertEquals( each, expectedMessage, options.valueOf( each ) );
- assertEquals( each, asList( expectedMessage ), options.valuesOf( each ) );
- }
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/PosixlyCorrectTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/PosixlyCorrectTest.java
deleted file mode 100644
index 7acb957..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/PosixlyCorrectTest.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package joptsimple.examples;
-
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class PosixlyCorrectTest {
- @Test
- public void supportsPosixlyCorrectBehavior() {
- OptionParser parser = new OptionParser( "i:j::k" );
- String[] arguments = { "-ibar", "-i", "junk", "xyz", "-jixnay", "foo", "-k", "blah", "--", "bah" };
-
- OptionSet options = parser.parse( arguments );
-
- assertTrue( options.has( "i" ) );
- assertTrue( options.has( "j" ) );
- assertTrue( options.has( "k" ) );
- assertEquals( asList( "bar", "junk" ), options.valuesOf( "i" ) );
- assertEquals( asList( "ixnay" ), options.valuesOf( "j" ) );
- assertEquals( asList( "xyz", "foo", "blah", "bah" ), options.nonOptionArguments() );
-
- parser.posixlyCorrect( true );
- options = parser.parse( arguments );
-
- assertTrue( options.has( "i" ) );
- assertFalse( options.has( "j" ) );
- assertFalse( options.has( "k" ) );
- assertEquals( asList( "bar", "junk" ), options.valuesOf( "i" ) );
- assertEquals( emptyList(), options.valuesOf( "j" ) );
- assertEquals( asList( "xyz", "-jixnay", "foo", "-k", "blah", "--", "bah" ), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/RequiredIfExample.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/RequiredIfExample.java
deleted file mode 100644
index c062fff..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/RequiredIfExample.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package joptsimple.examples;
-
-import joptsimple.OptionParser;
-
-public class RequiredIfExample {
- public static void main( String[] args ) {
- OptionParser parser = new OptionParser();
- parser.accepts( "ftp" );
- parser.accepts( "username" ).requiredIf( "ftp" ).withRequiredArg();
- parser.accepts( "password" ).requiredIf( "ftp" ).withRequiredArg();
-
- parser.parse( "--ftp" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/RequiredOptionsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/RequiredOptionsTest.java
deleted file mode 100644
index 5a40ea2..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/RequiredOptionsTest.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package joptsimple.examples;
-
-import joptsimple.OptionException;
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class RequiredOptionsTest {
- @Test( expected = OptionException.class )
- public void allowsSpecificationOfRequiredOptions() {
- OptionParser parser = new OptionParser() {
- {
- accepts( "userid" ).withRequiredArg().required();
- accepts( "password" ).withRequiredArg().required();
- }
- };
-
- parser.parse( "--userid", "bob" );
- }
-
- @Test
- public void aHelpOptionMeansRequiredOptionsNeedNotBePresent() {
- OptionParser parser = new OptionParser() {
- {
- accepts( "userid" ).withRequiredArg().required();
- accepts( "password" ).withRequiredArg().required();
- accepts( "help" ).forHelp();
- }
- };
-
- OptionSet options = parser.parse( "--help" );
- assertTrue( options.has( "help" ) );
- }
-
- @Test( expected = OptionException.class )
- public void missingHelpOptionMeansRequiredOptionsMustBePresent() {
- OptionParser parser = new OptionParser() {
- {
- accepts( "userid" ).withRequiredArg().required();
- accepts( "password" ).withRequiredArg().required();
- accepts( "help" ).forHelp();
- }
- };
-
- parser.parse( "" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/RequiredUnlessExample.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/RequiredUnlessExample.java
deleted file mode 100644
index f55f6ca..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/RequiredUnlessExample.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package joptsimple.examples;
-
-import joptsimple.OptionParser;
-
-public class RequiredUnlessExample {
- public static void main( String[] args ) {
- OptionParser parser = new OptionParser();
- parser.accepts( "anonymous" );
- parser.accepts( "username" ).requiredUnless( "anonymous" ).withRequiredArg();
- parser.accepts( "password" ).requiredUnless( "anonymous" ).withRequiredArg();
-
- parser.parse( "--anonymous" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsClusteringTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsClusteringTest.java
deleted file mode 100644
index 9143e45..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsClusteringTest.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package joptsimple.examples;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class ShortOptionsClusteringTest {
- @Test
- public void allowsClusteringShortOptions() {
- OptionParser parser = new OptionParser( "aBcd" );
-
- OptionSet options = parser.parse( "-cdBa" );
-
- assertTrue( options.has( "a" ) );
- assertTrue( options.has( "B" ) );
- assertTrue( options.has( "c" ) );
- assertTrue( options.has( "d" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsClusteringWithArgumentTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsClusteringWithArgumentTest.java
deleted file mode 100644
index 695f6ce..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsClusteringWithArgumentTest.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package joptsimple.examples;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class ShortOptionsClusteringWithArgumentTest {
- @Test
- public void allowsClusteringShortOptionsThatAcceptArguments() {
- OptionParser parser = new OptionParser();
- parser.accepts( "a" );
- parser.accepts( "B" );
- parser.accepts( "c" ).withRequiredArg();
-
- OptionSet options = parser.parse( "-aBcfoo" );
-
- assertTrue( options.has( "a" ) );
- assertTrue( options.has( "B" ) );
- assertTrue( options.has( "c" ) );
- assertEquals( "foo", options.valueOf( "c" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsTest.java
deleted file mode 100644
index 4e3487c..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsTest.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package joptsimple.examples;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class ShortOptionsTest {
- @Test
- public void supportsShortOptions() {
- OptionParser parser = new OptionParser( "aB?*." );
-
- OptionSet options = parser.parse( "-a", "-B", "-?" );
-
- assertTrue( options.has( "a" ) );
- assertTrue( options.has( "B" ) );
- assertTrue( options.has( "?" ) );
- assertFalse( options.has( "." ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsWithArgumentPositioningTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsWithArgumentPositioningTest.java
deleted file mode 100644
index 720253e..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsWithArgumentPositioningTest.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package joptsimple.examples;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class ShortOptionsWithArgumentPositioningTest {
- @Test
- public void allowsDifferentFormsOfPairingArgumentWithOption() {
- OptionParser parser = new OptionParser( "a:b:c::" );
-
- OptionSet options = parser.parse( "-a", "foo", "-bbar", "-c=baz" );
-
- assertTrue( options.has( "a" ) );
- assertTrue( options.hasArgument( "a" ) );
- assertEquals( "foo", options.valueOf( "a" ) );
-
- assertTrue( options.has( "b" ) );
- assertTrue( options.hasArgument( "b" ) );
- assertEquals( "bar", options.valueOf( "b" ) );
-
- assertTrue( options.has( "c" ) );
- assertTrue( options.hasArgument( "c" ) );
- assertEquals( "baz", options.valueOf( "c" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsWithArgumentsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsWithArgumentsTest.java
deleted file mode 100644
index 3ee7911..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsWithArgumentsTest.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package joptsimple.examples;
-
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class ShortOptionsWithArgumentsTest {
- @Test
- public void allowsOptionsToAcceptArguments() {
- OptionParser parser = new OptionParser( "fc:q::" );
-
- OptionSet options = parser.parse( "-f", "-c", "foo", "-q" );
-
- assertTrue( options.has( "f" ) );
-
- assertTrue( options.has( "c" ) );
- assertTrue( options.hasArgument( "c" ) );
- assertEquals( "foo", options.valueOf( "c" ) );
- assertEquals( asList( "foo" ), options.valuesOf( "c" ) );
-
- assertTrue( options.has( "q" ) );
- assertFalse( options.hasArgument( "q" ) );
- assertNull( options.valueOf( "q" ) );
- assertEquals( emptyList(), options.valuesOf( "q" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsWithMultipleArgumentsForSingleOptionTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsWithMultipleArgumentsForSingleOptionTest.java
deleted file mode 100644
index 8f113f8..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ShortOptionsWithMultipleArgumentsForSingleOptionTest.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package joptsimple.examples;
-
-import static java.util.Arrays.*;
-
-import joptsimple.OptionException;
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-
-import static org.junit.Assert.*;
-import static org.junit.rules.ExpectedException.*;
-
-public class ShortOptionsWithMultipleArgumentsForSingleOptionTest {
- @Rule public final ExpectedException thrown = none();
-
- @Test
- public void allowsMultipleValuesForAnOption() {
- OptionParser parser = new OptionParser( "a:" );
-
- OptionSet options = parser.parse( "-a", "foo", "-abar", "-a=baz" );
-
- assertTrue( options.has( "a" ) );
- assertTrue( options.hasArgument( "a" ) );
- assertEquals( asList( "foo", "bar", "baz" ), options.valuesOf( "a" ) );
-
- thrown.expect( OptionException.class );
- options.valueOf( "a" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/SignallingEndOfOptionsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/SignallingEndOfOptionsTest.java
deleted file mode 100644
index 9fd1fae..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/SignallingEndOfOptionsTest.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package joptsimple.examples;
-
-import static java.util.Arrays.*;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class SignallingEndOfOptionsTest {
- @Test
- public void doubleHyphenSignalsEndOfOptions() {
- OptionParser parser = new OptionParser( "ab:c::de:f::" );
-
- OptionSet options = parser.parse( "-a", "-b=foo", "-c=bar", "--", "-d", "-e", "baz", "-f", "biz" );
-
- assertTrue( options.has( "a" ) );
- assertFalse( options.hasArgument( "a" ) );
- assertTrue( options.has( "b" ) );
- assertTrue( options.hasArgument( "b" ) );
- assertEquals( asList( "foo" ), options.valuesOf( "b" ) );
- assertTrue( options.has( "c" ) );
- assertTrue( options.hasArgument( "c" ) );
- assertEquals( asList( "bar" ), options.valuesOf( "c" ) );
- assertFalse( options.has( "d" ) );
- assertFalse( options.has( "e" ) );
- assertFalse( options.has( "f" ) );
- assertEquals( asList( "-d", "-e", "baz", "-f", "biz" ), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/SpecialOptionalArgumentHandlingTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/SpecialOptionalArgumentHandlingTest.java
deleted file mode 100644
index 4f05559..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/SpecialOptionalArgumentHandlingTest.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package joptsimple.examples;
-
-import static java.util.Arrays.*;
-import static java.util.Collections.*;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class SpecialOptionalArgumentHandlingTest {
- @Test
- public void handlesNegativeNumberOptionalArguments() {
- OptionParser parser = new OptionParser();
- parser.accepts( "a" ).withOptionalArg().ofType( Integer.class );
- parser.accepts( "2" );
-
- OptionSet options = parser.parse( "-a", "-2" );
-
- assertTrue( options.has( "a" ) );
- assertFalse( options.has( "2" ) );
- assertEquals( asList( -2 ), options.valuesOf( "a" ) );
-
- options = parser.parse( "-2", "-a" );
-
- assertTrue( options.has( "a" ) );
- assertTrue( options.has( "2" ) );
- assertEquals( emptyList(), options.valuesOf( "a" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/Strings.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/Strings.java
deleted file mode 100644
index 4323506..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/Strings.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package joptsimple.examples;
-
-import java.util.Iterator;
-
-import static java.util.Arrays.*;
-
-public class Strings {
- public static String join( char delimiter, String... pieces ) {
- StringBuilder builder = new StringBuilder();
-
- for ( Iterator<String> iter = asList( pieces ).iterator(); iter.hasNext(); ) {
- builder.append( iter.next() );
- if ( iter.hasNext() )
- builder.append( delimiter );
- }
-
- return builder.toString();
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/TypesafeOptionArgumentRetrievalTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/TypesafeOptionArgumentRetrievalTest.java
deleted file mode 100644
index 93cd0a5..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/TypesafeOptionArgumentRetrievalTest.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package joptsimple.examples;
-
-import java.io.File;
-
-import static java.util.Arrays.*;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import joptsimple.OptionSpec;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class TypesafeOptionArgumentRetrievalTest {
- @Test
- public void allowsTypesafeRetrievalOfOptionArguments() {
- OptionParser parser = new OptionParser();
- OptionSpec<Integer> count = parser.accepts( "count" ).withRequiredArg().ofType( Integer.class );
- OptionSpec<File> outputDir = parser.accepts( "output-dir" ).withOptionalArg().ofType( File.class );
- OptionSpec<Void> verbose = parser.accepts( "verbose" );
- OptionSpec<File> files = parser.nonOptions().ofType( File.class );
-
- OptionSet options = parser.parse( "--count", "3", "--output-dir", "/tmp", "--verbose", "a.txt", "b.txt" );
-
- assertTrue( options.has( verbose ) );
-
- assertTrue( options.has( count ) );
- assertTrue( options.hasArgument( count ) );
- Integer expectedCount = 3;
- assertEquals( expectedCount, options.valueOf( count ) );
- assertEquals( expectedCount, count.value( options ) );
- assertEquals( asList( expectedCount ), options.valuesOf( count ) );
- assertEquals( asList( expectedCount ), count.values( options ) );
- assertEquals( asList( new File( "a.txt" ), new File( "b.txt" ) ), options.valuesOf( files ) );
-
- assertTrue( options.has( outputDir ) );
- assertTrue( options.hasArgument( outputDir ) );
- File expectedFile = new File( "/tmp" );
- assertEquals( expectedFile, options.valueOf( outputDir ) );
- assertEquals( expectedFile, outputDir.value( options ) );
- assertEquals( asList( expectedFile ), options.valuesOf( outputDir ) );
- assertEquals( asList( expectedFile ), outputDir.values( options ) );
- assertEquals( asList( new File( "a.txt" ), new File( "b.txt" ) ), files.values( options ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/UnrecognizedOptionsAllowedTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/UnrecognizedOptionsAllowedTest.java
deleted file mode 100644
index 6dc9972..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/UnrecognizedOptionsAllowedTest.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package joptsimple.examples;
-
-import joptsimple.OptionParser;
-import joptsimple.OptionSet;
-import org.junit.Test;
-
-import static java.util.Arrays.*;
-import static org.junit.Assert.*;
-
-public class UnrecognizedOptionsAllowedTest {
- @Test
- public void acceptsLongOptions() {
- OptionParser parser = new OptionParser();
- parser.allowsUnrecognizedOptions();
- parser.accepts( "f" );
-
- OptionSet options = parser.parse( "-f", "-d" );
-
- assertTrue( options.has( "f" ) );
- assertFalse( options.has( "d" ) );
- assertEquals( asList( "-d" ), options.nonOptionArguments() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ant/filters/HTMLEntitifier.java b/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ant/filters/HTMLEntitifier.java
deleted file mode 100644
index 0eabe4f..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/examples/ant/filters/HTMLEntitifier.java
+++ /dev/null
@@ -1,80 +0,0 @@
-package joptsimple.examples.ant.filters;
-
-import java.io.IOException;
-import java.io.Reader;
-import java.util.HashMap;
-import java.util.Map;
-
-import org.apache.tools.ant.filters.BaseFilterReader;
-import org.apache.tools.ant.filters.ChainableReader;
-
-/**
- * Ant filter class that transforms HTML special characters into their equivalent entities.
- *
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class HTMLEntitifier extends BaseFilterReader implements ChainableReader {
- private static final Map<Integer, String> ENTITIES = new HashMap<>();
-
- static {
- ENTITIES.put( (int) '<', "<" );
- ENTITIES.put( (int) '>', ">" );
- ENTITIES.put( (int) '"', """ );
- ENTITIES.put( (int) '&', "&" );
- }
-
- private String replacementData;
- private int replacementIndex = -1;
-
- /**
- * Creates "dummy" instances.
- */
- public HTMLEntitifier() {
- // empty on purpose
- }
-
- /**
- * @param source where the data to filter comes from
- */
- public HTMLEntitifier( Reader source ) {
- super( source );
- }
-
- /**
- * {@inheritDoc}
- */
- public Reader chain( Reader source ) {
- HTMLEntitifier newFilter = new HTMLEntitifier( source );
- newFilter.setInitialized( true );
-
- return newFilter;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public int read() throws IOException {
- if ( !getInitialized() )
- setInitialized( true );
-
- if ( replacementIndex > -1 ) {
- int ch = replacementData.charAt( replacementIndex++ );
-
- if ( replacementIndex >= replacementData.length() )
- replacementIndex = -1;
-
- return ch;
- }
-
- int nextChar = in.read();
-
- if ( ENTITIES.containsKey( nextChar ) ) {
- replacementData = ENTITIES.get( nextChar );
- replacementIndex = 1;
- return replacementData.charAt( 0 );
- }
-
- return nextChar;
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/AbbreviationMapTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/internal/AbbreviationMapTest.java
deleted file mode 100644
index abd4302..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/AbbreviationMapTest.java
+++ /dev/null
@@ -1,361 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.internal;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class AbbreviationMapTest {
- private AbbreviationMap<String> abbreviations;
-
- @Before
- public void setUp() {
- abbreviations = new AbbreviationMap<>();
- }
-
- @Test( expected = NullPointerException.class )
- public void nullValuesAreIllegal() {
- abbreviations.put( "cannotAddNullValue", null );
- }
-
- @Test( expected = NullPointerException.class )
- public void nullKeysAreIllegalToAdd() {
- abbreviations.put( null, "-1" );
- }
-
- @Test( expected = NullPointerException.class )
- public void nullKeysAreIllegalToCheckForContains() {
- abbreviations.contains( null );
- }
-
- @Test( expected = IllegalArgumentException.class )
- public void zeroLengthKeysAreIllegalToAdd() {
- abbreviations.put( "", "1" );
- }
-
- @Test( expected = NullPointerException.class )
- public void nullKeysAreIllegalToRemove() {
- abbreviations.remove( null );
- }
-
- @Test( expected = IllegalArgumentException.class )
- public void zeroLengthKeysAreIllegalToRemove() {
- abbreviations.remove( "" );
- }
-
- @Test
- public void empty() {
- assertFalse( abbreviations.contains( "boo" ) );
- assertNull( abbreviations.get( "boo" ) );
- }
-
- @Test
- public void addingOne() {
- abbreviations.put( "box", "2" );
-
- assertTrue( abbreviations.contains( "box" ) );
- assertEquals( "2", abbreviations.get( "box" ) );
- assertTrue( abbreviations.contains( "bo" ) );
- assertEquals( "2", abbreviations.get( "bo" ) );
- assertTrue( abbreviations.contains( "b" ) );
- assertEquals( "2", abbreviations.get( "b" ) );
- }
-
- @Test
- public void addingManyWithNoCommonPrefix() {
- abbreviations.put( "box", "1" );
- abbreviations.put( "cat", "2" );
- abbreviations.put( "dog", "3" );
-
- assertTrue( abbreviations.contains( "box" ) );
- assertEquals( "1", abbreviations.get( "box" ) );
- assertTrue( abbreviations.contains( "bo" ) );
- assertEquals( "1", abbreviations.get( "bo" ) );
- assertTrue( abbreviations.contains( "b" ) );
- assertEquals( "1", abbreviations.get( "b" ) );
- assertTrue( abbreviations.contains( "cat" ) );
- assertEquals( "2", abbreviations.get( "cat" ) );
- assertTrue( abbreviations.contains( "ca" ) );
- assertEquals( "2", abbreviations.get( "ca" ) );
- assertTrue( abbreviations.contains( "c" ) );
- assertEquals( "2", abbreviations.get( "c" ) );
- assertTrue( abbreviations.contains( "dog" ) );
- assertEquals( "3", abbreviations.get( "dog" ) );
- assertTrue( abbreviations.contains( "do" ) );
- assertEquals( "3", abbreviations.get( "do" ) );
- assertTrue( abbreviations.contains( "d" ) );
- assertEquals( "3", abbreviations.get( "d" ) );
- }
-
- @Test
- public void addingTwoWithCommonPrefix() {
- abbreviations.put( "box", "3" );
- abbreviations.put( "boy", "4" );
-
- assertTrue( abbreviations.contains( "box" ) );
- assertEquals( "3", abbreviations.get( "box" ) );
- assertTrue( abbreviations.contains( "boy" ) );
- assertEquals( "4", abbreviations.get( "boy" ) );
- assertFalse( abbreviations.contains( "bo" ) );
- assertNull( abbreviations.get( "bo" ) );
- assertFalse( abbreviations.contains( "b" ) );
- assertNull( abbreviations.get( "b" ) );
- }
-
- @Test
- public void addingThreeWithSuccessivelySmallerPrefixes() {
- abbreviations.put( "boy", "3" );
- abbreviations.put( "bo", "2" );
- abbreviations.put( "b", "1" );
-
- assertTrue( abbreviations.contains( "boy" ) );
- assertEquals( "3", abbreviations.get( "boy" ) );
- assertTrue( abbreviations.contains( "bo" ) );
- assertEquals( "2", abbreviations.get( "bo" ) );
- assertTrue( abbreviations.contains( "b" ) );
- assertEquals( "1", abbreviations.get( "b" ) );
- }
-
- @Test
- public void addingThreeWithSuccessivelyLargerPrefixes() {
- abbreviations.put( "b", "1" );
- abbreviations.put( "bo", "2" );
- abbreviations.put( "boy", "3" );
-
- assertTrue( abbreviations.contains( "boy" ) );
- assertEquals( "3", abbreviations.get( "boy" ) );
- assertTrue( abbreviations.contains( "bo" ) );
- assertEquals( "2", abbreviations.get( "bo" ) );
- assertTrue( abbreviations.contains( "b" ) );
- assertEquals( "1", abbreviations.get( "b" ) );
- }
-
- @Test
- public void addingThreeWithMixOfPrefixSize() {
- abbreviations.put( "boy", "3" );
- abbreviations.put( "b", "1" );
- abbreviations.put( "bo", "2" );
-
- assertTrue( abbreviations.contains( "boy" ) );
- assertEquals( "3", abbreviations.get( "boy" ) );
- assertTrue( abbreviations.contains( "bo" ) );
- assertEquals( "2", abbreviations.get( "bo" ) );
- assertTrue( abbreviations.contains( "b" ) );
- assertEquals( "1", abbreviations.get( "b" ) );
- }
-
- @Test
- public void addingOneThenReplacing() {
- abbreviations.put( "box", "2" );
-
- assertTrue( abbreviations.contains( "box" ) );
- assertEquals( "2", abbreviations.get( "box" ) );
- assertTrue( abbreviations.contains( "bo" ) );
- assertEquals( "2", abbreviations.get( "bo" ) );
- assertTrue( abbreviations.contains( "b" ) );
- assertEquals( "2", abbreviations.get( "b" ) );
-
- abbreviations.put( "box", "3" );
-
- assertTrue( abbreviations.contains( "box" ) );
- assertEquals( "3", abbreviations.get( "box" ) );
- assertTrue( abbreviations.contains( "bo" ) );
- assertEquals( "3", abbreviations.get( "bo" ) );
- assertTrue( abbreviations.contains( "b" ) );
- assertEquals( "3", abbreviations.get( "b" ) );
- }
-
- @Test
- public void removingNonExistentKeyHasNoEffect() {
- abbreviations.put( "box", "2" );
-
- abbreviations.remove( "cat" );
-
- assertTrue( abbreviations.contains( "box" ) );
- assertEquals( "2", abbreviations.get( "box" ) );
- assertTrue( abbreviations.contains( "bo" ) );
- assertEquals( "2", abbreviations.get( "bo" ) );
- assertTrue( abbreviations.contains( "b" ) );
- assertEquals( "2", abbreviations.get( "b" ) );
- }
-
- @Test
- public void removingSingleKey() {
- abbreviations.put( "box", "3" );
-
- abbreviations.remove( "box" );
-
- assertFalse( abbreviations.contains( "box" ) );
- assertNull( abbreviations.get( "box" ) );
- assertFalse( abbreviations.contains( "bo" ) );
- assertNull( abbreviations.get( "bo" ) );
- assertFalse( abbreviations.contains( "b" ) );
- assertNull( abbreviations.get( "b" ) );
- }
-
- @Test
- public void cannotRemoveByUniqueAbbreviation() {
- abbreviations.put( "box", "4" );
-
- abbreviations.remove( "bo" );
- abbreviations.remove( "b" );
-
- assertTrue( abbreviations.contains( "box" ) );
- assertEquals( "4", abbreviations.get( "box" ) );
- assertTrue( abbreviations.contains( "bo" ) );
- assertEquals( "4", abbreviations.get( "bo" ) );
- assertTrue( abbreviations.contains( "b" ) );
- assertEquals( "4", abbreviations.get( "b" ) );
- }
-
- @Test
- public void removeKeyWithCommonPrefix() {
- abbreviations.put( "box", "-1" );
- abbreviations.put( "boy", "-2" );
-
- abbreviations.remove( "box" );
-
- assertFalse( abbreviations.contains( "box" ) );
- assertNull( abbreviations.get( "box" ) );
- assertTrue( abbreviations.contains( "boy" ) );
- assertEquals( "-2", abbreviations.get( "boy" ) );
- assertTrue( abbreviations.contains( "bo" ) );
- assertEquals( "-2", abbreviations.get( "bo" ) );
- assertTrue( abbreviations.contains( "b" ) );
- assertEquals( "-2", abbreviations.get( "b" ) );
- }
-
- @Test
- public void addKeysWithCommonPrefixThenRemoveNonExistentKeyWithCommonPrefix() {
- abbreviations.put( "box", "-1" );
- abbreviations.put( "boy", "-2" );
-
- abbreviations.remove( "bop" );
-
- assertTrue( abbreviations.contains( "box" ) );
- assertEquals( "-1", abbreviations.get( "box" ) );
- assertTrue( abbreviations.contains( "boy" ) );
- assertEquals( "-2", abbreviations.get( "boy" ) );
- assertFalse( abbreviations.contains( "bo" ) );
- assertNull( abbreviations.get( "bo" ) );
- assertFalse( abbreviations.contains( "b" ) );
- assertNull( abbreviations.get( "b" ) );
- }
-
- @Test
- public void addKeysWithCommonPrefixesStairstepStyle() {
- abbreviations.put( "a", "1" );
- abbreviations.put( "abc", "2" );
-
- assertTrue( abbreviations.contains( "a" ) );
- assertEquals( "1", abbreviations.get( "a" ) );
- assertTrue( abbreviations.contains( "ab" ) );
- assertEquals( "2", abbreviations.get( "ab" ) );
- assertTrue( abbreviations.contains( "abc" ) );
- assertEquals( "2", abbreviations.get( "abc" ) );
-
- abbreviations.put( "abcde", "3" );
-
- assertTrue( abbreviations.contains( "a" ) );
- assertEquals( "1", abbreviations.get( "a" ) );
- assertFalse( abbreviations.contains( "ab" ) );
- assertNull( abbreviations.get( "ab" ) );
- assertTrue( abbreviations.contains( "abc" ) );
- assertEquals( "2", abbreviations.get( "abc" ) );
- assertTrue( abbreviations.contains( "abcd" ) );
- assertEquals( "3", abbreviations.get( "abcd" ) );
- assertTrue( abbreviations.contains( "abcde" ) );
- assertEquals( "3", abbreviations.get( "abcde" ) );
- }
-
- @Test
- public void addKeysWithCommonPrefixesStairstepStyleJumbled() {
- abbreviations.put( "a", "1" );
- abbreviations.put( "abcde", "3" );
- abbreviations.put( "abc", "2" );
-
- assertTrue( abbreviations.contains( "a" ) );
- assertEquals( "1", abbreviations.get( "a" ) );
- assertFalse( abbreviations.contains( "ab" ) );
- assertNull( abbreviations.get( "ab" ) );
- assertTrue( abbreviations.contains( "abc" ) );
- assertEquals( "2", abbreviations.get( "abc" ) );
- assertTrue( abbreviations.contains( "abcd" ) );
- assertEquals( "3", abbreviations.get( "abcd" ) );
- assertTrue( abbreviations.contains( "abcde" ) );
- assertEquals( "3", abbreviations.get( "abcde" ) );
- }
-
- @Test
- public void multipleKeysWithCommonPrefix() {
- abbreviations.put( "good", "4" );
- abbreviations.put( "goodyear", "8" );
- abbreviations.put( "go", "2" );
- abbreviations.put( "goodyea", "7" );
- abbreviations.put( "goodye", "6" );
-
- assertFalse( abbreviations.contains( "g" ) );
- assertNull( abbreviations.get( "g" ) );
- assertTrue( abbreviations.contains( "go" ) );
- assertEquals( "2", abbreviations.get( "go" ) );
- assertFalse( abbreviations.contains( "goo" ) );
- assertNull( abbreviations.get( "goo" ) );
- assertTrue( abbreviations.contains( "good" ) );
- assertEquals( "4", abbreviations.get( "good" ) );
- assertFalse( abbreviations.contains( "goody" ) );
- assertNull( abbreviations.get( "goody" ) );
- assertTrue( abbreviations.contains( "goodye" ) );
- assertEquals( "6", abbreviations.get( "goodye" ) );
- assertTrue( abbreviations.contains( "goodyea" ) );
- assertEquals( "7", abbreviations.get( "goodyea" ) );
- assertTrue( abbreviations.contains( "goodyea" ) );
- assertEquals( "8", abbreviations.get( "goodyear" ) );
-
- abbreviations.remove( "goodyea" );
-
- assertFalse( abbreviations.contains( "g" ) );
- assertNull( abbreviations.get( "g" ) );
- assertTrue( abbreviations.contains( "go" ) );
- assertEquals( "2", abbreviations.get( "go" ) );
- assertFalse( abbreviations.contains( "goo" ) );
- assertNull( abbreviations.get( "goo" ) );
- assertTrue( abbreviations.contains( "good" ) );
- assertEquals( "4", abbreviations.get( "good" ) );
- assertFalse( abbreviations.contains( "goody" ) );
- assertNull( abbreviations.get( "goody" ) );
- assertTrue( abbreviations.contains( "goodye" ) );
- assertEquals( "6", abbreviations.get( "goodye" ) );
- assertTrue( abbreviations.contains( "goodyea" ) );
- assertEquals( "8", abbreviations.get( "goodyea" ) );
- assertTrue( abbreviations.contains( "goodyea" ) );
- assertEquals( "8", abbreviations.get( "goodyear" ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/AbbreviationMapToJavaUtilMapTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/internal/AbbreviationMapToJavaUtilMapTest.java
deleted file mode 100644
index 8bc0621..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/AbbreviationMapToJavaUtilMapTest.java
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.internal;
-
-import static java.util.Collections.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class AbbreviationMapToJavaUtilMapTest {
- private AbbreviationMap<String> abbreviations;
-
- @Before
- public void setUp() {
- abbreviations = new AbbreviationMap<>();
- }
-
- @Test
- public void empty() {
- assertEquals( emptyMap(), abbreviations.toJavaUtilMap() );
- }
-
- @Test
- public void addingOne() {
- abbreviations.put( "box", "2" );
-
- assertEquals( singletonMap( "box", "2" ), abbreviations.toJavaUtilMap() );
- }
-
- @Test
- public void addingManyWithNoCommonPrefix() {
- abbreviations.put( "box", "1" );
- abbreviations.put( "cat", "2" );
- abbreviations.put( "dog", "3" );
-
- assertEquals( "{box=1, cat=2, dog=3}", abbreviations.toJavaUtilMap().toString() );
- }
-
- @Test
- public void addingTwoWithCommonPrefix() {
- abbreviations.put( "box", "3" );
- abbreviations.put( "boy", "4" );
-
- assertEquals( "{box=3, boy=4}", abbreviations.toJavaUtilMap().toString() );
- }
-
- @Test
- public void addingThreeWithSuccessivelySmallerPrefixes() {
- abbreviations.put( "boy", "3" );
- abbreviations.put( "bo", "2" );
- abbreviations.put( "b", "1" );
-
- assertEquals( "{b=1, bo=2, boy=3}", abbreviations.toJavaUtilMap().toString() );
- }
-
- @Test
- public void addingThreeWithSuccessivelyLargerPrefixes() {
- abbreviations.put( "b", "1" );
- abbreviations.put( "bo", "2" );
- abbreviations.put( "boy", "3" );
-
- assertEquals( "{b=1, bo=2, boy=3}", abbreviations.toJavaUtilMap().toString() );
- }
-
- @Test
- public void addingThreeWithMixOfPrefixSize() {
- abbreviations.put( "boy", "3" );
- abbreviations.put( "b", "1" );
- abbreviations.put( "bo", "2" );
-
- assertEquals( "{b=1, bo=2, boy=3}", abbreviations.toJavaUtilMap().toString() );
- }
-
- @Test
- public void addingOneThenReplacing() {
- abbreviations.put( "box", "2" );
- abbreviations.put( "box", "3" );
-
- assertEquals( "{box=3}", abbreviations.toJavaUtilMap().toString() );
- }
-
- @Test
- public void removeKeyWithCommonPrefix() {
- abbreviations.put( "box", "-1" );
- abbreviations.put( "boy", "-2" );
- abbreviations.remove( "box" );
-
- assertEquals( "{boy=-2}", abbreviations.toJavaUtilMap().toString() );
- }
-
- @Test
- public void addKeysWithCommonPrefixesStairstepStyle() {
- abbreviations.put( "a", "1" );
- abbreviations.put( "abc", "2" );
- abbreviations.put( "abcde", "3" );
-
- assertEquals( "{a=1, abc=2, abcde=3}", abbreviations.toJavaUtilMap().toString() );
- }
-
- @Test
- public void addKeysWithCommonPrefixesStairstepStyleJumbled() {
- abbreviations.put( "a", "1" );
- abbreviations.put( "abcde", "3" );
- abbreviations.put( "abc", "2" );
-
- assertEquals( "{a=1, abc=2, abcde=3}", abbreviations.toJavaUtilMap().toString() );
- }
-
- @Test
- public void multipleKeysWithCommonPrefix() {
- abbreviations.put( "good", "4" );
- abbreviations.put( "goodyear", "8" );
- abbreviations.put( "go", "2" );
- abbreviations.put( "goodyea", "7" );
- abbreviations.put( "goodye", "6" );
- abbreviations.remove( "goodyea" );
-
- assertEquals( "{go=2, good=4, goodye=6, goodyear=8}", abbreviations.toJavaUtilMap().toString() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/ClassesUtilityClassTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/internal/ClassesUtilityClassTest.java
deleted file mode 100644
index 89f3ea2..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/ClassesUtilityClassTest.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.internal;
-
-import joptsimple.UtilityClassesUninstantiabilityHarness;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ClassesUtilityClassTest extends UtilityClassesUninstantiabilityHarness {
- public ClassesUtilityClassTest() {
- super( Classes.class );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/MessagesUtilityClassTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/internal/MessagesUtilityClassTest.java
deleted file mode 100644
index a0c1051..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/MessagesUtilityClassTest.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.internal;
-
-import joptsimple.UtilityClassesUninstantiabilityHarness;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class MessagesUtilityClassTest extends UtilityClassesUninstantiabilityHarness {
- public MessagesUtilityClassTest() {
- super( Messages.class );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/Problematic.java b/third_party/java/jopt-simple/src/test/java/joptsimple/internal/Problematic.java
deleted file mode 100644
index 9ec93d6..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/Problematic.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.internal;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-class Problematic {
- private Problematic() {
- // no-op
- }
-
- Problematic( String s ) {
- throw new IllegalStateException(s);
- }
-
- private static void boo() {
- // no-op
- }
-
- static void mute() {
- new Problematic().stuff();
- }
-
- void stuff() {
- boo();
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/ReflectionTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/internal/ReflectionTest.java
deleted file mode 100644
index 06f9682..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/ReflectionTest.java
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.internal;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-
-import static joptsimple.internal.Reflection.*;
-import static org.junit.rules.ExpectedException.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ReflectionTest {
- @Rule public final ExpectedException thrown = none();
-
- @Test
- public void invokingConstructorQuietlyWrapsInstantiationException() throws Exception {
- Constructor<AbstractProblematic> constructor = AbstractProblematic.class.getDeclaredConstructor();
-
- thrown.expect( ReflectionException.class );
- thrown.expectMessage( InstantiationException.class.getName() );
-
- instantiate( constructor );
- }
-
- @Test
- public void invokingConstructorQuietlyWrapsIllegalAccessException() throws Exception {
- Constructor<Problematic> constructor = Problematic.class.getDeclaredConstructor();
-
- thrown.expect( ReflectionException.class );
- thrown.expectMessage( IllegalAccessException.class.getName() );
-
- instantiate( constructor );
- }
-
- @Test
- public void invokingConstructorQuietlyWrapsCauseOfInvocationTargetException() throws Exception {
- Constructor<Problematic> constructor = Problematic.class.getDeclaredConstructor( String.class );
-
- thrown.expect( ReflectionException.class );
- thrown.expectMessage( IllegalStateException.class.getName() );
-
- instantiate( constructor, "arg" );
- }
-
- @Test
- public void invokingConstructorQuietlyWrapsIllegalArgumentException() throws Exception {
- Constructor<Problematic> constructor = Problematic.class.getDeclaredConstructor(String.class);
-
- thrown.expect( ReflectionException.class );
- thrown.expectMessage( IllegalArgumentException.class.getName() );
-
- instantiate( constructor );
- }
-
- @Test
- public void invokingStaticMethodQuietlyWrapsIllegalAccessException() throws Exception {
- Method method = Problematic.class.getDeclaredMethod( "boo" );
-
- thrown.expect( ReflectionException.class );
- thrown.expectMessage( IllegalAccessException.class.getName() );
-
- invoke( method );
- }
-
- @Test
- public void invokingStaticMethodQuietlyWrapsIllegalArgumentException() throws Exception {
- Method method = Problematic.class.getDeclaredMethod( "mute" );
-
- thrown.expect( ReflectionException.class );
- thrown.expectMessage( IllegalArgumentException.class.getName() );
-
- invoke( method, new Object() );
- }
-
- private abstract static class AbstractProblematic {
- protected AbstractProblematic() {
- // no-op
- }
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/ReflectionUtilityClassTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/internal/ReflectionUtilityClassTest.java
deleted file mode 100644
index 7634a49..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/ReflectionUtilityClassTest.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.internal;
-
-import joptsimple.UtilityClassesUninstantiabilityHarness;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class ReflectionUtilityClassTest extends UtilityClassesUninstantiabilityHarness {
- public ReflectionUtilityClassTest() {
- super( Reflection.class );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/RowEqualsHashCodeTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/internal/RowEqualsHashCodeTest.java
deleted file mode 100644
index e1ad850..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/RowEqualsHashCodeTest.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.internal;
-
-import org.infinitest.toolkit.StrictEqualsHashCodeTestSupport;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class RowEqualsHashCodeTest extends StrictEqualsHashCodeTestSupport {
- @Override
- protected Object equalButDifferentClass() {
- return new Row( "o", "d" ) {
- };
- }
-
- @Override
- protected Object equal() throws Exception {
- return new Row( "o", "d" );
- }
-
- @Override
- protected Object notEqual() throws Exception {
- return new Row( "o", "e" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/RowsTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/internal/RowsTest.java
deleted file mode 100644
index c07522d..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/RowsTest.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.internal;
-
-import org.junit.Test;
-
-import static joptsimple.internal.Strings.*;
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class RowsTest {
- @Test
- public void optionsAndDescriptionsWithinOverallWidth() {
- Rows rows = new Rows( 40, 2 );
- rows.add( "left one", "right one" );
- rows.add( "another left one", "another right one" );
-
- assertRows( rows,
- "left one right one ",
- "another left one another right one" );
- }
-
- @Test
- public void someOptionsExceedOverallWidth() {
- Rows rows = new Rows( 40, 2 );
- rows.add( "left one is pretty freaking long to be over here", "right one" );
- rows.add( "another left one also has length that is quite excessive", "another right one" );
-
- assertRows( rows,
- "left one is pretty right one ",
- " freaking long to ",
- " be over here ",
- "another left one another right one",
- " also has length ",
- " that is quite ",
- " excessive " );
- }
-
- @Test
- public void someDescriptionsExceedOverallWidth() {
- Rows rows = new Rows( 40, 2 );
- rows.add( "left one", "right one for the time we have chosen" );
- rows.add( "another left one", "another right one could be used here instead" );
-
- assertRows( rows,
- "left one right one for the ",
- " time we have chosen",
- "another left one another right one ",
- " could be used here ",
- " instead " );
- }
-
- private void assertRows( Rows rows, String... expected ) {
- rows.fitToWidth();
-
- assertEquals( join( expected, LINE_SEPARATOR ) + LINE_SEPARATOR, rows.render() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/SimpleOptionNameMapTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/internal/SimpleOptionNameMapTest.java
deleted file mode 100644
index ae9ae0d..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/SimpleOptionNameMapTest.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.internal;
-
-import java.util.List;
-import java.util.Map;
-
-import org.junit.Test;
-
-import static java.util.Arrays.*;
-
-import static org.junit.Assert.*;
-
-public class SimpleOptionNameMapTest {
- private static final Integer VALUE = 1;
- private static final String KEY = "someKey";
- private static final String KEY2 = "someOtherKey";
-
- @Test
- public void putAndContains() {
- SimpleOptionNameMap<Integer> map = new SimpleOptionNameMap<>();
- assertFalse( map.contains( KEY ) );
-
- map.put( KEY, 1 );
-
- assertTrue( map.contains( KEY ) );
- }
-
- @Test
- public void get() {
- SimpleOptionNameMap<Integer> map = new SimpleOptionNameMap<>();
- assertNull( map.get( KEY ) );
-
- map.put( KEY, VALUE );
-
- assertEquals( VALUE, map.get( KEY ) );
- }
-
- @Test
- public void putAll() {
- SimpleOptionNameMap<Integer> map = new SimpleOptionNameMap<>();
- List<String> keys = asList( KEY, KEY2 );
-
- map.putAll( keys, VALUE );
-
- assertEquals( VALUE, map.get( KEY ) );
- assertEquals( VALUE, map.get( KEY2 ) );
- }
-
- @Test
- public void remove() {
- SimpleOptionNameMap<Integer> map = new SimpleOptionNameMap<>();
- map.put( KEY, 1 );
-
- map.remove( KEY );
-
- assertFalse( map.contains( KEY ) );
- }
-
- @Test
- public void toJavaUtilMap() {
- SimpleOptionNameMap<Integer> map = new SimpleOptionNameMap<>();
- map.put( KEY, VALUE );
-
- Map<String, Integer> javaUtilMap = map.toJavaUtilMap();
-
- assertEquals( VALUE, javaUtilMap.get( KEY ) );
- assertEquals( 1, javaUtilMap.size() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/StringsUtilityClassTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/internal/StringsUtilityClassTest.java
deleted file mode 100644
index a56b2a5..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/internal/StringsUtilityClassTest.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.internal;
-
-import joptsimple.UtilityClassesUninstantiabilityHarness;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class StringsUtilityClassTest extends UtilityClassesUninstantiabilityHarness {
- public StringsUtilityClassTest() {
- super( Strings.class );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/util/DateConverterTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/util/DateConverterTest.java
deleted file mode 100644
index 93baa0ba..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/util/DateConverterTest.java
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.util;
-
-import java.text.DateFormat;
-import java.text.FieldPosition;
-import java.text.NumberFormat;
-import java.text.ParsePosition;
-import java.text.SimpleDateFormat;
-import java.util.Date;
-
-import static java.text.DateFormat.*;
-
-import joptsimple.ValueConversionException;
-import joptsimple.ValueConverter;
-import org.joda.time.LocalDate;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-
-import static joptsimple.util.DateConverter.*;
-import static org.hamcrest.CoreMatchers.*;
-import static org.junit.Assert.*;
-import static org.junit.rules.ExpectedException.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class DateConverterTest {
- @Rule public final ExpectedException thrown = none();
-
- private DateFormat notASimpleDateFormat;
- private SimpleDateFormat monthDayYear;
-
- @Before
- public void setUp() {
- notASimpleDateFormat = new DateFormat() {
- private static final long serialVersionUID = -1L;
-
- {
- setNumberFormat( NumberFormat.getInstance() );
- }
-
- @Override
- public StringBuffer format( Date date, StringBuffer toAppendTo, FieldPosition fieldPosition ) {
- return null;
- }
-
- @Override
- public Date parse( String source, ParsePosition pos ) {
- return null;
- }
- };
-
- monthDayYear = new SimpleDateFormat( "MM/dd/yyyy" );
- }
-
- @Test( expected = NullPointerException.class )
- public void rejectsNullDateFormatter() {
- new DateConverter( null );
- }
-
- @Test
- public void shouldConvertValuesToDatesUsingADateFormat() {
- ValueConverter<Date> converter = new DateConverter( monthDayYear );
-
- assertEquals( new LocalDate( 2009, 1, 24 ).toDate(), converter.convert( "01/24/2009" ) );
- }
-
- @Test
- public void rejectsNonParsableValues() {
- thrown.expect( ValueConversionException.class );
-
- new DateConverter( getDateInstance() ).convert( "@(#*^" );
- }
-
- @Test
- public void rejectsValuesThatDoNotEntirelyMatch() {
- thrown.expect( ValueConversionException.class );
-
- new DateConverter( monthDayYear ).convert( "12/25/09 00:00:00" );
- }
-
- @Test
- public void shouldCreateSimpleDateFormatConverter() {
- assertEquals( new LocalDate( 2009, 7, 4 ).toDate(), datePattern( "MM/dd/yyyy" ).convert( "07/04/2009" ) );
- }
-
- @Test
- public void rejectsNullDatePattern() {
- thrown.expect( NullPointerException.class );
-
- datePattern( null );
- }
-
- @Test
- public void shouldRaiseExceptionThatContainsDatePatternAndValue() {
- thrown.expect( ValueConversionException.class );
- thrown.expectMessage( "qwe" );
- thrown.expectMessage( monthDayYear.toPattern() );
-
- new DateConverter( monthDayYear ).convert( "qwe" );
- }
-
- @Test
- public void shouldRaiseExceptionThatContainsValueOnlyIfNotASimpleDateFormat() {
- thrown.expect( ValueConversionException.class );
- thrown.expectMessage( "asdf" );
- thrown.expectMessage( not( containsString( notASimpleDateFormat.toString() ) ) );
-
- new DateConverter( notASimpleDateFormat ).convert( "asdf" );
- }
-
- @Test
- public void shouldAnswerCorrectValueType() {
- assertSame( Date.class, new DateConverter( monthDayYear ).valueType() );
- }
-
- @Test
- public void shouldGiveNoValuePatternIfFormatterNotASimpleDateFormat() {
- assertEquals( "", new DateConverter( notASimpleDateFormat ).valuePattern() );
- }
-
- @Test
- public void shouldGiveValuePatternIfFormatterIsASimpleDateFormat() {
- assertEquals( monthDayYear.toPattern(), datePattern( monthDayYear.toPattern() ).valuePattern() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/util/EnumConverterTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/util/EnumConverterTest.java
deleted file mode 100644
index 617f146..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/util/EnumConverterTest.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2014 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.util;
-
-import joptsimple.ValueConversionException;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
-import static org.junit.rules.ExpectedException.none;
-
-/**
- * @author <a href="mailto:christian.ohr@gmail.com">Christian Ohr</a>
- */
-public class EnumConverterTest {
- @Rule
- public final ExpectedException thrown = none();
-
- private EnumConverter<TestEnum> converter;
-
- @Before
- public void setUp() {
- converter = new TestEnumConverter();
- }
-
- @Test
- public void convertsEnumValuesToEnum() {
- assertEquals( TestEnum.A, converter.convert( "A" ) );
- }
-
- @Test
- public void rejectsNonEnumeratedValues() {
- thrown.expect( ValueConversionException.class );
-
- converter.convert( "Z" );
- }
-
- @Test
- public void answersCorrectValueType() {
- assertSame( TestEnum.class, converter.valueType() );
- }
-
- @Test
- public void givesDefaultValuePattern() {
- assertEquals( "[A,B,C,D]", converter.valuePattern() );
- }
-
- @Test
- public void givesCustomValuePattern() {
- converter.setDelimiters( "(|)" );
-
- assertEquals( "(A|B|C|D)", converter.valuePattern() );
- }
-
- @Test
- public void ignoresCase() {
- assertEquals( TestEnum.A, converter.convert( "a" ) );
- }
-
- private static class TestEnumConverter extends EnumConverter<TestEnum> {
- TestEnumConverter() {
- super( TestEnum.class );
- }
- }
-
- private static enum TestEnum {
- A, B, C, D
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/util/InetAddressConverterTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/util/InetAddressConverterTest.java
deleted file mode 100644
index 98f418f..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/util/InetAddressConverterTest.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.util;
-
-import java.net.InetAddress;
-import java.util.Random;
-
-import joptsimple.ValueConversionException;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-import static org.junit.Assume.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class InetAddressConverterTest {
- private InetAddressConverter converter;
-
- @Before
- public void setUp() {
- converter = new InetAddressConverter();
- }
-
- @Test
- public void localhost() throws Exception {
- assumeTrue( InetAddress.getByName( "127.0.0.1" ).isReachable( 5000 ) );
-
- assertEquals( "127.0.0.1", converter.convert( "localhost" ).getHostAddress() );
- }
-
- @Test( expected = ValueConversionException.class )
- public void unknownHost() {
- converter.convert( "!(@&#()!*@&#" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/util/KeyValuePairTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/util/KeyValuePairTest.java
deleted file mode 100644
index e0c64e9..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/util/KeyValuePairTest.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.util;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class KeyValuePairTest {
- @Test( expected = NullPointerException.class )
- public void nullArg() {
- KeyValuePair.valueOf( null );
- }
-
- @Test
- public void empty() {
- KeyValuePair pair = KeyValuePair.valueOf( "" );
-
- assertEquals( "", pair.key );
- assertEquals( "", pair.value );
- }
-
- @Test
- public void noEqualsSign() {
- KeyValuePair pair = KeyValuePair.valueOf( "aString" );
-
- assertEquals( "aString", pair.key );
- assertEquals( "", pair.value );
- }
-
- @Test
- public void signAtEnd() {
- KeyValuePair pair = KeyValuePair.valueOf( "aKey=" );
-
- assertEquals( "aKey", pair.key );
- assertEquals( "", pair.value );
- }
-
- @Test
- public void signAtStart() {
- KeyValuePair pair = KeyValuePair.valueOf( "=aValue" );
-
- assertEquals( "", pair.key );
- assertEquals( "aValue", pair.value );
- }
-
- @Test
- public void typical() {
- KeyValuePair pair = KeyValuePair.valueOf( "aKey=aValue" );
-
- assertEquals( "aKey", pair.key );
- assertEquals( "aValue", pair.value );
- }
-
- @Test
- public void multipleEqualsSignsDoNotMatter() {
- KeyValuePair pair = KeyValuePair.valueOf( "aKey=1=2=3=4" );
-
- assertEquals( "aKey", pair.key );
- assertEquals( "1=2=3=4", pair.value );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/util/KeyValuePairUnequalKeysTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/util/KeyValuePairUnequalKeysTest.java
deleted file mode 100644
index fc130bf..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/util/KeyValuePairUnequalKeysTest.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.util;
-
-import org.infinitest.toolkit.EqualsHashCodeTestSupport;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class KeyValuePairUnequalKeysTest extends EqualsHashCodeTestSupport {
- @Override
- protected KeyValuePair equal() {
- return KeyValuePair.valueOf( "x=z" );
- }
-
- @Override
- protected KeyValuePair notEqual() {
- return KeyValuePair.valueOf( "y=z" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/util/KeyValuePairUnequalValuesTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/util/KeyValuePairUnequalValuesTest.java
deleted file mode 100644
index 4bb36b7..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/util/KeyValuePairUnequalValuesTest.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.util;
-
-import org.infinitest.toolkit.EqualsHashCodeTestSupport;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class KeyValuePairUnequalValuesTest extends EqualsHashCodeTestSupport {
- @Override
- protected KeyValuePair equal() {
- return KeyValuePair.valueOf( "x=y" );
- }
-
- @Override
- protected KeyValuePair notEqual() {
- return KeyValuePair.valueOf( "x=z" );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/util/PathConverterTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/util/PathConverterTest.java
deleted file mode 100644
index 6b54393..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/util/PathConverterTest.java
+++ /dev/null
@@ -1,104 +0,0 @@
-package joptsimple.util;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-
-import joptsimple.ValueConversionException;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-
-import static joptsimple.util.PathProperties.*;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-public class PathConverterTest {
- @Rule
- public ExpectedException exception = ExpectedException.none();
-
- @Test
- public void convertsValuesToPaths() throws Exception {
- Path path = Files.createTempFile( "prefix", null );
- path.toFile().deleteOnExit();
-
- String pathName = path.toString();
-
- assertEquals( path, new PathConverter( null ).convert( pathName ) );
- assertEquals( path, new PathConverter().convert( pathName ) );
- }
-
- @Test
- public void answersCorrectValueType() {
- assertEquals( Path.class, new PathConverter().valueType() );
- }
-
- @Test
- public void testReadableAndOverwritableFile() throws Exception {
- Path path = Files.createTempFile( "prefix", null );
- path.toFile().deleteOnExit();
-
- String pathName = path.toString();
-
- assertTrue( Files.isReadable( new PathConverter( READABLE ).convert( pathName ) ) );
- assertTrue( Files.exists( new PathConverter( READABLE ).convert( pathName ) ) );
- assertTrue( Files.isWritable( new PathConverter( READABLE ).convert( pathName ) ) );
- assertTrue( Files.isWritable( new PathConverter( FILE_OVERWRITABLE).convert( pathName ) ) );
- }
-
- @Test
- public void testNotExisting() throws Exception {
- Path path = Files.createTempFile( "prefix", null );
-
- Files.deleteIfExists( path );
-
- assertFalse( Files.exists( new PathConverter( NOT_EXISTING ).convert( path.toString() ) ) );
- }
-
- @Test
- public void testNotReadable() throws Exception {
- Path path = Files.createTempFile( "prefix", null );
- String pathName = path.toString();
- Files.deleteIfExists( path );
-
- exception.expect( ValueConversionException.class );
- exception.expectMessage( "File [" + pathName );
-
- new PathConverter( READABLE ).convert( pathName );
- }
-
- @Test
- public void testDirectoryExisting() throws Exception {
- Path path = Files.createTempDirectory( "prefix" );
- path.toFile().deleteOnExit();
-
- String pathName = path.toString();
-
- assertTrue( Files.isDirectory( new PathConverter( DIRECTORY_EXISTING ).convert( pathName ) ) );
- }
-
- @Test
- public void testDirectoryNotOverwritable() throws Exception {
- Path path = Files.createTempDirectory( "prefix" );
- path.toFile().deleteOnExit();
-
- String pathName = path.toString();
-
- exception.expect( ValueConversionException.class );
- exception.expectMessage( "File [" + pathName );
-
- new PathConverter( FILE_OVERWRITABLE).convert( pathName );
- }
-
- @Test
- public void testNotExistingNotOverwritable() throws Exception {
- Path path = Files.createTempDirectory( "prefix" );
- String pathName = path.toString();
- Files.deleteIfExists( path );
-
- exception.expect( ValueConversionException.class );
- exception.expectMessage( "File [" + pathName );
-
- new PathConverter( FILE_OVERWRITABLE ).convert( pathName );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/util/PathPropertiesTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/util/PathPropertiesTest.java
deleted file mode 100644
index 1c6bf59..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/util/PathPropertiesTest.java
+++ /dev/null
@@ -1,54 +0,0 @@
-package joptsimple.util;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-import static joptsimple.util.PathProperties.*;
-
-public class PathPropertiesTest {
- @Test
- public void readableFile() throws Exception {
- Path path = Files.createTempFile("prefix", null);
-
- path.toFile().deleteOnExit();
-
- assertTrue( READABLE.accept( path ) );
- assertFalse( DIRECTORY_EXISTING.accept( path ) );
- assertTrue( FILE_EXISTING.accept( path ) );
- assertTrue( FILE_OVERWRITABLE.accept( path ) );
- assertTrue( WRITABLE.accept( path ) );
- assertFalse( NOT_EXISTING.accept( path ) );
- }
-
- @Test
- public void nonExisting() throws Exception {
- Path path = Files.createTempFile( "prefix", null );
-
- Files.deleteIfExists( path );
-
- assertFalse( READABLE.accept( path ) );
- assertFalse( DIRECTORY_EXISTING.accept( path ) );
- assertFalse( FILE_EXISTING.accept( path ) );
- assertFalse( FILE_OVERWRITABLE.accept( path ) );
- assertTrue( NOT_EXISTING.accept( path ) );
- assertFalse( WRITABLE.accept( path ) );
- }
-
- @Test
- public void directory() throws Exception {
- Path path = Files.createTempDirectory( "prefix" );
-
- path.toFile().deleteOnExit();
-
- assertTrue( READABLE.accept( path ) );
- assertTrue( DIRECTORY_EXISTING.accept( path ) );
- assertFalse( FILE_EXISTING.accept( path ) );
- assertFalse( FILE_OVERWRITABLE.accept( path ) );
- assertFalse( NOT_EXISTING.accept( path ) );
- assertTrue( WRITABLE.accept( path ) );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/java/joptsimple/util/RegexMatcherTest.java b/third_party/java/jopt-simple/src/test/java/joptsimple/util/RegexMatcherTest.java
deleted file mode 100644
index 56eae7e..0000000
--- a/third_party/java/jopt-simple/src/test/java/joptsimple/util/RegexMatcherTest.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- The MIT License
-
- Copyright (c) 2004-2015 Paul R. Holser, Jr.
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-package joptsimple.util;
-
-import joptsimple.ValueConversionException;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-
-import static joptsimple.util.RegexMatcher.*;
-import static org.junit.Assert.*;
-import static org.junit.rules.ExpectedException.*;
-
-/**
- * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
- */
-public class RegexMatcherTest {
- @Rule public final ExpectedException thrown = none();
-
- private RegexMatcher abc;
-
- @Before
- public void setUp() {
- abc = new RegexMatcher( "abc", 0 );
- }
-
- @Test
- public void shouldAttemptToMatchValueAgainstARegex() {
- assertEquals( "abc", abc.convert( "abc" ) );
- }
-
- @Test( expected = ValueConversionException.class )
- public void rejectsValueThatDoesNotMatchRegex() {
- abc.convert( "abcd" );
- }
-
- @Test
- public void raisesExceptionContainingValueAndPattern() {
- thrown.expect( ValueConversionException.class );
- thrown.expectMessage( "\\d+" );
- thrown.expectMessage( "asdf" );
-
- new RegexMatcher( "\\d+", 0 ).convert( "asdf" );
- }
-
- @Test
- public void shouldOfferConvenienceMethodForCreatingMatcherWithNoFlags() {
- assertEquals( "sourceforge.net", regex( "\\w+\\.\\w+" ).convert( "sourceforge.net" ) );
- }
-
- @Test
- public void shouldAnswerCorrectValueType() {
- assertEquals( String.class, abc.valueType() );
- }
-
- @Test
- public void shouldGiveCorrectValuePattern() {
- assertEquals( "abc", abc.valuePattern() );
- }
-}
diff --git a/third_party/java/jopt-simple/src/test/resources/joptsimple/ExceptionMessages_xx_YY.properties b/third_party/java/jopt-simple/src/test/resources/joptsimple/ExceptionMessages_xx_YY.properties
deleted file mode 100644
index ac78a62..0000000
--- a/third_party/java/jopt-simple/src/test/resources/joptsimple/ExceptionMessages_xx_YY.properties
+++ /dev/null
@@ -1,10 +0,0 @@
-joptsimple.IllegalOptionSpecificationException.message = illegal option specification exception
-joptsimple.MissingRequiredOptionsException.message = missing required option exception
-joptsimple.MultipleArgumentsForOptionException.message = multiple arguments for option exception
-joptsimple.OptionArgumentConversionException.message = option argument conversion exception
-joptsimple.OptionMissingRequiredArgumentException.message = option missing required argument exception
-joptsimple.UnconfiguredOptionException.message = unconfigured option exception
-joptsimple.UnrecognizedOptionException.message = unrecognized option exception
-joptsimple.util.DateConverter.without.pattern.message = date converter without pattern
-joptsimple.util.DateConverter.with.pattern.message = date converter with pattern
-joptsimple.util.RegexMatcher.message = regex matcher
\ No newline at end of file
