Update from Google.
--
MOE_MIGRATED_REVID=85702957
diff --git a/src/test/java/com/google/devtools/common/options/OptionsTest.java b/src/test/java/com/google/devtools/common/options/OptionsTest.java
new file mode 100644
index 0000000..700e26b
--- /dev/null
+++ b/src/test/java/com/google/devtools/common/options/OptionsTest.java
@@ -0,0 +1,500 @@
+// Copyright 2014 Google Inc. All rights reserved.
+//
+// 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.
+
+package com.google.devtools.common.options;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+
+/**
+ * Test for {@link Options}.
+ */
+@RunWith(JUnit4.class)
+public class OptionsTest {
+
+ private static final String[] NO_ARGS = {};
+
+ public static class HttpOptions extends OptionsBase {
+
+ @Option(name = "host",
+ defaultValue = "www.google.com",
+ help = "The URL at which the server will be running.")
+ public String host;
+
+ @Option(name = "port",
+ abbrev = 'p',
+ defaultValue = "80",
+ help = "The port at which the server will be running.")
+ public int port;
+
+ @Option(name = "debug",
+ abbrev = 'd',
+ defaultValue = "false",
+ help = "debug")
+ public boolean isDebugging;
+
+ @Option(name = "tristate",
+ abbrev = 't',
+ defaultValue = "auto",
+ help = "tri-state option returning auto by default")
+ public TriState triState;
+
+ @Option(name = "special",
+ defaultValue = "null",
+ expansion = { "--host=special.google.com", "--port=8080"})
+ public Void special;
+ }
+
+ @Test
+ public void paragraphFill() throws Exception {
+ // TODO(bazel-team): don't include trailing space after last word in line.
+ String input = "The quick brown fox jumps over the lazy dog.";
+
+ assertEquals(" The quick \n brown fox \n jumps over \n the lazy \n"
+ + " dog.",
+ OptionsUsage.paragraphFill(input, 2, 13));
+ assertEquals(" The quick brown \n fox jumps over \n the lazy dog.",
+ OptionsUsage.paragraphFill(input, 3, 19));
+
+ String input2 = "The quick brown fox jumps\nAnother paragraph.";
+ assertEquals(" The quick brown fox \n jumps\n Another paragraph.",
+ OptionsUsage.paragraphFill(input2, 2, 23));
+ }
+
+ @Test
+ public void getsDefaults() throws OptionsParsingException {
+ Options<HttpOptions> options = Options.parse(HttpOptions.class, NO_ARGS);
+ String[] remainingArgs = options.getRemainingArgs();
+ HttpOptions webFlags = options.getOptions();
+
+ assertEquals("www.google.com", webFlags.host);
+ assertEquals(80, webFlags.port);
+ assertEquals(false, webFlags.isDebugging);
+ assertEquals(TriState.AUTO, webFlags.triState);
+ assertEquals(0, remainingArgs.length);
+ }
+
+ @Test
+ public void objectMethods() throws OptionsParsingException {
+ String[] args = { "--host", "foo", "--port", "80" };
+ HttpOptions left =
+ Options.parse(HttpOptions.class, args).getOptions();
+ HttpOptions likeLeft =
+ Options.parse(HttpOptions.class, args).getOptions();
+ String [] rightArgs = {"--host", "other", "--port", "90" };
+ HttpOptions right =
+ Options.parse(HttpOptions.class, rightArgs).getOptions();
+
+ String toString = left.toString();
+ // Don't rely on Set.toString iteration order:
+ assertTrue(toString.startsWith(
+ "com.google.devtools.common.options.OptionsTest"
+ + "$HttpOptions{"));
+ assertTrue(toString.contains("host=foo"));
+ assertTrue(toString.contains("port=80"));
+ assertTrue(toString.endsWith("}"));
+
+ assertTrue(left.equals(left));
+ assertTrue(left.toString().equals(likeLeft.toString()));
+ assertTrue(left.equals(likeLeft));
+ assertTrue(likeLeft.equals(left));
+ assertFalse(left.equals(right));
+ assertFalse(right.equals(left));
+ assertFalse(left.equals(null));
+ assertFalse(likeLeft.equals(null));
+ assertEquals(likeLeft.hashCode(), likeLeft.hashCode());
+ assertEquals(left.hashCode(), likeLeft.hashCode());
+ // Strictly speaking this is not required for hashCode to be correct,
+ // but a good hashCode should be different at least for some values. So,
+ // we're making sure that at least this particular pair of inputs yields
+ // different values.
+ assertFalse(left.hashCode() == right.hashCode());
+ }
+
+ @Test
+ public void equals() throws OptionsParsingException {
+ String[] args = { "--host", "foo", "--port", "80" };
+ HttpOptions options1 = Options.parse(HttpOptions.class, args).getOptions();
+
+ String[] args2 = { "-p", "80", "--host", "foo" };
+ HttpOptions options2 = Options.parse(HttpOptions.class, args2).getOptions();
+ assertEquals("order/abbreviations shouldn't matter", options1, options2);
+
+ assertEquals("explicitly setting a default shouldn't matter",
+ Options.parse(HttpOptions.class, "--port", "80").getOptions(),
+ Options.parse(HttpOptions.class).getOptions());
+
+ assertThat(Options.parse(HttpOptions.class, "--port", "3").getOptions())
+ .isNotEqualTo(Options.parse(HttpOptions.class).getOptions());
+ }
+
+ @Test
+ public void getsFlagsProvidedInArguments()
+ throws OptionsParsingException {
+ String[] args = {"--host", "google.com",
+ "-p", "8080", // short form
+ "--debug"};
+ Options<HttpOptions> options = Options.parse(HttpOptions.class, args);
+ String[] remainingArgs = options.getRemainingArgs();
+ HttpOptions webFlags = options.getOptions();
+
+ assertEquals("google.com", webFlags.host);
+ assertEquals(8080, webFlags.port);
+ assertEquals(true, webFlags.isDebugging);
+ assertEquals(0, remainingArgs.length);
+ }
+
+ @Test
+ public void getsFlagsProvidedWithEquals() throws OptionsParsingException {
+ String[] args = {"--host=google.com",
+ "--port=8080",
+ "--debug"};
+ Options<HttpOptions> options = Options.parse(HttpOptions.class, args);
+ String[] remainingArgs = options.getRemainingArgs();
+ HttpOptions webFlags = options.getOptions();
+
+ assertEquals("google.com", webFlags.host);
+ assertEquals(8080, webFlags.port);
+ assertEquals(true, webFlags.isDebugging);
+ assertEquals(0, remainingArgs.length);
+ }
+
+ @Test
+ public void booleanNo() throws OptionsParsingException {
+ Options<HttpOptions> options =
+ Options.parse(HttpOptions.class, new String[]{"--nodebug", "--notristate"});
+ HttpOptions webFlags = options.getOptions();
+ assertEquals(false, webFlags.isDebugging);
+ assertEquals(TriState.NO, webFlags.triState);
+ }
+
+ @Test
+ public void booleanNoUnderscore() throws OptionsParsingException {
+ Options<HttpOptions> options =
+ Options.parse(HttpOptions.class, new String[]{"--no_debug", "--no_tristate"});
+ HttpOptions webFlags = options.getOptions();
+ assertEquals(false, webFlags.isDebugging);
+ assertEquals(TriState.NO, webFlags.triState);
+ }
+
+ @Test
+ public void booleanAbbrevMinus() throws OptionsParsingException {
+ Options<HttpOptions> options =
+ Options.parse(HttpOptions.class, new String[]{"-d-", "-t-"});
+ HttpOptions webFlags = options.getOptions();
+ assertEquals(false, webFlags.isDebugging);
+ assertEquals(TriState.NO, webFlags.triState);
+ }
+
+ @Test
+ public void boolean0() throws OptionsParsingException {
+ Options<HttpOptions> options =
+ Options.parse(HttpOptions.class, new String[]{"--debug=0", "--tristate=0"});
+ HttpOptions webFlags = options.getOptions();
+ assertEquals(false, webFlags.isDebugging);
+ assertEquals(TriState.NO, webFlags.triState);
+ }
+
+ @Test
+ public void boolean1() throws OptionsParsingException {
+ Options<HttpOptions> options =
+ Options.parse(HttpOptions.class, new String[]{"--debug=1", "--tristate=1"});
+ HttpOptions webFlags = options.getOptions();
+ assertEquals(true, webFlags.isDebugging);
+ assertEquals(TriState.YES, webFlags.triState);
+ }
+
+ @Test
+ public void retainsStuffThatsNotOptions() throws OptionsParsingException {
+ String[] args = {"these", "aint", "options"};
+ Options<HttpOptions> options = Options.parse(HttpOptions.class, args);
+ String[] remainingArgs = options.getRemainingArgs();
+ assertEquals(asList(args), asList(remainingArgs));
+ }
+
+ @Test
+ public void retainsStuffThatsNotComplexOptions()
+ throws OptionsParsingException {
+ String[] args = {"--host", "google.com",
+ "notta",
+ "--port=8080",
+ "option",
+ "--debug=true"};
+ String[] notoptions = {"notta", "option" };
+ Options<HttpOptions> options = Options.parse(HttpOptions.class, args);
+ String[] remainingArgs = options.getRemainingArgs();
+ assertEquals(asList(notoptions), asList(remainingArgs));
+ }
+
+ @Test
+ public void wontParseUnknownOptions() {
+ String [] args = { "--unknown", "--other=23", "--options" };
+ try {
+ Options.parse(HttpOptions.class, args);
+ fail();
+ } catch (OptionsParsingException e) {
+ assertEquals("Unrecognized option: --unknown", e.getMessage());
+ }
+ }
+
+ @Test
+ public void requiresOptionValue() {
+ String[] args = {"--port"};
+ try {
+ Options.parse(HttpOptions.class, args);
+ fail();
+ } catch (OptionsParsingException e) {
+ assertEquals("Expected value after --port", e.getMessage());
+ }
+ }
+
+ @Test
+ public void handlesDuplicateOptions_full() throws Exception {
+ String[] args = {"--port=80", "--port", "81"};
+ Options<HttpOptions> options = Options.parse(HttpOptions.class, args);
+ HttpOptions webFlags = options.getOptions();
+ assertEquals(81, webFlags.port);
+ }
+
+ @Test
+ public void handlesDuplicateOptions_abbrev() throws Exception {
+ String[] args = {"--port=80", "-p", "81"};
+ Options<HttpOptions> options = Options.parse(HttpOptions.class, args);
+ HttpOptions webFlags = options.getOptions();
+ assertEquals(81, webFlags.port);
+ }
+
+ @Test
+ public void duplicateOptionsOkWithSameValues() throws Exception {
+ // These would throw OptionsParsingException if they failed.
+ Options.parse(HttpOptions.class,"--port=80", "--port", "80");
+ Options.parse(HttpOptions.class, "--port=80", "-p", "80");
+ }
+
+ @Test
+ public void isPickyAboutBooleanValues() {
+ try {
+ Options.parse(HttpOptions.class, new String[]{"--debug=not_a_boolean"});
+ fail();
+ } catch (OptionsParsingException e) {
+ assertEquals("While parsing option --debug=not_a_boolean: "
+ + "\'not_a_boolean\' is not a boolean", e.getMessage());
+ }
+ }
+
+ @Test
+ public void isPickyAboutBooleanNos() {
+ try {
+ Options.parse(HttpOptions.class, new String[]{"--nodebug=1"});
+ fail();
+ } catch (OptionsParsingException e) {
+ assertEquals("Unexpected value after boolean option: --nodebug=1", e.getMessage());
+ }
+ }
+
+ @Test
+ public void usageForBuiltinTypes() {
+ String usage = Options.getUsage(HttpOptions.class);
+ // We can't rely on the option ordering.
+ assertTrue(usage.contains(
+ " --[no]debug [-d] (a boolean; default: \"false\")\n" +
+ " debug"));
+ assertTrue(usage.contains(
+ " --host (a string; default: \"www.google.com\")\n" +
+ " The URL at which the server will be running."));
+ assertTrue(usage.contains(
+ " --port [-p] (an integer; default: \"80\")\n" +
+ " The port at which the server will be running."));
+ assertTrue(usage.contains(
+ " --special\n" +
+ " Expands to: --host=special.google.com --port=8080"));
+ assertTrue(usage.contains(
+ " --[no]tristate [-t] (a tri-state (auto, yes, no); default: \"auto\")\n" +
+ " tri-state option returning auto by default"));
+ }
+
+ public static class NullTestOptions extends OptionsBase {
+ @Option(name = "host",
+ defaultValue = "null",
+ help = "The URL at which the server will be running.")
+ public String host;
+
+ @Option(name = "none",
+ defaultValue = "null",
+ expansion = {"--host=www.google.com"},
+ help = "An expanded option.")
+ public Void none;
+ }
+
+ @Test
+ public void usageForNullDefault() {
+ String usage = Options.getUsage(NullTestOptions.class);
+ assertTrue(usage.contains(
+ " --host (a string; default: see description)\n" +
+ " The URL at which the server will be running."));
+ assertTrue(usage.contains(
+ " --none\n" +
+ " An expanded option.\n" +
+ " Expands to: --host=www.google.com"));
+ }
+
+ public static class MyURLConverter implements Converter<URL> {
+
+ @Override
+ public URL convert(String input) throws OptionsParsingException {
+ try {
+ return new URL(input);
+ } catch (MalformedURLException e) {
+ throw new OptionsParsingException("Could not convert '" + input + "': "
+ + e.getMessage());
+ }
+ }
+
+ @Override
+ public String getTypeDescription() {
+ return "a url";
+ }
+
+ }
+
+ public static class UsesCustomConverter extends OptionsBase {
+
+ @Option(name = "url",
+ defaultValue = "http://www.google.com/",
+ converter = MyURLConverter.class)
+ public URL url;
+
+ }
+
+ @Test
+ public void customConverter() throws Exception {
+ Options<UsesCustomConverter> options =
+ Options.parse(UsesCustomConverter.class, new String[0]);
+ URL expected = new URL("http://www.google.com/");
+ assertEquals(expected, options.getOptions().url);
+ }
+
+ @Test
+ public void customConverterThrowsException() throws Exception {
+ String[] args = {"--url=a_malformed:url"};
+ try {
+ Options.parse(UsesCustomConverter.class, args);
+ fail();
+ } catch (OptionsParsingException e) {
+ assertEquals("While parsing option --url=a_malformed:url: "
+ + "Could not convert 'a_malformed:url': "
+ + "no protocol: a_malformed:url", e.getMessage());
+ }
+ }
+
+ @Test
+ public void usageWithCustomConverter() {
+ assertEquals(
+ " --url (a url; default: \"http://www.google.com/\")\n",
+ Options.getUsage(UsesCustomConverter.class));
+ }
+
+ @Test
+ public void unknownBooleanOption() {
+ try {
+ Options.parse(HttpOptions.class, new String[]{"--no-debug"});
+ fail();
+ } catch (OptionsParsingException e) {
+ assertEquals("Unrecognized option: --no-debug", e.getMessage());
+ }
+ }
+
+ public static class J extends OptionsBase {
+ @Option(name = "j", defaultValue = "null")
+ public String string;
+ }
+ @Test
+ public void nullDefaultForReferenceTypeOption() throws Exception {
+ J options = Options.parse(J.class, NO_ARGS).getOptions();
+ assertNull(options.string);
+ }
+
+ public static class K extends OptionsBase {
+ @Option(name = "1", defaultValue = "null")
+ public int int1;
+ }
+ @Test
+ public void nullDefaultForPrimitiveTypeOption() throws Exception {
+ // defaultValue() = "null" is not treated specially for primitive types, so
+ // we get an NumberFormatException from the converter (not a
+ // ClassCastException from casting null to int), just as we would for any
+ // other non-integer-literal string default.
+ try {
+ Options.parse(K.class, NO_ARGS).getOptions();
+ fail();
+ } catch (IllegalStateException e) {
+ assertEquals("OptionsParsingException while retrieving default for "
+ + "int1: 'null' is not an int",
+ e.getMessage());
+ }
+ }
+
+ @Test
+ public void nullIsntInterpretedSpeciallyExceptAsADefaultValue()
+ throws Exception {
+ HttpOptions options =
+ Options.parse(HttpOptions.class,
+ new String[] { "--host", "null" }).getOptions();
+ assertEquals("null", options.host);
+ }
+
+ @Test
+ public void nonDecimalRadicesForIntegerOptions() throws Exception {
+ Options<HttpOptions> options =
+ Options.parse(HttpOptions.class, new String[] { "--port", "0x51"});
+ assertEquals(81, options.getOptions().port);
+ }
+
+ @Test
+ public void expansionOptionSimple() throws Exception {
+ Options<HttpOptions> options =
+ Options.parse(HttpOptions.class, new String[] {"--special"});
+ assertEquals("special.google.com", options.getOptions().host);
+ assertEquals(8080, options.getOptions().port);
+ }
+
+ @Test
+ public void expansionOptionOverride() throws Exception {
+ Options<HttpOptions> options =
+ Options.parse(HttpOptions.class, new String[] {"--port=90", "--special", "--host=foo"});
+ assertEquals("foo", options.getOptions().host);
+ assertEquals(8080, options.getOptions().port);
+ }
+
+ @Test
+ public void expansionOptionEquals() throws Exception {
+ Options<HttpOptions> options1 =
+ Options.parse(HttpOptions.class, new String[] { "--host=special.google.com", "--port=8080"});
+ Options<HttpOptions> options2 =
+ Options.parse(HttpOptions.class, new String[] { "--special" });
+ assertEquals(options1.getOptions(), options2.getOptions());
+ }
+}
