assertThat(base.resolve("")).isEqualTo(parse("http://host/a/b"))
    assertThat(base.resolve("\\path")).isEqualTo(parse("http://host/path"))
  }

  @Test
  fun resolveUnsupportedScheme() {
    val base = parse("http://a/")
    assertThat(base.resolve("ftp://b")).isNull()
    assertThat(base.resolve("ht+tp://b")).isNull()
    assertThat(base.resolve("ht-tp://b")).isNull()
    assertThat(base.resolve("ht.tp://b")).isNull()

# Make Bazel not try to probe the host system for a C++ toolchain.
build:rbe_base --config=resultstore
build:rbe_base --repo_env=BAZEL_DO_NOT_DETECT_CPP_TOOLCHAIN=1
build:rbe_base --define=EXECUTOR=remote
build:rbe_base --jobs=800
build:rbe_base --remote_executor=grpcs://remotebuildexecution.googleapis.com
build:rbe_base --remote_timeout=3600
build:rbe_base --spawn_strategy=remote,worker,standalone,local

    private boolean isValidProfileId(String id) {
        switch (id.charAt(0)) { // avoid first character that has special CLI meaning in "mvn -P xxx"
            case '+': // activate
            case '-': // deactivate
            case '!': // deactivate
            case '?': // optional
                return false;
            default:
        }
        return true;
    }

					"messaging",
					"snapshots",
					"base-services"
				]
			},
			{
				"parallelizationMethod":{
					"name":"TeamCityParallelTests",
					"numberOfBatches":1
				},
				"subprojects":[
					"build-init",
					"publish",
					"plugins-java-base",
					"plugins-test-report-aggregation",
					"problems-api",
					"testing-base"
				]
			},
			{

                    message.append(parentId).append(" -> ");
                }
                message.append(parentData.id());

                problems.add(Severity.FATAL, ModelProblem.Version.BASE, message.toString());

                throw problems.newModelBuilderException();
            } else {
                currentData = parentData;
            }
        }

  }

  @Test
  @TestMetadata("postfixUnaryOperatorOnVar_base.kt")
  public void testPostfixUnaryOperatorOnVar_base() {
    runTest("analysis/analysis-api/testData/components/callResolver/resolveCall/postfixUnaryOperatorOnVar_base.kt");
  }

  @Test
  @TestMetadata("postfixUnaryOperatorWithArrayAccessConvention.kt")

        this.encodedUsername = base.encodedUsername
        this.encodedPassword = base.encodedPassword
        this.host = base.host
        this.port = base.port
        this.encodedPathSegments.clear()
        this.encodedPathSegments.addAll(base.encodedPathSegments)
        if (pos == limit || input[pos] == '#') {
          encodedQuery(base.encodedQuery)
        }
      }

package com.google.common.reflect;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import static java.util.Objects.requireNonNull;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Joiner;
import com.google.common.base.Predicate;
import com.google.common.collect.FluentIterable;

    TypeToken<?> unused = supertype.getSubtype(subtype.getRawType());
  }

  public void testGetSubtype_baseClassWithNoTypeArgs() {
    class SingleGenericExtendsBase<T> extends Base {}
    TypeToken<Base> supertype = new TypeToken<Base>() {};
    TypeToken<SingleGenericExtendsBase<String>> subtype =
        new TypeToken<SingleGenericExtendsBase<String>>() {};
    assertTrue(subtype.isSubtypeOf(supertype));

    /**
     * Assuming that all scopes in this List<FirScope> and [base] are surrounding [from], returns whether an element of
     * this List<FirScope> is closer than [base] based on the distance from [from].
     */
    private fun List<FirScope>.hasScopeCloserThan(base: FirScope, from: KtElement) = any { scope ->
        if (scope.isScopeForClass() && base.isScopeForClass()) {