func TestMap(t *testing.T) {
func() {
d := newMapString()
ix := rand.Perm(testN)
for _, v := range testVals {
d.set(v)
}
for _, idx := range ix {
d.delete(testVals[idx].id)
}
for _, idx := range ix {
if d.exist(testVals[idx].id) {
t.Errorf("%s should have not existed!", testVals[idx].id)
}
}
}()
func() {
d := newMapPointer()
ix := rand.Perm(testN)
for _, v := range testVals {
d.set(v)
}
for _, idx := range ix {
d.delete(testVals[idx].id)
}
for _, idx := range ix {
if d.exist(testVals[idx].id) {
t.Errorf("%s should have not existed!", testVals[idx].id)
}
}
}()
}
func TestInterface(t *testing.T) {
func() {
d := newDataRWMutex()
ix := rand.Perm(testSize)
for _, v := range testValues {
d.set(v)
}
for _, idx := range ix {
d.delete(testValues[idx])
}
for _, idx := range ix {
if d.exist(testValues[idx]) {
t.Errorf("%s should have not existed!", testValues[idx])
}
}
}()
func() {
d := newDataMutex()
ix := rand.Perm(testSize)
for _, v := range testValues {
d.set(v)
}
for _, idx := range ix {
d.delete(testValues[idx])
}
for _, idx := range ix {
if d.exist(testValues[idx]) {
t.Errorf("%s should have not existed!", testValues[idx])
}
}
}()
}
func advanceState(c appengine.Context, h *hunt.Hunt, currentState int) {
err := datastore.RunInTransaction(c, func(c appengine.Context) error {
h := hunt.ID(c, h.ID)
if h == nil || h.State != currentState {
// TODO(dneal): Return a real error.
return nil
}
switch h.State {
case hunt.StatePreLaunch:
teams := team.All(c, h)
nonPaperOrder := rand.Perm(len(teams))
paperOrder := rand.Perm(len(teams))
for i := range teams {
puzzle.New(c, h, teams[i], nonPaperOrder[i]+1, false)
puzzle.New(c, h, teams[i], len(teams)+paperOrder[i]+1, true)
}
case hunt.StateSurveying:
tally.BuildFinalTally(c, h)
}
h.State++
h.Write(c)
broadcast.SendRefresh(c, h)
return nil
}, nil)
if err != nil {
c.Errorf("Error: %v", err)
}
}
func TestEdgeX(t *testing.T) {
mom := rand.Perm(8)
dad := rand.Perm(8)
child := make([]int, 8)
perm.EdgeX(child, mom, dad)
validate(t, child)
}
func (ag *AvalonGame) assignSpecialCharacters() {
// === Good ===
randomOrder := rand.Perm(ag.NumGoods())
// Merlin
ag.SpecialCharacters["merlin"] = ag.GoodCharacters[randomOrder[0]]
// Percival
if ag.OptionEnabled[OptionMorganaPercival] {
ag.SpecialCharacters["percival"] = ag.GoodCharacters[randomOrder[1]]
}
// === Evil ===
randIndex := 1
randomOrder = rand.Perm(ag.NumEvils())
// Assassin
ag.SpecialCharacters["assassin"] = ag.EvilCharacters[randomOrder[0]]
// Mordred
if ag.OptionEnabled[OptionMordred] {
ag.SpecialCharacters["mordred"] = ag.EvilCharacters[randomOrder[randIndex]]
randIndex++
}
// Morgana
if ag.OptionEnabled[OptionMorganaPercival] {
ag.SpecialCharacters["morgana"] = ag.EvilCharacters[randomOrder[randIndex]]
randIndex++
}
// Oberon
if ag.OptionEnabled[OptionOberon] {
ag.SpecialCharacters["oberon"] = ag.EvilCharacters[randomOrder[randIndex]]
randIndex++
}
}
func init() {
for _, val := range rand.Perm(10) {
data := &TestData{
Id: int64(val),
Value: int64(val),
}
skipList.Set(data, nil)
datas[data.Id] = data
}
for _, val := range rand.Perm(20) {
data := &TestData{
Id: int64(val),
Value: int64(val),
}
old, ok := datas[data.Id]
if ok {
skipList.Set(data, old)
} else {
skipList.Set(data, nil)
}
}
fmt.Println("f**k")
skipList.Set(&TestData{
Id: 1,
Value: 10,
}, datas[1])
}
func TestBinaryTreeFind(t *testing.T) {
const count = 100
for i := 0; i < 10; i++ {
tree := Tree{Compare: func(a, b interface{}) ComparisonResult {
aa := a.(int)
bb := b.(int)
switch {
case aa < bb:
return Less
case aa > bb:
return Greater
default:
return Equal
}
}}
list := rand.Perm(count)
for _, j := range list {
if e := tree.Add(j); e != nil {
t.Error(e)
}
}
list = rand.Perm(count)
for _, j := range list {
if _, _, n := tree.Find(j); n == nil {
t.Errorf("Should have found %d, but didn't", j)
} else if v, ok := n.Data.(int); !ok {
t.Errorf("Unable to cast data to int... %+v", n.Data)
} else if v != j {
t.Errorf("Expected to find %d, but got %d", j, v)
}
}
}
}
func TestMapTo(t *testing.T) {
func() {
d := newSlice()
ix := rand.Perm(testN)
for _, v := range testVals {
d.set(v)
}
for _, idx := range ix {
d.delete(testVals[idx])
}
for _, idx := range ix {
if d.exist(testVals[idx]) {
t.Errorf("%s should have not existed!", testVals[idx])
}
}
}()
func() {
d := newMap()
ix := rand.Perm(testN)
for _, v := range testVals {
d.set(v)
}
for _, idx := range ix {
d.delete(testVals[idx])
}
for _, idx := range ix {
if d.exist(testVals[idx]) {
t.Errorf("%s should have not existed!", testVals[idx])
}
}
}()
}
func genRandomGenSparseVectorInt(m int) *GenSparseVector {
l := m * 3 / 4
values := make([]Value, l)
for i, v := range rand.Perm(m)[:l] {
values[i] = Value(v)
}
return NewGenSparseVector(IntIndex(rand.Perm(m)[:l]), values)
}
func doStuff(id int,
res chan<- Result,
wg *sync.WaitGroup,
body []byte,
prot, addr string) {
defer wg.Done()
localstats := [256]int64{}
keys := make([][]byte, *nkeys / *concurrency)
vbuckets := make([]uint16, *nvbuckets)
for i := 0; i < len(keys); i++ {
keys[i] = []byte(fmt.Sprintf("c%d.k%d", id, i))
vbuckets = append(vbuckets, uint16(rand.Intn(*nvbuckets)))
}
client, err := memcached.Connect(prot, addr)
if err != nil {
log.Printf("Error connecting to %v/%v: %v", prot, addr, err)
return
}
go handleResponses(client, res)
applyLocalStats := func() {
for j, v := range localstats {
atomic.AddInt64(&stats[j], v)
localstats[j] = 0
}
}
cmdi := 0
ids := rand.Perm(len(keys))
for {
for i, thisId := range ids {
key := keys[thisId]
opcode := cmds.cmds[cmdi]
sendCommand(client, opcode, vbuckets[thisId], key, body)
localstats[opcode]++
if i%1000 == 0 {
applyLocalStats()
if atomic.LoadInt32(&isDone) == 1 {
return
}
}
}
applyLocalStats()
cmdi++
if cmdi >= len(cmds.cmds) {
cmdi = 0
ids = rand.Perm(len(keys))
}
}
}
func RandomCubieCube() CubieCube {
var res CubieCube
// Generate a random permutation for the corners.
pieces := rand.Perm(8)
for i, x := range pieces {
res.Corners[i].Piece = x
}
// Generate a random permutation for the edges.
cornerParity := parity(pieces)
pieces = rand.Perm(12)
for i, x := range pieces {
res.Edges[i].Piece = x
}
// Make sure the overall parity is even.
if cornerParity != parity(pieces) {
res.Edges[11], res.Edges[10] = res.Edges[10], res.Edges[11]
}
// Generate edge orientations.
lastFlip := false
for i := 0; i < 11; i++ {
if rand.Intn(2) == 0 {
lastFlip = !lastFlip
res.Edges[i].Flip = true
}
}
res.Edges[11].Flip = lastFlip
// Generate the corner orientations.
for i := 0; i < 7; i++ {
res.Corners[i].Orientation = rand.Intn(3)
}
var orientations [8]int
for i, x := range []int{0, 1, 5, 4, 6, 2, 3, 7} {
orientations[i] = res.Corners[x].Orientation
}
for i := 0; i < 7; i++ {
thisOrientation := orientations[i]
nextOrientation := orientations[i+1]
if thisOrientation == 2 {
orientations[i+1] = (nextOrientation + 2) % 3
} else if thisOrientation == 0 {
orientations[i+1] = (nextOrientation + 1) % 3
}
}
if orientations[7] == 0 {
res.Corners[7].Orientation = 2
} else if orientations[7] == 2 {
res.Corners[7].Orientation = 0
}
return res
}
func BenchmarkFind(b *testing.B) {
bst := new(T)
for _, i := range rand.Perm(b.N) {
bst.Insert(i, i)
}
b.ResetTimer()
for _, i := range rand.Perm(b.N) {
bst.Find(i)
}
}
func genRandomSparseVector(m int) *SparseVectorUint32 {
l := m * 3 / 4
values := make([]Value, l)
for i, v := range rand.Perm(m)[:l] {
values[i] = Value(v)
}
index := make([]uint32, l)
for i, v := range rand.Perm(m)[:l] {
index[i] = uint32(v)
}
return NewSparseVectorUint32(index, values)
}
func main() {
rand.Seed(time.Now().UnixNano())
indices := rand.Perm(len(SOURCE))
var output string
for i := 0; i < 50; i++ {
if i != 0 && i%7 == 0 {
indices = rand.Perm(len(SOURCE))
}
output += fmt.Sprintf("%c", SOURCE[indices[i%7]])
}
fmt.Println(output)
}
func (r *roler) openReplicaRole(shardToMasterAddress map[int]route.Address, shardToReplicaAddress map[int]map[int]route.Address) (int, int, bool) {
for _, shard := range rand.Perm(r.sharder.NumShards()) {
addresses := shardToReplicaAddress[shard]
if len(addresses) < r.numReplicas && !r.hasRoleForShard(shard, shardToMasterAddress, shardToReplicaAddress) {
for _, index := range rand.Perm(r.numReplicas) {
if _, ok := addresses[index]; !ok {
return shard, index, true
}
}
}
}
return 0, 0, false
}
func genRandomGenSparseVectorUint32(m int) *GenSparseVector {
l := m * 3 / 4
values := make([]Value, l)
for i, v := range rand.Perm(m)[:l] {
values[i] = Value(v)
}
index := make(Uint32Index, l)
for i, v := range rand.Perm(m)[:l] {
index[i] = uint32(v)
}
return NewGenSparseVector(index, values)
}
func buildFlowGraph(params VbmapParams) (g *Graph) {
graphName := fmt.Sprintf("Flow graph for RI (%s)", params)
g = NewGraph(graphName)
tags := params.Tags.TagsList()
tagsNodes := params.Tags.TagsNodesMap()
maxReplicationsPerTag := 0
if params.NumReplicas != 0 {
maxReplicationsPerTag = params.NumSlaves / params.NumReplicas
}
nodes := params.Nodes()
for _, nodeIx := range rand.Perm(len(nodes)) {
node := nodes[nodeIx]
nodeTag := params.Tags[node]
nodeSrcV := NodeSourceVertex(node)
nodeSinkV := NodeSinkVertex(node)
g.AddEdge(Source, nodeSrcV, params.NumSlaves, params.NumSlaves)
g.AddEdge(nodeSinkV, Sink, params.NumSlaves, 0)
for _, tagIx := range rand.Perm(len(tags)) {
tag := tags[tagIx]
if tag == nodeTag {
continue
}
tagNodesCount := len(tagsNodes[tag])
tagCapacity := Min(tagNodesCount, maxReplicationsPerTag)
tagV := TagVertex(tag)
g.AddEdge(nodeSrcV, tagV, tagCapacity, 0)
}
}
for _, tagIx := range rand.Perm(len(tags)) {
tag := tags[tagIx]
tagNodes := tagsNodes[tag]
tagV := TagVertex(tag)
for _, tagNode := range tagNodes {
tagNodeV := NodeSinkVertex(tagNode)
g.AddEdge(tagV, tagNodeV, params.NumSlaves, 0)
}
}
return
}
func TestBinaryTreeAddDelete(t *testing.T) {
const count = 100
const sub = 20
for i := 0; i < 10; i++ {
tree := Tree{Compare: func(a, b interface{}) ComparisonResult {
aa := a.(int)
bb := b.(int)
switch {
case aa < bb:
return Less
case aa > bb:
return Greater
default:
return Equal
}
}}
list := rand.Perm(count)
for _, j := range list {
if e := tree.Add(j); e != nil {
t.Error(e)
}
}
for k := 0; k < 10; k++ {
list = rand.Perm(sub)
a := rand.Intn(count - sub)
for _, j := range list {
if e := tree.Delete(a + j); e != nil {
t.Error(e)
}
}
list = rand.Perm(sub)
for _, j := range list {
if e := tree.Add(a + j); e != nil {
t.Error(e)
}
}
}
ch := make(chan interface{})
go func() {
tree.Root.Walk(ch)
close(ch)
}()
for j := 0; j < count; j++ {
k := (<-ch).(int)
if k != j {
t.Errorf("%d != %d", k, j)
}
}
}
}
func TestRandomAllocateDeallocate(t *testing.T) {
ds, err := randomLocalStore()
if err != nil {
t.Fatal(err)
}
numBits := int(16 * blockLen)
hnd, err := NewHandle("bitseq-test/data/", ds, "test1", uint64(numBits))
if err != nil {
t.Fatal(err)
}
seed := time.Now().Unix()
rand.Seed(seed)
// Allocate all bits using a random pattern
pattern := rand.Perm(numBits)
for _, bit := range pattern {
err := hnd.Set(uint64(bit))
if err != nil {
t.Fatalf("Unexpected failure on allocation of %d: %v.\nSeed: %d.\n%s", bit, err, seed, hnd)
}
}
if hnd.Unselected() != 0 {
t.Fatalf("Expected full sequence. Instead found %d free bits. Seed: %d.\n%s", hnd.unselected, seed, hnd)
}
if hnd.head.toString() != "(0xffffffff, 16)->end" {
t.Fatalf("Unexpected db: %s", hnd.head.toString())
}
// Deallocate all bits using a random pattern
pattern = rand.Perm(numBits)
for _, bit := range pattern {
err := hnd.Unset(uint64(bit))
if err != nil {
t.Fatalf("Unexpected failure on deallocation of %d: %v.\nSeed: %d.\n%s", bit, err, seed, hnd)
}
}
if hnd.Unselected() != uint64(numBits) {
t.Fatalf("Expected full sequence. Instead found %d free bits. Seed: %d.\n%s", hnd.unselected, seed, hnd)
}
if hnd.head.toString() != "(0x0, 16)->end" {
t.Fatalf("Unexpected db: %s", hnd.head.toString())
}
err = hnd.Destroy()
if err != nil {
t.Fatal(err)
}
}
func BenchmarkRemove(b *testing.B) {
// Create some initial data and fill the set
data := rand.Perm(b.N)
set := New()
for _, val := range data {
set.Insert(val)
}
// Execute the benchmark (different order)
rems := rand.Perm(b.N)
b.ResetTimer()
for _, val := range rems {
set.Remove(val)
}
}
func TestRandomReplace(t *testing.T) {
tree := New(NaturalSortLessInt)
n := 100
perm := rand.Perm(n)
for i := 0; i < n; i++ {
tree.ReplaceOrInsert(Int(perm[i]))
}
perm = rand.Perm(n)
for i := 0; i < n; i++ {
if replaced := tree.ReplaceOrInsert(Int(perm[i])); replaced == nil || replaced.(Int) != Int(perm[i]) {
t.Errorf("error replacing")
}
}
}
func TestRandomReplace(t *testing.T) {
tree := NewLLRB()
n := 100
perm := rand.Perm(n)
for i := 0; i < n; i++ {
tree.Upsert(&KeyInt{int64(perm[i]), -1})
}
perm = rand.Perm(n)
for i := 0; i < n; i++ {
replaced := tree.Upsert(&KeyInt{int64(perm[i]), -1})
if replaced == nil || replaced.(*KeyInt).Key != int64(perm[i]) {
t.Errorf("error replacing")
}
}
}
//Generate a random MapData given some dimensions
func generate_map(n int) *MapData {
map_data := *NewMapData(n, n)
map_data[0][0] = START
map_data[n-1][n-1] = STOP
xs := rand.Perm(n - 1)
ys := rand.Perm(n - 1)
for i := 1; i < len(xs); i += rand.Intn(4) + 1 {
for j := 1; j < len(ys); j++ {
map_data[xs[i]][ys[j]] = WALL
}
}
return &map_data
}
func TestRandomReplace(t *testing.T) {
tree := New()
n := 100
perm := rand.Perm(n)
for i := 0; i < n; i++ {
tree.ReplaceOrInsert(uint64(perm[i]))
}
perm = rand.Perm(n)
for i := 0; i < n; i++ {
v := uint64(perm[i])
if replaced := tree.ReplaceOrInsert(v); !replaced {
t.Errorf("error replacing")
}
}
}
func BenchmarkExist(b *testing.B) {
b.StopTimer()
var d Interface
if opt == "slice" {
d = newMapToSlice()
} else {
d = newMapToMap()
}
k := "A"
for _, v := range testVals {
d.set(k, v)
}
// to make it not biased towards data structures
// with an order, such as slice.
ix := rand.Perm(testN)
b.StartTimer()
b.ReportAllocs()
for _, idx := range ix {
if !d.exist(k, testVals[idx]) {
b.Errorf("%s should have existed!", testVals[idx])
}
}
}
func (options *ScanOptions) SSLMatchHosts(conn *tls.Conn) []string {
hosts := make([]string, 0)
options.hostsMutex.Lock()
for _, host := range options.inputHosts {
testhost := host.Host
if strings.Contains(testhost, ".appspot.com") {
testhost = "appengine.google.com"
} else if strings.Contains(testhost, "ggpht.com") {
testhost = "googleusercontent.com"
} else if strings.Contains(testhost, ".books.google.com") {
testhost = "books.google.com"
} else if strings.Contains(testhost, ".googleusercontent.com") {
testhost = "googleusercontent.com"
}
if conn.VerifyHostname(testhost) == nil {
hosts = append(hosts, host.Host)
}
}
options.hostsMutex.Unlock()
dest := make([]string, len(hosts))
perm := rand.Perm(len(hosts))
for i, v := range perm {
dest[v] = hosts[i]
}
hosts = dest
return hosts
}
func Generate(name string) Course {
holes := make([]Hole, 18)
for index, pos := range rand.Perm(18) {
holes[index] = GenerateHole(pars[pos])
}
return Course{Name: name, Par: 72, Holes: holes}
}
func getExternalIP() net.IP {
var currentIP net.IP
for _, i := range rand.Perm(len(urls)) {
if verbose {
fmt.Printf("Connecting to %v...\n", urls[i])
}
url := "http://" + urls[i]
content, err := getResponse(url)
if err != nil {
if verbose {
fmt.Printf("%v\n", err)
}
continue
}
ip := regex.FindString(content)
currentIP = net.ParseIP(ip)
if currentIP != nil {
return currentIP
}
fmt.Println("No valid IP address could be parsed from response.")
}
return currentIP
}
func TestBinaryTreeDelete(t *testing.T) {
keys := rand.Perm(5217)
tree := new(BinaryTree)
for _, i := range keys {
tree.Set(i, fmt.Sprintf("format_%d", i))
}
for _, i := range keys {
if _, err := tree.Get(i); err != nil {
t.Error(err.Error())
}
}
for _, i := range keys {
tree.Delete(i)
if _, err := tree.Get(i); err == nil {
t.Error("Найдено, а не должно бы")
}
}
}
func generatePermSet(mode int) []int {
if mode == 0 {
return rand.Perm(1000)
}
return make([]int, 0)
}