diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunction.java
index e2cdeef..43b52ee 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunction.java
@@ -161,6 +161,10 @@
       return new AutoValue_ToolchainResolutionFunction_ToolchainType(
           toolchainTypeRequirement, toolchainTypeInfo);
     }
+
+    public boolean mandatory() {
+      return toolchainTypeRequirement().mandatory();
+    }
   }
 
   /**
@@ -428,44 +432,40 @@
     // Determine the potential set of toolchains.
     Table<ConfiguredTargetKey, ToolchainTypeInfo, Label> resolvedToolchains =
         HashBasedTable.create();
-    ImmutableSet.Builder<ToolchainTypeInfo> requiredToolchainTypesBuilder = ImmutableSet.builder();
-    List<Label> missingToolchains = new ArrayList<>();
+    List<Label> missingMandatoryToolchains = new ArrayList<>();
     for (SingleToolchainResolutionKey key : registeredToolchainKeys) {
       SingleToolchainResolutionValue singleToolchainResolutionValue =
           (SingleToolchainResolutionValue)
               results.getOrThrow(key, InvalidToolchainLabelException.class);
-        if (singleToolchainResolutionValue == null) {
-          valuesMissing = true;
-          continue;
-        }
+      if (singleToolchainResolutionValue == null) {
+        valuesMissing = true;
+        continue;
+      }
 
-      if (singleToolchainResolutionValue.availableToolchainLabels().isEmpty()) {
-        // Save the missing type and continue looping to check for more.
-        // TODO(katre): Handle mandatory/optional.
-        missingToolchains.add(key.toolchainType().toolchainType());
-      } else {
+      if (!singleToolchainResolutionValue.availableToolchainLabels().isEmpty()) {
         ToolchainTypeInfo requiredToolchainType = singleToolchainResolutionValue.toolchainType();
-        requiredToolchainTypesBuilder.add(requiredToolchainType);
         resolvedToolchains.putAll(
             findPlatformsAndLabels(requiredToolchainType, singleToolchainResolutionValue));
+      } else if (key.toolchainType().mandatory()) {
+        // Save the missing type and continue looping to check for more.
+        missingMandatoryToolchains.add(key.toolchainType().toolchainType());
       }
+      // TODO(katre): track missing optional toolchains?
     }
 
-    if (!missingToolchains.isEmpty()) {
-      throw new UnresolvedToolchainsException(missingToolchains);
+    // Verify that all mandatory toolchain types have a toolchain.
+    if (!missingMandatoryToolchains.isEmpty()) {
+      throw new UnresolvedToolchainsException(missingMandatoryToolchains);
     }
 
     if (valuesMissing) {
       throw new ValueMissingException();
     }
 
-    ImmutableSet<ToolchainTypeInfo> requiredToolchainTypes = requiredToolchainTypesBuilder.build();
-
-    // Find and return the first execution platform which has all required toolchains.
-    // TODO(katre): Handle mandatory/optional.
+    // Find and return the first execution platform which has all mandatory toolchains.
     Optional<ConfiguredTargetKey> selectedExecutionPlatformKey =
         findExecutionPlatformForToolchains(
-            requiredToolchainTypes,
+            toolchainTypes,
             forcedExecutionPlatform,
             platformKeys.executionPlatformKeys(),
             resolvedToolchains);
@@ -520,43 +520,43 @@
    * resolvedToolchains} and has all required toolchain types.
    */
   private static Optional<ConfiguredTargetKey> findExecutionPlatformForToolchains(
-      ImmutableSet<ToolchainTypeInfo> requiredToolchainTypes,
+      ImmutableSet<ToolchainType> toolchainTypes,
       Optional<ConfiguredTargetKey> forcedExecutionPlatform,
       ImmutableList<ConfiguredTargetKey> availableExecutionPlatformKeys,
       Table<ConfiguredTargetKey, ToolchainTypeInfo, Label> resolvedToolchains) {
 
     if (forcedExecutionPlatform.isPresent()) {
       // Is the forced platform suitable?
-      if (isPlatformSuitable(
-          forcedExecutionPlatform.get(), requiredToolchainTypes, resolvedToolchains)) {
+      if (isPlatformSuitable(forcedExecutionPlatform.get(), toolchainTypes, resolvedToolchains)) {
         return forcedExecutionPlatform;
       }
     }
 
+    // Choose the first execution platform that has all mandatory toolchains.
     return availableExecutionPlatformKeys.stream()
-        .filter(epk -> isPlatformSuitable(epk, requiredToolchainTypes, resolvedToolchains))
+        .filter(epk -> isPlatformSuitable(epk, toolchainTypes, resolvedToolchains))
         .findFirst();
   }
 
   private static boolean isPlatformSuitable(
       ConfiguredTargetKey executionPlatformKey,
-      ImmutableSet<ToolchainTypeInfo> requiredToolchainTypes,
+      ImmutableSet<ToolchainType> toolchainTypes,
       Table<ConfiguredTargetKey, ToolchainTypeInfo, Label> resolvedToolchains) {
-    if (requiredToolchainTypes.isEmpty()) {
+    if (toolchainTypes.isEmpty()) {
       // Since there aren't any toolchains, we should be able to use any execution platform that
       // has made it this far.
       return true;
     }
 
-    if (!resolvedToolchains.containsRow(executionPlatformKey)) {
-      return false;
-    }
-
-    // Unless all toolchains are present, ignore this execution platform.
+    // Determine whether all mandatory toolchains are present.
     return resolvedToolchains
         .row(executionPlatformKey)
         .keySet()
-        .containsAll(requiredToolchainTypes);
+        .containsAll(
+            toolchainTypes.stream()
+                .filter(ToolchainType::mandatory)
+                .map(ToolchainType::toolchainTypeInfo)
+                .collect(toImmutableSet()));
   }
 
   private static final class ValueMissingException extends Exception {
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunctionTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunctionTest.java
index e6b7981..6a84433 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunctionTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/ToolchainResolutionFunctionTest.java
@@ -19,6 +19,7 @@
 
 import com.google.common.collect.ImmutableList;
 import com.google.devtools.build.lib.analysis.config.ToolchainTypeRequirement;
+import com.google.devtools.build.lib.analysis.platform.ToolchainTypeInfo;
 import com.google.devtools.build.lib.cmdline.Label;
 import com.google.devtools.build.lib.rules.platform.ToolchainTestCase;
 import com.google.devtools.build.lib.skyframe.ConstraintValueLookupUtil.InvalidConstraintValueException;
@@ -86,6 +87,92 @@
     assertThat(unloadedToolchainContext).hasTargetPlatform("//platforms:linux");
   }
 
+  // TODO(katre): Add further tests for optional/mandatory/mixed toolchains.
+
+  @Test
+  public void resolve_optional() throws Exception {
+    // This should select platform mac, toolchain extra_toolchain_mac, because platform
+    // mac is listed first.
+    addToolchain(
+        "extra",
+        "extra_toolchain_linux",
+        ImmutableList.of("//constraints:linux"),
+        ImmutableList.of("//constraints:linux"),
+        "baz");
+    addToolchain(
+        "extra",
+        "extra_toolchain_mac",
+        ImmutableList.of("//constraints:mac"),
+        ImmutableList.of("//constraints:linux"),
+        "baz");
+    rewriteWorkspace(
+        "register_toolchains('//extra:extra_toolchain_linux', '//extra:extra_toolchain_mac')",
+        "register_execution_platforms('//platforms:mac', '//platforms:linux')");
+
+    useConfiguration("--platforms=//platforms:linux");
+    ToolchainContextKey key =
+        ToolchainContextKey.key()
+            .configurationKey(targetConfigKey)
+            .toolchainTypes(testToolchainType)
+            .build();
+
+    EvaluationResult<UnloadedToolchainContext> result = invokeToolchainResolution(key);
+
+    assertThatEvaluationResult(result).hasNoError();
+    UnloadedToolchainContext unloadedToolchainContext = result.get(key);
+    assertThat(unloadedToolchainContext).isNotNull();
+
+    assertThat(unloadedToolchainContext).hasToolchainType(testToolchainTypeLabel);
+    assertThat(unloadedToolchainContext).hasResolvedToolchain("//extra:extra_toolchain_mac_impl");
+    assertThat(unloadedToolchainContext).hasExecutionPlatform("//platforms:mac");
+    assertThat(unloadedToolchainContext).hasTargetPlatform("//platforms:linux");
+  }
+
+  @Test
+  public void resolve_multiple() throws Exception {
+    Label secondToolchainTypeLabel = Label.parseAbsoluteUnchecked("//second:toolchain_type");
+    ToolchainTypeRequirement secondToolchainTypeRequirement =
+        ToolchainTypeRequirement.create(secondToolchainTypeLabel);
+    ToolchainTypeInfo secondToolchainTypeInfo = ToolchainTypeInfo.create(secondToolchainTypeLabel);
+    scratch.file("second/BUILD", "toolchain_type(name = 'toolchain_type')");
+
+    addToolchain(
+        "main",
+        "main_toolchain_linux",
+        ImmutableList.of("//constraints:linux"),
+        ImmutableList.of("//constraints:linux"),
+        "baz");
+    addToolchain(
+        "main",
+        "second_toolchain_linux",
+        secondToolchainTypeLabel,
+        ImmutableList.of("//constraints:linux"),
+        ImmutableList.of("//constraints:linux"),
+        "baz");
+    rewriteWorkspace(
+        "register_toolchains('//main:all',)", "register_execution_platforms('//platforms:linux')");
+
+    useConfiguration("--platforms=//platforms:linux");
+    ToolchainContextKey key =
+        ToolchainContextKey.key()
+            .configurationKey(targetConfigKey)
+            .toolchainTypes(testToolchainType, secondToolchainTypeRequirement)
+            .build();
+
+    EvaluationResult<UnloadedToolchainContext> result = invokeToolchainResolution(key);
+
+    assertThatEvaluationResult(result).hasNoError();
+    UnloadedToolchainContext unloadedToolchainContext = result.get(key);
+    assertThat(unloadedToolchainContext).isNotNull();
+
+    assertThat(unloadedToolchainContext).hasToolchainType(testToolchainTypeLabel);
+    assertThat(unloadedToolchainContext).hasResolvedToolchain("//main:main_toolchain_linux_impl");
+    assertThat(unloadedToolchainContext).hasToolchainType(secondToolchainTypeLabel);
+    assertThat(unloadedToolchainContext).hasResolvedToolchain("//main:second_toolchain_linux_impl");
+    assertThat(unloadedToolchainContext).hasExecutionPlatform("//platforms:linux");
+    assertThat(unloadedToolchainContext).hasTargetPlatform("//platforms:linux");
+  }
+
   @Test
   public void resolve_mandatory_missing() throws Exception {
     // There is no toolchain for the requested type.
@@ -106,6 +193,91 @@
   }
 
   @Test
+  public void resolve_multiple_optional() throws Exception {
+    Label secondToolchainTypeLabel = Label.parseAbsoluteUnchecked("//second:toolchain_type");
+    ToolchainTypeRequirement secondToolchainTypeRequirement =
+        ToolchainTypeRequirement.builder(secondToolchainTypeLabel).mandatory(false).build();
+    ToolchainTypeInfo secondToolchainTypeInfo = ToolchainTypeInfo.create(secondToolchainTypeLabel);
+    scratch.file("second/BUILD", "toolchain_type(name = 'toolchain_type')");
+
+    addToolchain(
+        "main",
+        "main_toolchain_linux",
+        ImmutableList.of("//constraints:linux"),
+        ImmutableList.of("//constraints:linux"),
+        "baz");
+    addToolchain(
+        "main",
+        "second_toolchain_linux",
+        secondToolchainTypeLabel,
+        ImmutableList.of("//constraints:linux"),
+        ImmutableList.of("//constraints:linux"),
+        "baz");
+    rewriteWorkspace(
+        "register_toolchains('//main:all',)", "register_execution_platforms('//platforms:linux')");
+
+    useConfiguration("--platforms=//platforms:linux");
+    ToolchainContextKey key =
+        ToolchainContextKey.key()
+            .configurationKey(targetConfigKey)
+            .toolchainTypes(testToolchainType, secondToolchainTypeRequirement)
+            .build();
+
+    EvaluationResult<UnloadedToolchainContext> result = invokeToolchainResolution(key);
+
+    assertThatEvaluationResult(result).hasNoError();
+    UnloadedToolchainContext unloadedToolchainContext = result.get(key);
+    assertThat(unloadedToolchainContext).isNotNull();
+
+    assertThat(unloadedToolchainContext).hasToolchainType(testToolchainTypeLabel);
+    assertThat(unloadedToolchainContext).hasResolvedToolchain("//main:main_toolchain_linux_impl");
+    assertThat(unloadedToolchainContext).hasToolchainType(secondToolchainTypeLabel);
+    assertThat(unloadedToolchainContext).hasResolvedToolchain("//main:second_toolchain_linux_impl");
+    assertThat(unloadedToolchainContext).hasExecutionPlatform("//platforms:linux");
+    assertThat(unloadedToolchainContext).hasTargetPlatform("//platforms:linux");
+  }
+
+  @Test
+  public void resolve_multiple_optional_missing() throws Exception {
+    Label secondToolchainTypeLabel = Label.parseAbsoluteUnchecked("//second:toolchain_type");
+    ToolchainTypeRequirement secondToolchainTypeRequirement =
+        ToolchainTypeRequirement.builder(secondToolchainTypeLabel).mandatory(false).build();
+    ToolchainTypeInfo secondToolchainTypeInfo = ToolchainTypeInfo.create(secondToolchainTypeLabel);
+    scratch.file("second/BUILD", "toolchain_type(name = 'toolchain_type')");
+
+    addToolchain(
+        "main",
+        "main_toolchain_linux",
+        ImmutableList.of("//constraints:linux"),
+        ImmutableList.of("//constraints:linux"),
+        "baz");
+    rewriteWorkspace(
+        "register_toolchains('//main:all',)", "register_execution_platforms('//platforms:linux')");
+
+    useConfiguration("--platforms=//platforms:linux");
+    ToolchainContextKey key =
+        ToolchainContextKey.key()
+            .configurationKey(targetConfigKey)
+            .toolchainTypes(testToolchainType, secondToolchainTypeRequirement)
+            .build();
+
+    EvaluationResult<UnloadedToolchainContext> result = invokeToolchainResolution(key);
+
+    assertThatEvaluationResult(result).hasNoError();
+    UnloadedToolchainContext unloadedToolchainContext = result.get(key);
+    assertThat(unloadedToolchainContext).isNotNull();
+
+    assertThat(unloadedToolchainContext).hasToolchainType(testToolchainTypeLabel);
+    assertThat(unloadedToolchainContext).hasResolvedToolchain("//main:main_toolchain_linux_impl");
+    assertThat(unloadedToolchainContext).hasToolchainType(secondToolchainTypeLabel);
+    assertThat(unloadedToolchainContext)
+        .resolvedToolchainLabels()
+        .doesNotContain(Label.parseAbsoluteUnchecked("//main:second_toolchain_linux_impl"));
+    assertThat(unloadedToolchainContext).hasExecutionPlatform("//platforms:linux");
+    assertThat(unloadedToolchainContext).hasTargetPlatform("//platforms:linux");
+  }
+
+  @Test
   public void resolve_toolchainTypeAlias() throws Exception {
     addToolchain(
         "extra",
@@ -221,6 +393,29 @@
   }
 
   @Test
+  public void resolve_optional_unavailableToolchainType_single() throws Exception {
+    reporter.removeHandler(failFastHandler);
+    scratch.file("fake/toolchain/BUILD", "");
+    useConfiguration("--host_platform=//platforms:linux", "--platforms=//platforms:linux");
+    ToolchainContextKey key =
+        ToolchainContextKey.key()
+            .configurationKey(targetConfigKey)
+            .toolchainTypes(optionalToolchainType)
+            .build();
+
+    EvaluationResult<UnloadedToolchainContext> result = invokeToolchainResolution(key);
+
+    assertThatEvaluationResult(result).hasNoError();
+    UnloadedToolchainContext unloadedToolchainContext = result.get(key);
+    assertThat(unloadedToolchainContext).isNotNull();
+
+    assertThat(unloadedToolchainContext).hasToolchainType(optionalToolchainTypeLabel);
+    assertThat(unloadedToolchainContext).resolvedToolchainLabels().isEmpty();
+    assertThat(unloadedToolchainContext).hasExecutionPlatform("//platforms:linux");
+    assertThat(unloadedToolchainContext).hasTargetPlatform("//platforms:linux");
+  }
+
+  @Test
   public void resolve_unavailableToolchainType_multiple() throws Exception {
     reporter.removeHandler(failFastHandler);
     scratch.file("fake/toolchain/BUILD", "");
diff --git a/src/test/shell/integration/toolchain_test.sh b/src/test/shell/integration/toolchain_test.sh
index 3585045..24f3307 100755
--- a/src/test/shell/integration/toolchain_test.sh
+++ b/src/test/shell/integration/toolchain_test.sh
@@ -150,6 +150,8 @@
 function write_register_toolchain() {
   local pkg="${1}"
   local toolchain_name="${2:-test_toolchain}"
+  local exec_compatible_with="${3:-"[]"}"
+  local target_compatible_with="${4:-"[]"}"
 
   cat >> WORKSPACE <<EOF
 register_toolchains('//register/${pkg}:${toolchain_name}_1')
@@ -171,8 +173,8 @@
 toolchain(
     name = '${toolchain_name}_1',
     toolchain_type = '//${pkg}/toolchain:${toolchain_name}',
-    exec_compatible_with = [],
-    target_compatible_with = [],
+    exec_compatible_with = ${exec_compatible_with},
+    target_compatible_with = ${target_compatible_with},
     toolchain = ':${toolchain_name}_impl_1',
     visibility = ['//visibility:public'])
 EOF
@@ -484,6 +486,50 @@
   expect_log 'Using toolchain: rule message: "this is the rule", toolchain 1 extra_str: "foo from test_toolchain_1", toolchain 2 extra_str: "foo from test_toolchain_2"'
 }
 
+function test_multiple_toolchain_use_in_rule_with_optional_missing {
+  local -r pkg="${FUNCNAME[0]}"
+  write_test_toolchain "${pkg}" test_toolchain_1
+  write_test_toolchain "${pkg}" test_toolchain_2
+
+  write_register_toolchain "${pkg}" test_toolchain_1
+
+  # The rule uses two separate toolchains.
+  mkdir -p "${pkg}/toolchain"
+  cat > "${pkg}/toolchain/rule_use_toolchains.bzl" <<EOF
+def _impl(ctx):
+  toolchain_1 = ctx.toolchains['//${pkg}/toolchain:test_toolchain_1']
+  toolchain_2 = ctx.toolchains['//${pkg}/toolchain:test_toolchain_2']
+  message = ctx.attr.message
+  print(
+      'Using toolchain: rule message: "%s", toolchain 1 extra_str: "%s", toolchain 2 is none: %s' %
+         (message, toolchain_1.extra_str, toolchain_2 == None))
+  return []
+
+use_toolchains = rule(
+    implementation = _impl,
+    attrs = {
+        'message': attr.string(),
+    },
+    toolchains = [
+        '//${pkg}/toolchain:test_toolchain_1',
+        config_common.toolchain_type('//${pkg}/toolchain:test_toolchain_2', mandatory = False),
+    ],
+)
+EOF
+
+  mkdir -p "${pkg}/demo"
+  cat > "${pkg}/demo/BUILD" <<EOF
+load('//${pkg}/toolchain:rule_use_toolchains.bzl', 'use_toolchains')
+# Use the toolchain.
+use_toolchains(
+    name = 'use',
+    message = 'this is the rule')
+EOF
+
+  bazel build "//${pkg}/demo:use" &> $TEST_log || fail "Build failed"
+  expect_log 'Using toolchain: rule message: "this is the rule", toolchain 1 extra_str: "foo from test_toolchain_1", toolchain 2 is none: True'
+}
+
 function test_multiple_toolchain_use_in_rule_one_missing {
   local -r pkg="${FUNCNAME[0]}"
   write_test_toolchain "${pkg}" test_toolchain_1
@@ -2377,6 +2423,146 @@
   expect_log "foo_tool = <target @rules_foo//foo_tools:foo_tool>"
 }
 
+function test_exec_platform_order_with_mandatory_toolchains {
+  local -r pkg="${FUNCNAME[0]}"
+
+  # Add two possible execution platforms.
+  mkdir -p "${pkg}/platforms"
+  cat > "${pkg}/platforms/BUILD" <<EOF
+package(default_visibility = ['//visibility:public'])
+constraint_setting(name = 'setting')
+constraint_value(name = 'value1', constraint_setting = ':setting')
+constraint_value(name = 'value2', constraint_setting = ':setting')
+
+platform(
+    name = 'platform1',
+    constraint_values = [':value1'],
+    visibility = ['//visibility:public'])
+platform(
+    name = 'platform2',
+    constraint_values = [':value2'],
+    visibility = ['//visibility:public'])
+EOF
+  # Register them in order.
+  cat >> WORKSPACE <<EOF
+register_execution_platforms("//${pkg}/platforms:platform1", "//${pkg}/platforms:platform2")
+EOF
+
+  # Create a toolchain that only works with platform2
+  write_test_toolchain "${pkg}" test_toolchain
+  write_register_toolchain "${pkg}" test_toolchain "['//${pkg}/platforms:value2']"
+
+  # The rule must receive the toolchain.
+  mkdir -p "${pkg}/toolchain"
+  cat > "${pkg}/toolchain/rule_use_toolchains.bzl" <<EOF
+def _impl(ctx):
+  toolchain = ctx.toolchains['//${pkg}/toolchain:test_toolchain']
+  message = ctx.attr.message
+  print(
+      'Using toolchain: rule message: "%s", toolchain is none: %s' %
+         (message, toolchain == None))
+  return []
+
+use_toolchains = rule(
+    implementation = _impl,
+    attrs = {
+        'message': attr.string(),
+    },
+    toolchains = [
+        config_common.toolchain_type('//${pkg}/toolchain:test_toolchain', mandatory = True),
+    ],
+)
+EOF
+
+  mkdir -p "${pkg}/demo"
+  cat > "${pkg}/demo/BUILD" <<EOF
+load('//${pkg}/toolchain:rule_use_toolchains.bzl', 'use_toolchains')
+# Use the toolchain.
+use_toolchains(
+    name = 'use',
+    message = 'this is the rule')
+EOF
+
+  bazel build "//${pkg}/demo:use" &> $TEST_log || fail "Build failed"
+  bazel build \
+    --toolchain_resolution_debug=.* \
+    "//${pkg}/demo:use" &> $TEST_log || fail "Build failed"
+  # Verify that a toolchain was provided.
+  expect_log 'Using toolchain: rule message: "this is the rule", toolchain is none: False'
+  # Verify that the exec platform is platform2.
+  expect_log "Selected execution platform //${pkg}/platforms:platform2"
+}
+
+function test_exec_platform_order_with_optional_toolchains {
+  local -r pkg="${FUNCNAME[0]}"
+
+  # Add two possible execution platforms.
+  mkdir -p "${pkg}/platforms"
+  cat > "${pkg}/platforms/BUILD" <<EOF
+package(default_visibility = ['//visibility:public'])
+constraint_setting(name = 'setting')
+constraint_value(name = 'value1', constraint_setting = ':setting')
+constraint_value(name = 'value2', constraint_setting = ':setting')
+
+platform(
+    name = 'platform1',
+    constraint_values = [':value1'],
+    visibility = ['//visibility:public'])
+platform(
+    name = 'platform2',
+    constraint_values = [':value2'],
+    visibility = ['//visibility:public'])
+EOF
+  # Register them in order.
+  cat >> WORKSPACE <<EOF
+register_execution_platforms("//${pkg}/platforms:platform1", "//${pkg}/platforms:platform2")
+EOF
+
+  # Create a toolchain that only works with platform2
+  write_test_toolchain "${pkg}" test_toolchain
+  write_register_toolchain "${pkg}" test_toolchain "['//${pkg}/platforms:value2']"
+
+  # The rule can optionally use the toolchain.
+  mkdir -p "${pkg}/toolchain"
+  cat > "${pkg}/toolchain/rule_use_toolchains.bzl" <<EOF
+def _impl(ctx):
+  toolchain = ctx.toolchains['//${pkg}/toolchain:test_toolchain']
+  message = ctx.attr.message
+  print(
+      'Using toolchain: rule message: "%s", toolchain is none: %s' %
+         (message, toolchain == None))
+  return []
+
+use_toolchains = rule(
+    implementation = _impl,
+    attrs = {
+        'message': attr.string(),
+    },
+    toolchains = [
+        config_common.toolchain_type('//${pkg}/toolchain:test_toolchain', mandatory = False),
+    ],
+)
+EOF
+
+  mkdir -p "${pkg}/demo"
+  cat > "${pkg}/demo/BUILD" <<EOF
+load('//${pkg}/toolchain:rule_use_toolchains.bzl', 'use_toolchains')
+# Use the toolchain.
+use_toolchains(
+    name = 'use',
+    message = 'this is the rule')
+EOF
+
+  bazel build "//${pkg}/demo:use" &> $TEST_log || fail "Build failed"
+  bazel build \
+    --toolchain_resolution_debug=.* \
+    "//${pkg}/demo:use" &> $TEST_log || fail "Build failed"
+  # Verify that no toolchain was provided.
+  expect_log 'Using toolchain: rule message: "this is the rule", toolchain is none: True'
+  # Verify that the exec platform is platform1.
+  expect_log "Selected execution platform //${pkg}/platforms:platform1"
+}
+
 # TODO(katre): Test using toolchain-provided make variables from a genrule.
 
 run_suite "toolchain tests"