}

    @Override
    protected <RESULT extends RelatedQuery> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType) {
        try {
            final RESULT result = entityType.newInstance();
            result.setCreatedBy(DfTypeUtil.toString(source.get("createdBy")));
            result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));
            result.setQueries(toStringArray(source.get("queries")));

	result.ClientConfig = restclient.CopyConfig(server.GenericAPIServer.LoopbackClientConfig)
	result.ClientConfig.QPS = 1000
	result.ClientConfig.Burst = 10000
	result.ServerOpts = s
	result.TearDownFn = func() {
		tearDown()
		etcdClient.Close()
	}
	result.EtcdClient = etcdClient
	result.EtcdStoragePrefix = storageConfig.Prefix

	return result, nil
}

	var output string
	for i := 0; i < retries; i++ {
		result, output, err = pb.runProbe(ctx, probeType, p, pod, status, container, containerID)
		if err == nil {
			return result, output, nil
		}
	}
	return result, output, err
}

                || result.hasVersionRangeViolations()
                || result.hasCircularDependencyExceptions()) {
            return result;
        }

        if (result.getArtifactResolutionNodes() != null) {
            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

            CountDownLatch latch =
                    new CountDownLatch(result.getArtifactResolutionNodes().size());

        return (result[0] == 0) ? this : rebalance();
      } else if (cmp > 0) {
        AvlNode<E> initRight = right;
        if (initRight == null) {
          result[0] = 0;
          return this;
        }

        right = initRight.remove(comparator, e, count, result);

        if (result[0] > 0) {
          if (count >= result[0]) {
            this.distinctElements--;
            this.totalCount -= result[0];

        /**
         * Create a new legacy result representing the result of resolving build dependencies.
         */
        public static LegacyResolverResults buildDependenciesResolved(LegacyVisitedArtifactSet artifacts) {
            return new DefaultLegacyResolverResults(artifacts, null);
        }

        /**
         * Create a new legacy result representing the result of resolving the dependency graph.
         */

        }
        2.times {
            fails 'entryPoint', '-PfinalizerDepDep1.broken', '--continue'
            result.assertTasksExecuted(':entryPoint', ':finalizerDepDep1', ':finalizerDepDep2', ':finalizerDep2')
            result.assertTaskOrder ':entryPoint', ':finalizerDepDep1'

        return buildOperationRunner.call(new CallableBuildOperation<Result>() {
            @Override
            public Result call(BuildOperationContext operationContext) {
                Result result = executeInternal(work, context);
                operationContext.setResult(Operation.Result.INSTANCE);
                return result;
            }

            @Override

func Getpwnam(name *byte, pwd *Passwd, buf *byte, size uintptr, result **Passwd) syscall.Errno {
	// Note: Returns an errno as its actual result, not in global errno.
	errno, _, _ := syscall_syscall6(abi.FuncPCABI0(libc_getpwnam_r_trampoline),
		uintptr(unsafe.Pointer(name)),
		uintptr(unsafe.Pointer(pwd)),
		uintptr(unsafe.Pointer(buf)),
		size,
		uintptr(unsafe.Pointer(result)),
		0)
	return syscall.Errno(errno)
}

            public WorkResult call(BuildOperationContext context) {
                WorkResult result = delegate.execute(spec);
                context.setResult(toBuildOperationResult(result));
                return result;
            }

            private Result toBuildOperationResult(WorkResult result) {
                if (result instanceof ApiCompilerResult) {