import javax.annotation.Nullable;

/**
 * A builder for {@link DirectorySnapshot}.
 *
 * In order to build a directory snapshot, you need to call the methods for entering/leaving a directory
 * and for visiting leaf elements.
 * The visit methods need to be called in depth-first order.
 * When leaving a directory, the builder will create a {@link DirectorySnapshot} for the directory,
 * calculating the combined hash of the entries.
 */

    private int treeDepth;

    /**
     * Called before visiting the contents of a directory.
     */
    public void enterDirectory(DirectorySnapshot directorySnapshot, boolean isRoot) {}

    /**
     * Called for each regular file/directory/missing/unavailable file.
     *
     * @return how to continue visiting the rest of the snapshot hierarchy.
     */

                eachFile { fcd ->
                    println("visiting ${fcd.path}")
                    fcd.path = "sub/${fcd.path}"
                }
            }
        '''

        when:
        run 'copy'

        then:
        output.count('visiting ') == 2
        outputContains('visiting a.txt')
        outputContains('visiting dir/b.txt')
        file('dest').assertHasDescendants(

            generateArchiveContents(archiveContentsDir)
        }
    }

    @RunFor(
        @Scenario(type = PER_COMMIT, operatingSystems = [LINUX], testProjects = ["archivePerformanceProject"])
    )
    def "visiting zip trees"() {
        given:
        runner.tasksToRun = ['visitZip']
        runner.addBuildMutator { createArchive(it, "archive.zip") { contents, output -> contents.zipTo(output) } }

        when:

                    if (!visiting.contains(successor)) {
                        insertPoint.add(successor);
                    }
                }
            } else {
                // Have visited this node's dependencies - add it to the graph
                queue.removeFirst();
                visiting.remove(node);
                node.dependenciesProcessed();

        TypeVisitResult visitType(Class<? super T> type);
    }

    public static enum TypeVisitResult {
        /**
         * Continue visiting.
         */
        CONTINUE,

        /**
         * Terminate visiting immediately.
         */
        TERMINATE
    }

    if (failed(res)) return res;
  }

  // To support WhileRegion, we need to propagate device attributes from
  // WhileRegion operands to body/cond region arguments *prior* to visiting
  // these regions, so use a pre-order walk.
  WalkResult walk_res = func_op.walk<WalkOrder::PreOrder>([&](Operation* op) {
    if (auto var_handle = dyn_cast<VarHandleOp>(op)) {

// if visiting should continue.
type ContainerVisitor func(container *api.Container, containerType ContainerType) (shouldContinue bool)

// VisitContainers invokes the visitor function with a pointer to every container
// spec in the given pod spec with type set in mask. If visitor returns false,
// visiting is short-circuited. VisitContainers returns true if visiting completes,
// false if visiting was short-circuited.

else
   tfrun bazel test $TFCI_BAZEL_COMMON_ARGS --profile "$TFCI_OUTPUT_DIR/profile.json.gz" --config="${TFCI_BAZEL_TARGET_SELECTING_CONFIG_PREFIX}_pycpp_test"
fi

# Note: the profile can be viewed by visiting chrome://tracing in a Chrome browser.
# See https://docs.bazel.build/versions/main/skylark/performance.html#performance-profiling

    protected abstract void visitCause(Throwable cause);

    protected abstract void visitLocation(String location);

    /**
     * Should be called after each time this visitor has finished visiting.
     *
     * This method can be used to perform any cleanup or final processing related
     * to the visitor's purpose.
     */
    protected void endVisiting() {
        // default is no-op
    }