continue
		}

		if end.Before(thisInstant) {
			expiry := end.Format(dateFormat)
			countFiles[expiry] = append(countFiles[expiry], f)
			if earliest[expiry].IsZero() || earliest[expiry].After(begin) {
				earliest[expiry] = begin
			}
		}
	}
	for expiry, files := range countFiles {
		if notNeeded(expiry, *todo) {
			u.logger.Printf("Files for %s not needed, deleting %v", expiry, files)

			case expiry.After(u.startTime):
				u.logger.Printf("Skipping count file %s: still active", fi.Name())
			default:
				u.logger.Printf("Collecting count file %s", fi.Name())
				ans.countfiles = append(ans.countfiles, fname)
			}
		} else if strings.HasPrefix(fi.Name(), "local.") {
			// skip
		} else if strings.HasSuffix(fi.Name(), ".json") && mode == "on" {
			// Collect reports that are ready for upload.

        this
    }

    String content(String relativePath) {
        List<String> files = filesByRelativePath.get(relativePath)
        assert files.size() == 1
        files.get(0)
    }

    Integer countFiles(String relativePath) {
        filesByRelativePath.get(relativePath).size()
    }

    def hasDirs(String... relativePaths) {
        assert dirs.sort() == relativePaths.collect { it + "/" }.sort()
        this

    }

    private def confirmDuplicateServicesPreserved() {
        def jar = new JarTestFixture(file('test.jar'))

        assert 2 == jar.countFiles('META-INF/services/org.gradle.Service')
        assert 1 == jar.countFiles('path/test.txt')

        jar.assertFileContent('test.txt', 'Content of first file')
        jar.hasService('org.gradle.Service', 'org.gradle.BetterServiceImpl')

}


internal
fun File.readLinesRange() =
    countLines().let { count ->
        if (count == 0L) 0..0L
        else 1..count
    }


private
fun File.countLines(): Long =
    inputStream().buffered().use { input ->
        input.countLines()
    }


private
fun BufferedInputStream.countLines(): Long {
    val buffer = ByteArray(DEFAULT_BUFFER_SIZE)

		return
	}

	DB.Migrator().DropTable(&City{}, &Museum{})

	if err = db.AutoMigrate(&City{}, &Museum{}); err != nil {
		t.Fatalf("failed to migrate countries & cities tables, got error: %v", err)
	}

	city := City{Name: "Amsterdam"}

	err = db.Create(&city).Error
	if err != nil {
		t.Fatalf("failed to create city: %v", err)
	}

8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License may
add an explicit geographical distribution limitation excluding those
countries, so that distribution is permitted only in or among countries
not thus excluded. In such case, this License incorporates the

	expectedFilterRules := countRules(logger, utiliptables.TableFilter, iptablesData)

	if nFilterRules != expectedFilterRules {
		t.Fatalf("Wrong number of filter rule: expected %d got %d\n%s", expectedFilterRules, nFilterRules, iptablesData)
	}

	nNatRules := countRulesFromMetric(logger, utiliptables.TableNAT)
	expectedNatRules := countRules(logger, utiliptables.TableNAT, iptablesData)

// IsPrivateUse reports whether this script code is reserved for private use.
func (s Script) IsPrivateUse() bool {
	return s.scriptID.IsPrivateUse()
}

// Region is an ISO 3166-1 or UN M.49 code for representing countries and regions.
type Region struct {
	regionID language.Region
}

// EncodeM49 returns the Region for the given UN M.49 code.
// It returns an error if r is not a valid code.

infringement under applicable copyright law, except executing it on a
computer or modifying a private copy.  Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.

  To "convey" a work means any kind of propagation that enables other
parties to make or receive copies.  Mere interaction with a user through