* See the License for the specific language governing permissions and
* limitations under the License.
*/

def visitIterations = (1..10)

tasks.register("visitZip") {
    doLast {
        visitIterations.each {
            zipTree(file("archive.zip")).each {
                logger.info it.path
            }
        }
    }
}

tasks.register("visitTar") {

    }

    @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:
        def result = runner.run()

        then:

        when:
        fileTree.visit(visitor)

        then:
        1 * visitor.visitDir({ it.file == tempDir.file("dir1") })
        1 * visitor.visitDir({ it.file == tempDir.file("dir2") })
        1 * visitor.visitDir({ it.file == tempDir.file("dir3") })
        1 * visitor.visitDir({ it.file == tempDir.file("dir2/dir1") })
        1 * visitor.visitDir({ it.file == tempDir.file("dir2/dir2") })

			}
		}
		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:

        1 * spec.isSatisfiedBy(excluded) >> false
        1 * source.visit(_) >> { FileVisitor nestedVisitor ->
            nestedVisitor.visitDir(included)
            nestedVisitor.visitDir(excluded)
        }
        1 * visitor.visitDir(included)
        0 * _
    }

    def "ignores file that is not included"() {
        def spec = Mock(Spec)
        def included = Stub(FileVisitDetails)

                visitFile: {FileVisitDetails details ->
                    assertFalse(found)
                    found = true
                    details.stopVisiting()
                },
                visitDir: {FileVisitDetails details ->
                    assertFalse(found)
                }
        ] as FileVisitor

        tree.visit(visitor)
        assertTrue(found)
    }

        def fileTree = new DirectoryFileTree(rootDir, new PatternSet(), TestFiles.fileSystem(), false)
        def visited = []
        def visitClosure = { visited << it }
        def fileVisitor = [visitFile: visitClosure, visitDir: visitClosure, isReproducibleFileOrder: { isReproducible }] as ReproducibleFileVisitor
        fileTree.visit(fileVisitor)
        visited
    }

            visitDirectoryContents(root, visitor);
        }
    }

    private void visitDirectoryContents(File dir, ClasspathEntryVisitor visitor) throws IOException {
        visitDir(dir, "", visitor);
    }

    private void visitDir(File dir, String prefix, ClasspathEntryVisitor visitor) throws IOException {
        File[] files = dir.listFiles();

        // Apply a consistent order, regardless of file system ordering

        Spec<FileTreeElement> spec = patterns.getAsSpec();
        tree.visit(new FileVisitor() {
            @Override
            public void visitDir(FileVisitDetails dirDetails) {
                if (spec.isSatisfiedBy(dirDetails)) {
                    visitor.visitDir(dirDetails);
                }
            }

            @Override
            public void visitFile(FileVisitDetails fileDetails) {

    if (ShouldPreserveIsland(island)) {
      reachable_ops.insert(&op);
      VisitOp(graph, &op, &reachable_ops, &ops_to_visit);
    }
  }

  // Visit transitive ops until no there are no reachable ops left that have not
  // been visited.
  while (!ops_to_visit.empty()) {
    Operation* op = ops_to_visit.pop_back_val();
    VisitOp(graph, op, &reachable_ops, &ops_to_visit);
  }