src/test/java/com/google/devtools/common/options/OptionsTest.java

// Copyright 2014 The Bazel Authors. 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());
  }
}