scanner.run()

        then:
        1 * detector.startDetection(processor)
        then:
        1 * files.visit(_) >> { args ->
            FileVisitor visitor = args[0]
            assert visitor
            visitor.visitFile(class1)
            visitor.visitFile(class2)
        }
        then:
        1 * detector.processTestClass({ it.file.is(class1.file) && it.relativePath.is(class1.relativePath) })
        then:

			}
		}
		if !withCondition {
			db.AddError(gorm.ErrMissingWhereClause)
		}
		return
	}
}

type visitMap = map[reflect.Value]bool

// Check if circular values, return true if loaded
func loadOrStoreVisitMap(visitMap *visitMap, v reflect.Value) (loaded bool) {
	if v.Kind() == reflect.Ptr {
		v = v.Elem()
	}

	switch v.Kind() {
	case reflect.Slice, reflect.Array:

    }

    @Override
    public void visit(Visitor visitor) {
        visitor.visitArtifacts(this);
    }

    @Override
    public void visitTransformSources(TransformSourceVisitor visitor) {
        throw UncheckedException.throwAsUncheckedException(failure);
    }

    @Override
    public void visitExternalArtifacts(Action<ResolvableArtifact> visitor) {

        ClassWriter visitor = classGenerator.getVisitor();

        Type generatedType = classGenerator.getGeneratedType();

        Type superclassType = Type.getType(implClass);
        Type publicType = Type.getType(publicContractType);

        generateClass(visitor, generatedType, superclassType, publicType);
        generateConstructors(visitor, implClass, superclassType);
        visitor.visitEnd();

        return visitor(data_.capsule);
      case NONE:
        return visitor(impl::None::GetInstance());
    }
  }

  /// @brief Implements visitor pattern for doing type-based dispatch.
  ///
  /// @tparam R The desired return type.
  /// @tparam Visitor The visitor class which has a callable operator.
  /// @return The `visitor` called on the correct value.
  template <class R, class Visitor>
  R visit(Visitor visitor) const {

        public void visit(ArtifactVisitor visitor) {
            if (visitor.requireArtifactFiles() && !artifact.getFileSource().getValue().isSuccessful()) {
                visitor.visitFailure(artifact.getFileSource().getValue().getFailure().get());
            } else {
                visitor.visitArtifact(variantName, variantAttributes, capabilities, artifact);
                visitor.endVisitCollection(FileCollectionInternal.OTHER);

    def "visits self and parent"() {
        def visitor = Mock(ClassLoaderVisitor)
        def parent = new ClassLoader(null) { }
        def classPath = [new File("a").toURI().toURL(), new File("b").toURI().toURL()]
        def cl = new VisitableURLClassLoader("test", parent, classPath)

        when:
        cl.visit(visitor)

        then:

            return patternSet;
        });
    }

    @Override
    public FileTree visit(FileVisitor visitor) {
        visitContentsAsFileTrees(child -> child.visit(visitor));
        return this;
    }

    @Override
    public void visitContentsAsFileTrees(Consumer<FileTreeInternal> visitor) {
        visitContents(new FileCollectionStructureVisitor() {
            @Override

    @Override
    public void describe(DiagnosticsVisitor visitor) {
        visitor.candidate("String or CharSequence instances").example("\"some/path\"");
        visitor.candidate("Boolean values").example("true").example("Boolean.TRUE");
        visitor.candidate("Number values").example("42").example("3.14");
        visitor.candidate("A File instance");
        visitor.candidate("A Closure that returns any supported value.");

    def "collects union of potential values"() {
        def visitor = new ValueCollectingDiagnosticsVisitor()

        given:
        visitor.candidate("thing 1").values(["a", "b"])
        visitor.candidate("thing 2").values(["a", 1.2, false])
        visitor.candidate("thing 3")

        expect:
        visitor.values == ["a", "b", "false", "1.2"] as Set
    }