diff --git a/src/test/java/com/google/devtools/build/lib/analysis/util/BuildViewTestCase.java b/src/test/java/com/google/devtools/build/lib/analysis/util/BuildViewTestCase.java
index a33f235..bf69366 100644
--- a/src/test/java/com/google/devtools/build/lib/analysis/util/BuildViewTestCase.java
+++ b/src/test/java/com/google/devtools/build/lib/analysis/util/BuildViewTestCase.java
@@ -342,7 +342,7 @@
     return ResourceSet.createWithRamCpu(Double.MAX_VALUE, Double.MAX_VALUE);
   }
 
-  private BuildConfigurationCollection createConfigurations(
+  protected final BuildConfigurationCollection createConfigurations(
       ImmutableMap<String, Object> skylarkOptions, String... args) throws Exception {
     optionsParser =
         OptionsParser.newOptionsParser(
@@ -359,7 +359,7 @@
     optionsParser.parse(args);
 
     // TODO(juliexxia): when the starlark options parsing work goes in, add type verification here.
-    optionsParser.setStarlarkOptionsForTesting(skylarkOptions);
+    optionsParser.setStarlarkOptions(skylarkOptions);
 
     InvocationPolicyEnforcer optionsPolicyEnforcer =
         getAnalysisMock().getInvocationPolicyEnforcer();
@@ -2216,3 +2216,4 @@
     }
   }
 }
+
diff --git a/src/test/java/com/google/devtools/build/lib/skylark/BUILD b/src/test/java/com/google/devtools/build/lib/skylark/BUILD
index 0fdccf6..6f3d861 100644
--- a/src/test/java/com/google/devtools/build/lib/skylark/BUILD
+++ b/src/test/java/com/google/devtools/build/lib/skylark/BUILD
@@ -55,8 +55,11 @@
         "//src/main/java/com/google/devtools/build/lib:build-base",
         "//src/main/java/com/google/devtools/build/lib:classpath-util",
         "//src/main/java/com/google/devtools/build/lib:events",
+        "//src/main/java/com/google/devtools/build/lib:exitcode-external",
+        "//src/main/java/com/google/devtools/build/lib:keep-going-option",
         "//src/main/java/com/google/devtools/build/lib:packages",
         "//src/main/java/com/google/devtools/build/lib:python-rules",
+        "//src/main/java/com/google/devtools/build/lib:runtime",
         "//src/main/java/com/google/devtools/build/lib:skylark_semantics",
         "//src/main/java/com/google/devtools/build/lib:skylarkinterface",
         "//src/main/java/com/google/devtools/build/lib:util",
@@ -71,6 +74,7 @@
         "//src/main/java/com/google/devtools/build/lib/vfs",
         "//src/main/java/com/google/devtools/build/skyframe",
         "//src/main/java/com/google/devtools/build/skyframe:skyframe-objects",
+        "//src/main/java/com/google/devtools/common/options",
         "//src/test/java/com/google/devtools/build/lib:actions_testutil",
         "//src/test/java/com/google/devtools/build/lib:analysis_testutil",
         "//src/test/java/com/google/devtools/build/lib:foundations_testutil",
diff --git a/src/test/java/com/google/devtools/build/lib/skylark/StarlarkOptionsParsingTest.java b/src/test/java/com/google/devtools/build/lib/skylark/StarlarkOptionsParsingTest.java
new file mode 100644
index 0000000..c47347b
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/skylark/StarlarkOptionsParsingTest.java
@@ -0,0 +1,399 @@
+// Copyright 2018 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.build.lib.skylark;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.devtools.build.lib.testutil.MoreAsserts.assertThrows;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.devtools.build.lib.events.StoredEventHandler;
+import com.google.devtools.build.lib.packages.SkylarkSemanticsOptions;
+import com.google.devtools.build.lib.pkgcache.LoadingOptions;
+import com.google.devtools.build.lib.pkgcache.PackageCacheOptions;
+import com.google.devtools.build.lib.runtime.BlazeCommand;
+import com.google.devtools.build.lib.runtime.BlazeCommandEventHandler.Options;
+import com.google.devtools.build.lib.runtime.BlazeCommandResult;
+import com.google.devtools.build.lib.runtime.ClientOptions;
+import com.google.devtools.build.lib.runtime.Command;
+import com.google.devtools.build.lib.runtime.CommandEnvironment;
+import com.google.devtools.build.lib.runtime.CommonCommandOptions;
+import com.google.devtools.build.lib.runtime.KeepGoingOption;
+import com.google.devtools.build.lib.runtime.StarlarkOptionsParser;
+import com.google.devtools.build.lib.skylark.util.SkylarkTestCase;
+import com.google.devtools.build.lib.util.ExitCode;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.common.options.OptionsBase;
+import com.google.devtools.common.options.OptionsParser;
+import com.google.devtools.common.options.OptionsParsingException;
+import com.google.devtools.common.options.OptionsParsingResult;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit test for the {@code StarlarkOptionsParser}. */
+@RunWith(JUnit4.class)
+public class StarlarkOptionsParsingTest extends SkylarkTestCase {
+
+  private StarlarkOptionsParser starlarkOptionsParser;
+
+  private static final List<Class<? extends OptionsBase>> requiredOptionsClasses =
+      ImmutableList.of(
+          PackageCacheOptions.class,
+          SkylarkSemanticsOptions.class,
+          KeepGoingOption.class,
+          LoadingOptions.class,
+          ClientOptions.class,
+          Options.class,
+          CommonCommandOptions.class);
+
+  @Before
+  public void setUp() throws Exception {
+    optionsParser =
+        OptionsParser.newOptionsParser(
+            Iterables.concat(requiredOptionsClasses, ruleClassProvider.getConfigurationOptions()));
+    starlarkOptionsParser =
+        StarlarkOptionsParser.newStarlarkOptionsParserForTesting(
+            skyframeExecutor, reporter, PathFragment.EMPTY_FRAGMENT, optionsParser);
+  }
+
+  @Command(
+      name = "residue",
+      builds = true,
+      options = {
+        PackageCacheOptions.class,
+        SkylarkSemanticsOptions.class,
+        KeepGoingOption.class,
+        LoadingOptions.class,
+        ClientOptions.class,
+        Options.class,
+      },
+      allowResidue = true,
+      shortDescription =
+          "a dummy command for testing that allows residue and recognizes all"
+              + " relevant options for starlark options parsing.",
+      help = "")
+  private static class ResidueCommand implements BlazeCommand {
+    @Override
+    public BlazeCommandResult exec(CommandEnvironment env, OptionsParsingResult options) {
+      return BlazeCommandResult.exitCode(ExitCode.SUCCESS);
+    }
+
+    @Override
+    public void editOptions(OptionsParser optionsParser) {}
+  }
+
+  private OptionsParsingResult parseStarlarkOptions(String options) throws Exception {
+    starlarkOptionsParser.setResidueForTesting(Arrays.asList(options.split(" ")));
+    starlarkOptionsParser.parse(
+        ResidueCommand.class.getAnnotation(Command.class), new StoredEventHandler());
+    return starlarkOptionsParser.getNativeOptionsParserFortesting();
+  }
+
+  private void writeBuildSetting(String type, String defaultValue, boolean isFlag)
+      throws Exception {
+    setSkylarkSemanticsOptions("--experimental_build_setting_api=True");
+
+    String flag = isFlag ? "True" : "False";
+
+    scratch.file(
+        "test/build_setting.bzl",
+        "def _build_setting_impl(ctx):",
+        "  return []",
+        type + "_setting = rule(",
+        "  implementation = _build_setting_impl,",
+        "  build_setting = config." + type + "(flag=" + flag + ")",
+        ")");
+    scratch.file(
+        "test/BUILD",
+        "load('//test:build_setting.bzl', '" + type + "_setting')",
+        type
+            + "_setting(name = 'my_"
+            + type
+            + "_setting', build_setting_default = "
+            + defaultValue
+            + ")");
+  }
+
+  private void writeBasicIntFlag() throws Exception {
+    writeBuildSetting("int", "42", true);
+  }
+
+  // test --flag=value
+  @Test
+  public void testFlagEqualsValueForm() throws Exception {
+    writeBasicIntFlag();
+
+    OptionsParsingResult result = parseStarlarkOptions("--//test:my_int_setting=666");
+
+    assertThat(result.getStarlarkOptions()).hasSize(1);
+    assertThat(result.getStarlarkOptions().get("//test:my_int_setting")).isEqualTo(666);
+    assertThat(result.getResidue()).isEmpty();
+  }
+
+  // test --flag value
+  @Test
+  public void testFlagSpaceValueForm() throws Exception {
+    writeBasicIntFlag();
+
+    OptionsParsingResult result = parseStarlarkOptions("--//test:my_int_setting 666");
+
+    assertThat(result.getStarlarkOptions()).hasSize(1);
+    assertThat(result.getStarlarkOptions().get("//test:my_int_setting")).isEqualTo(666);
+    assertThat(result.getResidue()).isEmpty();
+  }
+
+  // test --fake_flag=value
+  @Test
+  public void testBadFlag_equalsForm() throws Exception {
+    scratch.file("test/BUILD");
+    reporter.removeHandler(failFastHandler);
+
+    OptionsParsingException e =
+        assertThrows(
+            OptionsParsingException.class,
+            () -> parseStarlarkOptions("--//fake_flag=blahblahblah"));
+
+    assertThat(e).hasMessageThat().contains("Error loading option //fake_flag");
+  }
+
+  // test --fake_flag value
+  @Test
+  public void testBadFlag_spaceForm() throws Exception {
+    scratch.file("test/BUILD");
+    reporter.removeHandler(failFastHandler);
+
+    OptionsParsingException e =
+        assertThrows(
+            OptionsParsingException.class,
+            () -> parseStarlarkOptions("--//fake_flag blahblahblah"));
+
+    assertThat(e).hasMessageThat().contains("Error loading option //fake_flag");
+  }
+
+  // test --fake_flag
+  @Test
+  public void testBadFlag_boolForm() throws Exception {
+    scratch.file("test/BUILD");
+    reporter.removeHandler(failFastHandler);
+
+    OptionsParsingException e =
+        assertThrows(OptionsParsingException.class, () -> parseStarlarkOptions("--//fake_flag"));
+
+    assertThat(e).hasMessageThat().contains("Error loading option //fake_flag");
+  }
+
+  // test -flag=value (Note - there's currently no way in real life to allow single dash long form
+  // options.)
+  @Test
+  public void testSingleDash_notAllowed() throws Exception {
+    optionsParser.setAllowSingleDashLongOptions(false);
+
+    writeBasicIntFlag();
+
+    OptionsParsingResult result = parseStarlarkOptions("-//test:my_int_setting=666");
+
+    assertThat(result.getStarlarkOptions()).isEmpty();
+    assertThat(result.getResidue()).containsExactly("-//test:my_int_setting=666");
+  }
+
+  // test --non_flag_setting=value
+  @Test
+  public void testNonFlagParsing() throws Exception {
+    setSkylarkSemanticsOptions("--experimental_build_setting_api=True");
+
+    scratch.file(
+        "test/build_setting.bzl",
+        "def _build_setting_impl(ctx):",
+        "  return []",
+        "int_flag = rule(",
+        "  implementation = _build_setting_impl,",
+        "  build_setting = config.int(flag=False)",
+        ")");
+    scratch.file(
+        "test/BUILD",
+        "load('//test:build_setting.bzl', 'int_flag')",
+        "int_flag(name = 'my_int_setting', build_setting_default = 42)");
+
+    OptionsParsingException e =
+        assertThrows(
+            OptionsParsingException.class,
+            () -> parseStarlarkOptions("--//test:my_int_setting=666"));
+
+    assertThat(e).hasMessageThat().isEqualTo("Unrecognized option: //test:my_int_setting=666");
+  }
+
+  private void writeBasicBoolFlag() throws Exception {
+    writeBuildSetting("bool", "True", true);
+  }
+
+  // test --bool_flag
+  @Test
+  public void testBooleanFlag() throws Exception {
+    writeBasicBoolFlag();
+
+    OptionsParsingResult result = parseStarlarkOptions("--//test:my_bool_setting");
+
+    assertThat(result.getStarlarkOptions()).hasSize(1);
+    assertThat(result.getStarlarkOptions().get("//test:my_bool_setting")).isEqualTo(true);
+    assertThat(result.getResidue()).isEmpty();
+  }
+
+  // test --nobool_flag
+  @Test
+  public void testNoPrefixedBooleanFlag() throws Exception {
+    writeBasicBoolFlag();
+
+    OptionsParsingResult result = parseStarlarkOptions("--no//test:my_bool_setting");
+
+    assertThat(result.getStarlarkOptions()).hasSize(1);
+    assertThat(result.getStarlarkOptions().get("//test:my_bool_setting")).isEqualTo(false);
+    assertThat(result.getResidue()).isEmpty();
+  }
+
+  // test --noint_flag
+  @Test
+  public void testNoPrefixedNonBooleanFlag() throws Exception {
+    writeBasicIntFlag();
+
+    OptionsParsingException e =
+        assertThrows(
+            OptionsParsingException.class, () -> parseStarlarkOptions("--no//test:my_int_setting"));
+
+    assertThat(e)
+        .hasMessageThat()
+        .isEqualTo("Illegal use of 'no' prefix on non-boolean option: //test:my_int_setting");
+  }
+
+  // test --int_flag
+  @Test
+  public void testFlagWithoutValue() throws Exception {
+    writeBasicIntFlag();
+
+    OptionsParsingException e =
+        assertThrows(
+            OptionsParsingException.class, () -> parseStarlarkOptions("--//test:my_int_setting"));
+
+    assertThat(e).hasMessageThat().isEqualTo("Expected value after --//test:my_int_setting");
+  }
+
+  // test --flag --flag
+  @Test
+  public void testRepeatFlagLastOneWins() throws Exception {
+    writeBasicIntFlag();
+
+    OptionsParsingResult result =
+        parseStarlarkOptions("--//test:my_int_setting=4 --//test:my_int_setting=7");
+
+    assertThat(result.getStarlarkOptions()).hasSize(1);
+    assertThat(result.getStarlarkOptions().get("//test:my_int_setting")).isEqualTo(7);
+    assertThat(result.getResidue()).isEmpty();
+  }
+
+  // test --flagA=valueA --flagB=valueB
+  @Test
+  public void testMultipleFlags() throws Exception {
+    setSkylarkSemanticsOptions("--experimental_build_setting_api=True");
+
+    scratch.file(
+        "test/build_setting.bzl",
+        "def _build_setting_impl(ctx):",
+        "  return []",
+        "int_flag = rule(",
+        "  implementation = _build_setting_impl,",
+        "  build_setting = config.int(flag=True)",
+        ")");
+    scratch.file(
+        "test/BUILD",
+        "load('//test:build_setting.bzl', 'int_flag')",
+        "int_flag(name = 'my_int_setting', build_setting_default = 42)",
+        "int_flag(name = 'my_other_int_setting', build_setting_default = 77)");
+
+    OptionsParsingResult result =
+        parseStarlarkOptions("--//test:my_int_setting=0 --//test:my_other_int_setting=0");
+
+    assertThat(result.getResidue()).isEmpty();
+    assertThat(result.getStarlarkOptions()).hasSize(2);
+    assertThat(result.getStarlarkOptions().get("//test:my_int_setting")).isEqualTo(0);
+    assertThat(result.getStarlarkOptions().get("//test:my_other_int_setting")).isEqualTo(0);
+  }
+
+  // test --non_build_setting
+  @Test
+  public void testNonBuildSetting() throws Exception {
+    scratch.file(
+        "test/rules.bzl",
+        "def _impl(ctx):",
+        "  return []",
+        "my_rule = rule(",
+        "  implementation = _impl,",
+        ")");
+    scratch.file("test/BUILD", "load('//test:rules.bzl', 'my_rule')", "my_rule(name = 'my_rule')");
+    OptionsParsingException e =
+        assertThrows(OptionsParsingException.class, () -> parseStarlarkOptions("--//test:my_rule"));
+    assertThat(e).hasMessageThat().isEqualTo("Unrecognized option: //test:my_rule");
+  }
+
+  // test --non_rule_configured_target
+  @Test
+  public void testNonRuleConfiguredTarget() throws Exception {
+    scratch.file(
+        "test/BUILD",
+        "genrule(",
+        "  name = 'my_gen',",
+        "  srcs = ['x.in'],",
+        "  outs = ['x.cc'],",
+        "  cmd = '$(locations :tool) $< >$@',",
+        "  tools = [':tool'],",
+        ")",
+        "cc_library(name = 'tool-dep')");
+    OptionsParsingException e =
+        assertThrows(OptionsParsingException.class, () -> parseStarlarkOptions("--//test:x.in"));
+    assertThat(e).hasMessageThat().isEqualTo("Unrecognized option: //test:x.in");
+  }
+
+  // test --int_flag=non_int_value
+  @Test
+  public void testWrongValueType_int() throws Exception {
+    writeBasicIntFlag();
+
+    OptionsParsingException e =
+        assertThrows(
+            OptionsParsingException.class,
+            () -> parseStarlarkOptions("--//test:my_int_setting=woohoo"));
+
+    assertThat(e)
+        .hasMessageThat()
+        .isEqualTo("While parsing option //test:my_int_setting=woohoo: 'woohoo' is not a int");
+  }
+
+  // test --bool_flag=non_bool_value
+  @Test
+  public void testWrongValueType_bool() throws Exception {
+    writeBasicBoolFlag();
+
+    OptionsParsingException e =
+        assertThrows(
+            OptionsParsingException.class,
+            () -> parseStarlarkOptions("--//test:my_bool_setting=woohoo"));
+
+    assertThat(e)
+        .hasMessageThat()
+        .isEqualTo("While parsing option //test:my_bool_setting=woohoo: 'woohoo' is not a boolean");
+  }
+}