def factory = new DefaultProblemDiagnosticsFactory(DefaultFailureFactory.withDefaultClassifier(), locationAnalyzer, userCodeContext, 2)

    def "uses caller's stack trace to calculate problem location"() {
        given:
        def location = Stub(Location)
        def stream = factory.newStream()

        when:
        def diagnostics = stream.forCurrentCaller()

        then:

    AbstractTensorHandlePtr Ones_X(temp_output);

    name = "Add_Log1p_Grad_X";
    // Calculate 1 + Conj(X)
    TF_RETURN_IF_ERROR(
        AddV2(ctx, Ones_X.get(), Conj_X.get(), &temp_output, name.c_str()));

    AbstractTensorHandlePtr Conj_XP1(temp_output);

    name = "Div_Log1p_Grad_X";
    // Calculate U / (1 + Conj(X))
    TF_RETURN_IF_ERROR(

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

class IntegerCalculations {
    def calculate() {
        int a = 9834
        int b = 238923
        int c = a + b
        int d = c - a
        int e = d * c
        int f = e.intdiv(5)
    }

    /**
     * Returns a view of this supplier that will calculate its value as empty if it would be missing.
     * If this supplier already ignores absent results, returns this supplier.
     */
    CollectionSupplier<T, C> absentIgnoring();

    /**
     * Returns a view of this supplier that will calculate its value as empty if it would be missing,

fun calculate() {
    val a = 1
    val b = 2
    val c = 3
    val result = a * <expr>(b + c)</expr> - a
    println(result)

		if err != nil {
			return 0, time.Time{}, fmt.Errorf("unable to calculate ready pods: %s", err)
		}
		replicaCount = int32(math.Ceil(usageRatio * float64(readyPodCount)))
	} else {
		// Scale to zero or n pods depending on usageRatio
		replicaCount = int32(math.Ceil(usageRatio))
	}

	return replicaCount, timestamp, err
}

                location -> fileSystemAccess.readRegularFileContentHash(location.getAbsolutePath())
                    .map(contentHash -> contentCache.get(contentHash, key -> calculator.calculate(location, true))
                ).orElseGet(
                    () -> calculator.calculate(location, false)
                ));
        }

        private void assertStoredIn(IndexedCache<HashCode, V> store) {
            if (this.contentCache != store) {

Could not determine the dependencies of task ':compileJava'.
> Could not resolve all dependencies for configuration ':compileClasspath'.
   > Failed to calculate the value of task ':compileJava' property 'javaCompiler'.
      > Cannot find a Java installation on your machine matching this tasks requirements: {languageVersion=11, vendor=matching('customString'), implementation=vendor-specific} for %OS% on %ARCH%.

Could not determine the dependencies of task ':compileJava'.
> Could not resolve all dependencies for configuration ':compileClasspath'.
   > Failed to calculate the value of task ':compileJava' property 'javaCompiler'.
      > Cannot find a Java installation on your machine matching this tasks requirements: {languageVersion=11, vendor=matching('customString'), implementation=vendor-specific} for %OS% on %ARCH%.

/**
 * Some value that is calculated as part of dependency resolution, but which may have a partial or different value
 * when the execution graph is calculated.
 * @param <T>
 */
public interface ResolutionResultProvider<T> {

    /**
     * Returns the value available at execution graph calculation time. Note that the value may change between when the execution graph is calculated and