ModelResolverException e = assertThrows(
                ModelResolverException.class,
                () -> newModelResolver().resolveModel(session, parent, new AtomicReference<>()),
                "Expected 'ModelResolverException' not thrown.");
        assertNotNull(e.getMessage());
        assertThat(e.getMessage(), containsString("Could not find artifact org.apache:apache:pom:0 in central"));
    }

    @Test

		if fi.VersionID != versions[i].VersionID {
			t.Fatalf("getFileInfoVersions: versions don't match at %d, version id expected %s but got %s", i, fi.VersionID, versions[i].VersionID)
		}
		if fi.NumVersions != len(fivs.Versions) {
			t.Fatalf("getFileInfoVersions: version with %s version id expected to have %d as NumVersions but got %d", fi.VersionID, len(fivs.Versions), fi.NumVersions)
		}
	}

        return result;
    }

    public static TestFailure fromTestAssertionFailure(Throwable failure, String expected, String actual, List<TestFailure> causes) {
        DefaultTestFailureDetails details = new DefaultTestFailureDetails(messageOf(failure), classNameOf(failure), stacktraceOf(failure), true, false, expected, actual, null, null);

	assert.Equal(t, len(want), len(actual))

	got := map[string]*model.WorkloadInstance{}
	for _, instance := range actual {
		got[instance.Name] = instance
	}

	for _, expected := range want {
		assert.Equal(t, expected, got[expected.Name])
	}

	if err := coverage.WriteMetaDir(mangled); err == nil {
		log.Fatal("expected error from WriteMetaDir to nonexistent dir")
	} else {
		got := fmt.Sprintf("%v", err)
		checkWant("meta data", got)
	}

	// Now try to emit counter data file to a bad dir.
	if err := coverage.WriteCountersDir(mangled); err == nil {
		log.Fatal("expected error emitting counter data to bad dir")
	} else {
		got := fmt.Sprintf("%v", err)

      fail();
    } catch (TimeoutException expected) {
    } catch (ExecutionException e) {
      throw new AssertionError(e);
    }
  }

  static void verifyTimedGetOnPendingFuture(Future<?> future) {
    try {
      getUninterruptibly(future, 0, SECONDS);
      fail();
    } catch (TimeoutException expected) {
    } catch (ExecutionException e) {
      throw new AssertionError(e);
    }

    def setup() {
        executer.requireIsolatedDaemons()
        executer.requireDaemon()
    }

    def "Given daemon toolchain version When executing any task Then daemon jvm was set up with expected configuration"() {
        given:
        writeJvmCriteria(Jvm.current())
        captureJavaHome()

        expect:
        succeeds("help")
        assertDaemonUsedJvm(Jvm.current())

			}

			switch {
			case len(test.errShouldContain) == 0:
				if len(errMessageGot) > 0 {
					t.Errorf("Expected no error, but got: %q", errMessageGot)
				}
			default:
				if !strings.Contains(errMessageGot, test.errShouldContain) {
					t.Errorf("Expected error message to contain: %q, but got: %q", test.errShouldContain, errMessageGot)
				}
			}
		})
	}
}

// RUN: tf-opt %s -split-input-file -verify-diagnostics -tf-xla-validate-inputs

// expected-error @+1 {{expects no nested calls of entry functions as they prevent graph traversal in some passes from working correctly}}
func.func @nested_entry_functions() attributes {tf.entry_function = {}} {
  tf_executor.graph {

        received.poll(5, TimeUnit.SECONDS)
    }

    def receiveStdin(String expected) {
        def receivedCommand = receivedCommand()
        assert receivedCommand instanceof ForwardInput
        assert receivedCommand.bytes == expected.bytes
        true
    }

    def receiveUserResponse(String expected) {
        def receivedCommand = receivedCommand()
        assert receivedCommand instanceof UserResponse