Golang Int63n示例

说明

golang int63n示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: math/rand

示例#1
文件: crafting.go 项目: dominikh/ryzom

func (p *Plan) FindParent(materials material.MaterialSlice) string {
	seed := time.Now().UnixNano()
	fmt.Println("Seed:", seed)
	rand.Seed(seed) // FIXME use own PRNG instance

	ingredients := make([]Ingredient, 0)

	for use, amount := range p.Requirements {
		possibleMaterials := materials.FindByUse(use)
		remainingAmount := amount
		for remainingAmount > 0 {
			randomAmount := rand.Int63n(int64(remainingAmount)) + 1
			randomIndex := rand.Int63n(int64(len(possibleMaterials)))
			randomGrade := rand.Int63n(5)

			mat := possibleMaterials[randomIndex]
			ingredient := Ingredient{mat, use, material.GradeIndexToGrade(randomGrade), uint8(randomAmount)}
			ingredients = append(ingredients, ingredient)

			remainingAmount -= uint8(randomAmount)
		}
	}

	recipe := &Recipe{p, ingredients}
	genes := recipe.genome(materials)
	fmt.Println("Genome:", genes)
	return genes
}

示例#2
文件: scheduler_fetch.go 项目: WUMUXIAN/glow

// Requirement is TaskGroup
// Object is Agent's Location
func (s *Scheduler) Fetch(demands []market.Demand) {
	var request resource.AllocationRequest
	for _, d := range demands {
		demand := d.Requirement.(*plan.TaskGroup)
		request.Requests = append(request.Requests, resource.ComputeRequest{
			ComputeResource: resource.ComputeResource{
				CPUCount: 1,
				CPULevel: 1,
				MemoryMB: int64(s.Option.TaskMemoryMB),
			},
			Inputs: s.findTaskGroupInputs(demand),
		})
	}

	result, err := Assign(s.Leader, &request)
	if err != nil {
		log.Printf("%s Failed to allocate: %v", s.Leader, err)
		time.Sleep(time.Millisecond * time.Duration(15000+rand.Int63n(5000)))
	} else {
		if len(result.Allocations) == 0 {
			log.Printf("%s Failed to allocate any executor.", s.Leader)
			time.Sleep(time.Millisecond * time.Duration(2000+rand.Int63n(1000)))
		} else {
			log.Printf("%s allocated %d executors.", s.Leader, len(result.Allocations))
			for _, allocation := range result.Allocations {
				s.Market.AddSupply(market.Supply{
					Object: allocation,
				})
			}
		}
	}
}

示例#3
文件: dot_test.go 项目: deathly809/parallels

func TestDotInt64WithDiffLength(t *testing.T) {
	N := 1000 + rand.Intn(1000000)
	M := 1000 + rand.Intn(1000000)
	a := make([]int64, N)
	b := make([]int64, M)
	Expected := int64(0)
	for i := range a {
		if i < N {
			a[i] = gomath.ScaleInt64(LowInt64, HighInt64, 0, HighInt64, rand.Int63n(HighInt64))
		}
		if i < M {
			b[i] = gomath.ScaleInt64(LowInt64, HighInt64, 0, HighInt64, rand.Int63n(HighInt64))
		}

		if i < N && i < M {
			Expected += a[i] * b[i]
		}
	}

	Computed := DotInt64(a, b)

	if Computed != Expected {
		t.Logf("Expected %d but computed %d\n", Expected, Computed)
		t.FailNow()
	}
}

示例#4
文件: lustreserver.go 项目: holgerBerger/go_ludalo

// GetRandomValues RPC call for OST, returns random values for testing
func (*OssRpcT) GetRandomValues(init bool, result *OstValues) error {
	result.OstTotal = make(map[string]OstStats)
	result.NidValues = make(map[string]map[string]OstStats)

	for i := 0; i < 10; i++ {
		ost := "OST" + strconv.Itoa(int(rand.Int63n(10)))

		t := result.OstTotal[ost]
		t.RBs = rand.Int63n(10)
		t.WBs = rand.Int63n(10)
		t.RRqs = rand.Int63n(100)
		t.WRqs = rand.Int63n(100)
		result.OstTotal[ost] = t

		result.NidValues[ost] = make(map[string]OstStats)
		for j := 0; j < 100; j++ {
			nid := "nid" + strconv.Itoa(int(rand.Int63n(100)))
			t := result.NidValues[ost][nid]
			t.RBs = rand.Int63n(10)
			t.WBs = rand.Int63n(10)
			t.RRqs = rand.Int63n(100)
			t.WRqs = rand.Int63n(100)
			result.NidValues[ost][nid] = t
		}
	}
	return nil
}

示例#5
文件: sector.go 项目: hiroakiukaji/shooter-server

func (self *sector) hyperWatch() {
	ratio := int64(1e3)
	for {
		// Keeping number of players in field constant.
		if len(self.players) < 20 {
			ai := newAgent()
			ai.player.Position = [2]float64{
				float64(rand.Int63n(ratio) - ratio/2),
				float64(rand.Int63n(ratio) - ratio/2),
			}
			self.addPlayer(ai.player)
		}
		// Keeping number of items constant.
		if len(self.powerups) < 30 {
			pu := newPowerup()
			// Random position.
			pu.Position = [2]float64{
				float64(rand.Int63n(self.bounds[0]) - self.bounds[0]/2),
				float64(rand.Int63n(self.bounds[1]) - self.bounds[1]/2),
			}
			self.addPowerup(pu)
		}
		log.Printf("players: %v, items: %v\n", len(self.players), len(self.powerups))
		time.Sleep(time.Millisecond * time.Duration(rand.Float32()*hyperWatchMaxTime))
	}
}

示例#6
文件: datas.go 项目: athoune/go-searchtags

func loadData() {
	var DOCS_SIZE uint32 = 50000
	var TAGS_SIZE uint64 = 1024
	docs = NewDocuments(DOCS_SIZE, TAGS_SIZE)
	var i uint32
	for i = 0; i < DOCS_SIZE; i++ {
		d := bitset.New64(TAGS_SIZE)
		d.Set(1)
		for j := 0; j < 200; j++ {
			d.Set(uint64(rand.Int63n(int64(TAGS_SIZE))))
		}
		docs.Set(i, d)
	}
	d := bitset.New64(TAGS_SIZE)
	d.Set(1)
	for j := 0; j < 200; j++ {
		d.Set(uint64(rand.Int63n(int64(TAGS_SIZE))))
	}
	for i = 1; i < 5; i++ {
		d := bitset.New64(TAGS_SIZE)
		for j := 0; j < 200; j++ {
			d.Set(uint64(rand.Int63n(int64(TAGS_SIZE))))
		}
		docs.bonus[i] = d
	}

}

示例#7
文件: objectfile_test.go 项目: hironobu-s/swiftfs

func TestRead(t *testing.T) {
	compare := func(offset int64, size int64) {
		l := size - offset

		buf := make([]byte, l)
		res, code := objfile.Read(buf, offset)
		if !code.Ok() {
			t.Fatalf("Read() error, (not OK)")
		}

		read, _ := res.Bytes(buf)
		data := string(read)

		if TEST_DATA[offset:offset+l] != data {
			t.Fatalf("Read() returns invalid data. (offset:%d, size:%d)", offset, size)
		}
	}

	var i = 0
	for i < 10 {
		size := rand.Int63n(int64(len(TEST_DATA)))
		offset := rand.Int63n(size - 1)
		compare(offset, size)
		i++
	}
}

示例#8
文件: deltacoords_test.go 项目: kressnerd/imposm3

func init() {
	nodes = make([]element.Node, 64)
	offset := rand.Int63n(1e10)
	for i := range nodes {
		nodes[i] = element.Node{OSMElem: element.OSMElem{Id: offset + rand.Int63n(1000)}, Long: rand.Float64()*360 - 180, Lat: rand.Float64()*180 - 90}
	}
}

示例#9
文件: datagen.go 项目: CAP-ALL/kube2consul

func GenerateRandomStats(numStats, numCores int, duration time.Duration) []*info.ContainerStats {
	ret := make([]*info.ContainerStats, numStats)
	perCoreUsages := make([]uint64, numCores)
	currentTime := time.Now()
	for i := range perCoreUsages {
		perCoreUsages[i] = uint64(rand.Int63n(1000))
	}
	for i := 0; i < numStats; i++ {
		stats := new(info.ContainerStats)
		stats.Timestamp = currentTime
		currentTime = currentTime.Add(duration)

		percore := make([]uint64, numCores)
		for i := range perCoreUsages {
			perCoreUsages[i] += uint64(rand.Int63n(1000))
			percore[i] = perCoreUsages[i]
			stats.Cpu.Usage.Total += percore[i]
		}
		stats.Cpu.Usage.PerCpu = percore
		stats.Cpu.Usage.User = stats.Cpu.Usage.Total
		stats.Cpu.Usage.System = 0
		stats.Memory.Usage = uint64(rand.Int63n(4096))
		ret[i] = stats
	}
	return ret
}

示例#10
文件: transaction.go 项目: eric-hawthorne/relishpl-concurrent-db-xactions

/*
Begins an immediate-mode database transaction.
*/
func (db *SqliteDBThread) BeginTransaction(transactionType string) (err error) {

	db.dbt.th.AllowGC()
	defer db.dbt.th.DisallowGC()

	stmt := "BEGIN " + transactionType + " TRANSACTION"
	err = db.ExecStatement(stmt)

	var TRY_GAP_WIDENING_MS_INCREMENT int64 = 100 // ms - longest wait will be 6 seconds + random factor
	var tryGapWidth int64 = TRY_GAP_WIDENING_MS_INCREMENT
	var r int64
	for i := 0; err != nil && i < N_BEGIN_TRIES; i++ {
		Logln(PERSIST2_, "BEGIN", transactionType, "ERR:", err)
		r = rand.Int63n(500 + tryGapWidth)
		if i > 5 {
			TRY_GAP_WIDENING_MS_INCREMENT = 1000
		}
		tryGapWidth += TRY_GAP_WIDENING_MS_INCREMENT
		time.Sleep(time.Duration((tryGapWidth + r) * 1000000))
		err = db.ExecStatement(stmt)
	}

	if transactionType == "DEFERRED" {
		// We really don't want a deferred transaction. We want to create a SHARED lock right
		// away in the SQLITE database. If we cannot, we need to fail-fast here, so that
		// the code inside the transaction-protected block will not be executed.

		// So do a dummy read query.

		if dummyQuery == nil {
			dummyQuery, err = db.Prepare("select rowid from RPackage where rowid=1")
			if err != nil {
				panic(err)
			}
		}

		err = dummyQuery.Query()
		dummyQuery.Reset()

		var TRY_GAP_WIDENING_MS_INCREMENT int64 = 100 // ms - longest wait will be 6 seconds + random factor
		var tryGapWidth int64 = TRY_GAP_WIDENING_MS_INCREMENT
		var r int64
		for j := 0; err != nil && j < N_BEGIN_TRIES; j++ {
			Logln(PERSIST2_, "BEGIN DEFERRED: ERR executing dummy select query:", err)
			r = rand.Int63n(500 + tryGapWidth)
			if j > 5 {
				TRY_GAP_WIDENING_MS_INCREMENT = 1000
			}
			tryGapWidth += TRY_GAP_WIDENING_MS_INCREMENT
			time.Sleep(time.Duration((tryGapWidth + r) * 1000000))
			err = dummyQuery.Query()
			dummyQuery.Reset()
		}
	}

	if err == nil {
		Logln(PERSIST2_, ">>>>>>>>>>>>>>>>>>>>>>>>> SUCCESSFULLY BEGAN", transactionType, "TRANSACTION")
	}
	return
}

示例#11
文件: transaction_test.go 项目: conseweb/factoid

func getSignedTrans() IBlock {

	if nb != nil {
		return nb
	}

	nb = new(Transaction)
	t := nb.(*Transaction)

	for i := 0; i < 5; i++ {
		t.AddInput(nextAddress(), uint64(rand.Int63n(10000000000)))
	}

	for i := 0; i < 3; i++ {
		t.AddOutput(nextAddress(), uint64(rand.Int63n(10000000000)))
	}

	for i := 0; i < 3; i++ {
		t.AddECOutput(nextAddress(), uint64(rand.Int63n(10000000)))
	}

	for i := 0; i < 3; i++ {
		sig := NewRCD_1(nextSig())
		t.AddAuthorization(sig)
	}

	for i := 0; i < 2; i++ {

		t.AddAuthorization(nextAuth2())
	}

	return nb
}

示例#12
文件: factoidTransaction_test.go 项目: jjdevbiz/factomd

func newFactoidTransaction() *FactoidTransaction {
	msg := new(FactoidTransaction)

	t := new(factoid.Transaction)

	for i := 0; i < 5; i++ {
		t.AddInput(nextAddress(), uint64(rand.Int63n(10000000000)))
	}

	for i := 0; i < 3; i++ {
		t.AddOutput(nextAddress(), uint64(rand.Int63n(10000000000)))
	}

	for i := 0; i < 3; i++ {
		t.AddECOutput(nextAddress(), uint64(rand.Int63n(10000000)))
	}

	for i := 0; i < 3; i++ {
		sig := factoid.NewRCD_1(nextSig())
		t.AddAuthorization(sig)
	}

	for i := 0; i < 2; i++ {
		t.AddAuthorization(nextAuth2())
	}

	msg.Transaction = t

	return msg
}

示例#13

// Randomly generate number [start,end) except @except.
func randInt64Except(start, end int64, except map[int64]empty) int64 {
	n := end - start
	ret := rand.Int63n(n) + start
	for _, ok := except[ret]; ok; _, ok = except[ret] {
		ret = rand.Int63n(n) + start
	}
	return ret
}

示例#14
文件: main.go 项目: taysom/va

func (p *Producer) Action() {
	var w Work
	println("Producer Action")
	w.start = current + time(rand.Int63n(100))
	clock.insert(&w)
	p.start = current + time(rand.Int63n(100))
	clock.insert(p)
}

示例#15
文件: monitor_test.go 项目: s-vp/fluent-agent-hydra

func TestMonitorServer(t *testing.T) {
	config := &hydra.Config{
		Monitor: &hydra.ConfigMonitor{
			Host: "localhost",
			Port: 0,
		},
	}
	_, ch := hydra.NewChannel()
	monitor, _ := hydra.NewMonitor(config, ch)
	go monitor.Run()

	expectedMessages := make(map[string]int64)
	expectedBytes := make(map[string]int64)
	tags := []string{"foo", "bar", "dummy.test"}
	for _, tag := range tags {
		for i := 1; i <= 100; i++ {
			m := rand.Int63n(10)
			b := rand.Int63n(2560)
			ch <- &hydra.SentStat{
				Tag:      tag,
				Messages: m,
				Bytes:    b,
			}
			expectedMessages[tag] += m
			expectedBytes[tag] += b
		}
	}
	sleep(1)

	resp, err := http.Get(fmt.Sprintf("http://%s/", monitor.Addr))
	if err != nil {
		t.Error(err)
	}
	defer resp.Body.Close()
	if ct := resp.Header.Get("Content-Type"); ct != "application/json" {
		t.Error("invalid content-type", ct)
	}
	body, _ := ioutil.ReadAll(resp.Body)
	js := bytes.NewReader(body)
	for tag, n := range expectedMessages {
		js.Seek(int64(0), os.SEEK_SET)
		var got int64
		scan.ScanJSON(js, "/sent/"+tag+"/messages", &got)
		if got != n {
			t.Errorf("/sent/%s/messages got %d expected %d", tag, got, n)
		}
	}
	for tag, n := range expectedBytes {
		js.Seek(int64(0), os.SEEK_SET)
		var got int64
		scan.ScanJSON(js, "/sent/"+tag+"/bytes", &got)
		if got != n {
			t.Errorf("/sent/%s/bytes got %d expected %d", tag, got, n)
		}
	}

	log.Println(string(body))
}

示例#16
文件: priority_queue.go 项目: sankark/golang-stuff

func requester(work chan Request) {
	for {
		time.Sleep(time.Duration(rand.Int63n(MaxRequesters * Seconds)))
		work <- func() {
			r := rand.Int63n(MaxRequesters*Seconds) + 10
			time.Sleep(time.Duration(r))
		}
	}
}

示例#17
文件: perf.go 项目: fmstephe/performance-presentation-notes

func valRangePyramid(n int, low, high int64) []int64 {
	seq := (high - low) / 4
	vals := make([]int64, n)
	for i := 0; i < n; i++ {
		val := rand.Int63n(seq) + rand.Int63n(seq) + rand.Int63n(seq) + rand.Int63n(seq)
		vals[i] = val + low
	}
	return vals
}

示例#18
文件: nuid.go 项目: glycerine/rmq

// New will generate a new NUID and properly initialize the prefix, sequential start, and sequential increment.
func New() *NUID {
	n := &NUID{
		seq: prand.Int63n(maxSeq),
		inc: minInc + prand.Int63n(maxInc-minInc),
		pre: make([]byte, preLen),
	}
	n.RandomizePrefix()
	return n
}

示例#19
文件: input_raw_test.go 项目: buger/gor

func BenchmarkRAWInput(b *testing.B) {
	quit := make(chan int)

	origin := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
	defer origin.Close()
	originAddr := strings.Replace(origin.Listener.Addr().String(), "[::]", "127.0.0.1", -1)

	var respCounter, reqCounter int64

	input := NewRAWInput(originAddr, EnginePcap, true, testRawExpire, "")
	defer input.Close()

	output := NewTestOutput(func(data []byte) {
		if data[0] == '1' {
			atomic.AddInt64(&reqCounter, 1)
		} else {
			atomic.AddInt64(&respCounter, 1)
		}

		// log.Println("Captured ", reqCounter, "requests and ", respCounter, " responses")
	})

	Plugins.Inputs = []io.Reader{input}
	Plugins.Outputs = []io.Writer{output}

	go Start(quit)

	emitted := 0
	fileContent, _ := ioutil.ReadFile("LICENSE.txt")

	for i := 0; i < b.N; i++ {
		wg := new(sync.WaitGroup)
		wg.Add(10 * 100)
		emitted += 10 * 100
		for w := 0; w < 100; w++ {
			go func() {
				client := NewHTTPClient(origin.URL, &HTTPClientConfig{})
				for i := 0; i < 10; i++ {
					if rand.Int63n(2) == 0 {
						client.Post("/", fileContent)
					} else {
						client.Get("/")
					}
					time.Sleep(time.Duration(rand.Int63n(50)) * time.Millisecond)
					wg.Done()
				}
			}()
		}
		wg.Wait()
	}

	time.Sleep(400 * time.Millisecond)
	log.Println("Emitted ", emitted, ", Captured ", reqCounter, "requests and ", respCounter, " responses")

	close(quit)
}

示例#20
文件: epsilongreedy_new_test.go 项目: reiver/go-epsilongreedy

func TestNewWithRandEpsilon(t *testing.T) {

	for i := 0; i < 100; i++ {

		size := 1 + uint64(rand.Int63n(1000))

		// rand.Float64() returns [0,1)
		epsilon := rand.Float64()

		x := New(size, epsilon)

		if nil == x {
			t.Errorf("Expected a non-nil return for epsilon [%v]", epsilon)
		}

		if epsilon != x.epsilon {
			t.Errorf("Stored epsilon and test epsilon are different for size [%+v] and epsilon [%+v] and object [%+v]", size, epsilon, x)
		}

		if size != x.size {
			t.Errorf("Stored size and test size are different for size [%+v] and epsilon [%+v] and object [%+v]", size, epsilon, x)
		}

		if size != uint64(len(x.counts)) {
			t.Errorf("Length of stored counts and test size are different for size [%+v] and epsilon [%+v] and object [%+v]", size, epsilon, x)
		}

		if size != uint64(len(x.values)) {
			t.Errorf("Length of stored values and test size are different for size [%+v] and epsilon [%+v] and object [%+v]", size, epsilon, x)
		}
	}

	for i := 0; i < 100; i++ {

		size := 1 + uint64(rand.Int63n(1000))

		// rand.Float64() returns [0,1)
		epsilon := 1 + rand.Float64()
		if 0 == rand.Int31n(1) {
			epsilon += rand.Float64()
		}
		if 0 == rand.Int31n(1) {
			epsilon *= 1 + rand.Float64()
		}
		if 0 == rand.Int31n(1) {
			epsilon *= -1
		}

		x := New(size, epsilon)

		if nil != x {
			t.Errorf("Expected a nil return for size [%+v] and epsilon [%v]", size, epsilon)
		}
	}

}

示例#21
文件: migration.go 项目: rzh/montu

func (r *ChunkMigrationGen) Init() {
	r.C = make(chan [3]int64)

	go func() {
		for {
			<-r.C
			r.C <- [3]int64{rand.Int63(), rand.Int63n(3), rand.Int63n(3)}
		}
	}()
}

示例#22
文件: registry_test.go 项目: glestaris/clique

func makeTranaferResults(ip net.IP, bytesSent uint32) api.TransferResults {
	return api.TransferResults{
		IP:        ip,
		BytesSent: bytesSent,
		Checksum:  uint32(rand.Int31()),
		Duration:  time.Duration(rand.Int63n(1000)) * time.Millisecond,
		RTT:       time.Duration(rand.Int63n(100)) * time.Millisecond,
		Time:      time.Now(),
	}
}

示例#23
文件: datagen.go 项目: TencentSA/kubernetes-0.5

func GenerateRandomContainerSpec(numCores int) info.ContainerSpec {
	ret := info.ContainerSpec{
		Cpu:    info.CpuSpec{},
		Memory: info.MemorySpec{},
	}
	ret.Cpu.Limit = uint64(1000 + rand.Int63n(2000))
	ret.Cpu.MaxLimit = uint64(1000 + rand.Int63n(2000))
	ret.Cpu.Mask = fmt.Sprintf("0-%d", numCores-1)
	ret.Memory.Limit = uint64(4096 + rand.Int63n(4096))
	return ret
}

示例#24
文件: backoff.go 项目: nightlyone/reconnect

// Given a retry count and a base retry interval, return the next retry interval
// according to the exponential backoff algorithm.
// Maximum returned retry interval is interval * 2^15.
func nextExponentialBackoff(retries uint, interval time.Duration) time.Duration {
	switch {
	case retries == 0:
		return time.Duration(rand.Int63n(int64(interval)))
	case retries == 1:
		return time.Duration(rand.Int63n(7)) * interval
	case retries >= 2 && retries < 15:
		return time.Duration(rand.Int63n((1<<retries)-1)) * interval
	default:
	}
	return time.Duration(rand.Int63n(1<<15)) * interval
}

示例#25
文件: record.go 项目: SchumacherFM/mediamock

func init() {
	// reason for this: if an image with the same name will be served
	// in different sizes then the displayed pattern will be the same
	// but the color changes with each start of mediamock.
	// This feature makes it possible for the human to recognize a resized image.
	var key []byte
	rand.Seed(time.Now().Unix())
	a := rand.Int63n(2000)
	key = strconv.AppendInt(key, a, 10)
	b := rand.Int63n(2000)
	key = strconv.AppendInt(key, b, 10)
	sipHashKey = md5.Sum(key)
}

示例#26
文件: cmap_test.go 项目: NONFish/goc2p

func TestInt64Cmap(t *testing.T) {
	newCmap := func() ConcurrentMap {
		keyType := reflect.TypeOf(int64(2))
		elemType := keyType
		return NewConcurrentMap(keyType, elemType)
	}
	testConcurrentMap(
		t,
		newCmap,
		func() interface{} { return rand.Int63n(1000) },
		func() interface{} { return rand.Int63n(1000) },
		reflect.Int64,
		reflect.Int64)
}

示例#27
文件: ipsum.go 项目: daaku/ipsum

func randSize() int64 {
	r := rand.Float32()
	switch {
	case r < 0.05:
		return rand.Int63n(h("3mb")) + h("1mb")
	case r < 0.2:
		return rand.Int63n(h("200k")) + h("100k")
	case r < 0.5:
		return rand.Int63n(h("50k")) + h("50k")
	case r < 0.6:
		return rand.Int63n(h("50k")) + h("10k")
	}
	return rand.Int63n(h("10k"))
}

示例#28
文件: tinteger_test.go 项目: roger2000hk/flib

func TestMin(t *testing.T) {
	rand.Seed(1)
	for i := 0; i < 1000*1000; i++ {
		a := rand.Int63n(1000 * 1000 * 1000)
		b := rand.Int63n(1000 * 1000 * 1000)
		m := Min(a, b)
		om := simpleMin(a, b)
		if m != om {
			as := fstrconv.ItoaComma(a)
			bs := fstrconv.ItoaComma(b)
			ms := fstrconv.ItoaComma(m)
			t.Errorf("Problem with min of %s, %s - min returned %s", as, bs, ms)
		}
	}
}

示例#29
文件: keys_test.go 项目: NONFish/goc2p

func TestInt64Keys(t *testing.T) {
	testKeys(t,
		func() Keys {
			//return NewKeys(
			//func(e1 interface{}, e2 interface{}) int8 {
			//	k1 := e1.(int64)
			//	k2 := e2.(int64)
			//	if k1 < k2 {
			//		return -1
			//	} else if k1 > k2 {
			//		return 1
			//	} else {
			//		return 0
			//	}
			//},
			//reflect.TypeOf(int64(1)))
			int64Keys := &myKeys{
				container: make([]interface{}, 0),
				compareFunc: func(e1 interface{}, e2 interface{}) int8 {
					k1 := e1.(int64)
					k2 := e2.(int64)
					if k1 < k2 {
						return -1
					} else if k1 > k2 {
						return 1
					} else {
						return 0
					}
				},
				elemType: reflect.TypeOf(int64(1))}
			return int64Keys
		},
		func() interface{} { return rand.Int63n(1000) },
		reflect.Int64)
}

示例#30
文件: reader.go 项目: rif/golang-stuff

// poll all known lookup servers every LookupdPollInterval
func (q *Reader) lookupdLoop() {
	// add some jitter so that multiple consumers discovering the same topic,
	// when restarted at the same time, dont all connect at once.
	rand.Seed(time.Now().UnixNano())
	jitter := time.Duration(rand.Int63n(int64(q.LookupdPollInterval / 10)))
	ticker := time.NewTicker(q.LookupdPollInterval)

	select {
	case <-time.After(jitter):
	case <-q.lookupdExitChan:
		goto exit
	}

	for {
		select {
		case <-ticker.C:
			q.queryLookupd()
		case <-q.lookupdRecheckChan:
			q.queryLookupd()
		case <-q.lookupdExitChan:
			goto exit
		}
	}

exit:
	ticker.Stop()
	log.Printf("exiting lookupdLoop")
}

展开阅读全文