System.out.println(new WithInner1().getInner().foo());
                        System.out.println(new WithInner2().getInner().foo());
                    }
                }
            """
        }

        void changeInnerName() {
            source """
                class WithInner2 {
                    SomeInterface getInner() {
                        return new Inner2();

                                               mlir::OpResult dest) {
  CopyDeviceAndUnderscoredAttributesAdaptor(src.getOwner(), dest.getOwner());
}

void CopyDeviceAndUnderscoredAttributesAdaptor(mlir::Operation *src,
                                               mlir::OpResult dest) {
  CopyDeviceAndUnderscoredAttributesAdaptor(src, dest.getOwner());
}

void CopyDeviceAndUnderscoredAttributesAdaptor(mlir::Operation *src,

                CallableInfo callable = request.getInterceptedCallable();
                CallableKindInfo kind = callable.getKind();
                if (kind == CallableKindInfo.AFTER_CONSTRUCTOR) {
                    Type constructedType = request.getInterceptedCallable().getOwner().getType();

        ProjectState projectState = gradle.getOwner().getProjects().getProject(rootProjectDescriptor.path());
        projectState.createMutableModel(rootProjectClassLoaderScope, baseProjectClassLoaderScope);
        ProjectInternal rootProject = projectState.getMutableModel();
        gradle.setRootProject(rootProject);

    if (auto while_op = llvm::dyn_cast<TF::WhileOp>(use.getOwner())) {
      auto body = while_op.body_function();
      assert(body);
      auto type_from_body = GetElementTypeFromAccess(
          body.getArgument(use.getOperandNumber()), module, infer_from_op);
      if (type_from_body.has_value()) return type_from_body;
    } else if (auto if_op = llvm::dyn_cast<TF::IfOp>(use.getOwner())) {
      auto then_branch = if_op.then_function();

    }

    @Override
    public void visitEdges(DependencyGraphNode node) {
        resolutionResultBuilder.visitOutgoingEdges(node.getOwner().getResultId(), node.getOutgoingEdges());
    }

    @Override
    public void finish(RootGraphNode root) {
        Long resultId = root.getOwner().getResultId();
        this.root = resolutionResultBuilder.getRoot(resultId);
        this.requestAttributes = root.getResolveState().getAttributes();

            Runner runner = getRunner(testClass);
            final Description runnerDescription = runner.getDescription();
            return runnerDescription.getChildren();
        } catch (Throwable throwable) {
            throw new TestSuiteExecutionException(String.format("Unable to process Ignored class %s.", className), throwable);
        }
    }

    private static Runner getRunner(Class<?> testClass) throws Throwable {

        return interceptionRequests.stream()
            .filter(request -> request.getInterceptedCallable().getOwner().isInterceptSubtypes())
            .collect(Collectors.toList());
    }

    @Override
    public GenerationResult generateResourceForRequests(Collection<CallInterceptionRequest> filteredRequests) {

        List<ComponentIdentifier> rootPath = new ArrayList<>();
        rootPath.add(toNode.getOwner().getComponentId());
        shortestPaths.put(toNode.getOwner(), rootPath);

        Set<DependencyGraphComponent> directDependees = new LinkedHashSet<>();
        for (DependencyGraphNode node : fromNodes) {
            directDependees.add(node.getOwner());
        }

        Set<DependencyGraphComponent> seen = new HashSet<>();

}

// EvalHostSymlinks always returns an error on unsupported platforms
func (hu *HostUtil) EvalHostSymlinks(pathname string) (string, error) {
	return "", errUnsupported
}

// GetOwner always returns an error on unsupported platforms
func (hu *HostUtil) GetOwner(pathname string) (int64, int64, error) {
	return -1, -1, errUnsupported
}

// GetSELinuxSupport always returns an error on unsupported platforms