func TestUTPPingPong(t *testing.T) { defer goroutineLeakCheck(t)() s, err := NewSocket("udp", "localhost:0") require.NoError(t, err) defer s.Close() pingerClosed := make(chan struct{}) go func() { defer close(pingerClosed) b, err := Dial(s.Addr().String()) require.NoError(t, err) defer b.Close() n, err := b.Write([]byte("ping")) require.NoError(t, err) require.EqualValues(t, 4, n) buf := make([]byte, 4) b.Read(buf) require.EqualValues(t, "pong", buf) log.Printf("got pong") }() a, err := s.Accept() require.NoError(t, err) defer a.Close() log.Printf("accepted %s", a) buf := make([]byte, 42) n, err := a.Read(buf) require.NoError(t, err) require.EqualValues(t, "ping", buf[:n]) log.Print("got ping") n, err = a.Write([]byte("pong")) require.NoError(t, err) require.Equal(t, 4, n) log.Print("waiting for pinger to close") <-pingerClosed }
func (s *watcherTestSuite) Test_DynamicUpdateRestoresGoodState() { someInt := flagz.DynInt64(s.flagSet, "someint", 1337, "some int usage") someFloat := flagz.DynFloat64(s.flagSet, "somefloat", 1.337, "some int usage") s.setFlagzValue("someint", "2015") require.NoError(s.T(), s.watcher.Initialize()) require.NoError(s.T(), s.watcher.Start()) require.EqualValues(s.T(), 2015, someInt.Get(), "int flag should change value") require.EqualValues(s.T(), 1.337, someFloat.Get(), "float flag should not change value") // Bad update causing a rollback. s.setFlagzValue("someint", "randombleh") eventually(s.T(), 1*time.Second, assert.ObjectsAreEqualValues, "2015", func() interface{} { return s.getFlagzValue("someint") }, "someint failure should revert etcd value to 2015") // Make sure we can continue updating. s.setFlagzValue("someint", "2016") s.setFlagzValue("somefloat", "3.14") eventually(s.T(), 1*time.Second, assert.ObjectsAreEqualValues, int64(2016), func() interface{} { return someInt.Get() }, "someint value should change, after rolled back") eventually(s.T(), 1*time.Second, assert.ObjectsAreEqualValues, float64(3.14), func() interface{} { return someFloat.Get() }, "somefloat value should change") }
func TestTransactionSingleConnection(t *testing.T) { db, _ := sql.Open("sqlrpc", serverAddr) defer db.Close() db.Exec("drop table if exists a") tx, _ := db.Begin() tx.Exec("create table a(b)") tx.Exec("insert into a values(?)", 1) t.Log(time.Now()) row := tx.QueryRow("select * from a where b < ?", 2) var i int err := row.Scan(&i) t.Log(time.Now()) require.NoError(t, err) require.EqualValues(t, 1, i) tx.Exec("insert into a values(?)", 2) rows, err := tx.Query("select b from a where b > ?", 0) require.NoError(t, err) cols, _ := rows.Columns() require.EqualValues(t, []string{"b"}, cols) require.True(t, rows.Next()) rows.Scan(&i) require.EqualValues(t, 1, i) require.True(t, rows.Next()) rows.Scan(&i) require.EqualValues(t, 2, i) require.False(t, rows.Next()) tx.Rollback() }
func TestQuery(t *testing.T) { dir1, dir2, _, err := prepare() require.NoError(t, err) defer closeAll(dir1, dir2) // Parse GQL into internal query representation. gq, _, err := gql.Parse(q0) require.NoError(t, err) ctx := context.Background() g, err := query.ToSubGraph(ctx, gq) require.NoError(t, err) // Test internal query representation. require.EqualValues(t, childAttrs(g), []string{"follows", "_xid_", "status"}) require.EqualValues(t, childAttrs(g.Children[0]), []string{"_xid_", "status"}) ch := make(chan error) go query.ProcessGraph(ctx, g, nil, ch) err = <-ch require.NoError(t, err) var l query.Latency js, err := g.ToJSON(&l) require.NoError(t, err) fmt.Println(string(js)) }
// Ensure that no race exists between sending a bitfield, and a subsequent // Have that would potentially alter it. func TestSendBitfieldThenHave(t *testing.T) { r, w := io.Pipe() c := &connection{ t: &Torrent{ cl: &Client{}, }, rw: struct { io.Reader io.Writer }{r, w}, outgoingUnbufferedMessages: list.New(), } go c.writer(time.Minute) c.mu().Lock() c.Bitfield([]bool{false, true, false}) c.mu().Unlock() c.mu().Lock() c.Have(2) c.mu().Unlock() b := make([]byte, 15) n, err := io.ReadFull(r, b) c.mu().Lock() // This will cause connection.writer to terminate. c.closed.Set() c.mu().Unlock() require.NoError(t, err) require.EqualValues(t, 15, n) // Here we see that the bitfield doesn't have piece 2 set, as that should // arrive in the following Have message. require.EqualValues(t, "\x00\x00\x00\x02\x05@\x00\x00\x00\x05\x04\x00\x00\x00\x02", string(b)) }
func TestSnapshot(t *testing.T) { path, err := ioutil.TempDir("", "storetest_") require.NoError(t, err) defer os.RemoveAll(path) s, err := NewStore(path) require.NoError(t, err) k := []byte("mykey") require.NoError(t, s.SetOne(k, []byte("neo"))) snapshot := s.NewSnapshot() // Snapshot will contain neo, not trinity. require.NoError(t, s.SetOne(k, []byte("trinity"))) // Before setting snapshot, do a get. Expect to get trinity. val, err := s.Get(k) require.NoError(t, err) require.EqualValues(t, val.Data(), "trinity") s.SetSnapshot(snapshot) // After setting snapshot, we expect to get neo. val, err = s.Get(k) require.NoError(t, err) require.EqualValues(t, val.Data(), "neo") s.SetSnapshot(nil) // After clearing snapshot, we expect to get trinity again. val, err = s.Get(k) require.NoError(t, err) require.EqualValues(t, val.Data(), "trinity") }
func TestSortInts(t *testing.T) { list := getInput(Int32ID, []string{"22", "111", "11", "212"}) ul := getUIDList(4) require.NoError(t, int32Type.Sort(list, ul, false)) require.EqualValues(t, []uint64{300, 100, 200, 400}, ul.Uids) require.EqualValues(t, []string{"11", "22", "111", "212"}, toString(t, list)) }
func TestSortByteArrays(t *testing.T) { list := getInput(BytesID, []string{"bb", "aaa", "aa", "bab"}) ul := getUIDList(4) require.NoError(t, byteArrayType.Sort(list, ul, false)) require.EqualValues(t, []uint64{300, 200, 400, 100}, ul.Uids) require.EqualValues(t, []string{"aa", "aaa", "bab", "bb"}, toString(t, list)) }
func TestUnmarshalPex(t *testing.T) { var pem peerExchangeMessage err := bencode.Unmarshal([]byte("d5:added12:\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0ce"), &pem) require.NoError(t, err) require.EqualValues(t, 2, len(pem.Added)) require.EqualValues(t, 1286, pem.Added[0].Port) require.EqualValues(t, 0x100*0xb+0xc, pem.Added[1].Port) }
func TestAddMutation_jchiu3(t *testing.T) { key := x.DataKey("value", 10) dir, err := ioutil.TempDir("", "storetest_") require.NoError(t, err) defer os.RemoveAll(dir) ps, err := store.NewStore(dir) require.NoError(t, err) Init(ps) ol := getNew(key, ps) // Set value to cars and merge to RocksDB. edge := &task.DirectedEdge{ Value: []byte("cars"), Label: "jchiu", } addMutation(t, ol, edge, Set) require.Equal(t, 1, ol.Length(0)) merged, err := ol.CommitIfDirty(context.Background()) require.NoError(t, err) require.True(t, merged) require.EqualValues(t, 1, ol.Length(0)) checkValue(t, ol, "cars") // Del a value cars and but don't merge. edge = &task.DirectedEdge{ Value: []byte("cars"), Label: "jchiu", } addMutation(t, ol, edge, Del) require.Equal(t, 0, ol.Length(0)) // Set value to newcars, but don't merge yet. edge = &task.DirectedEdge{ Value: []byte("newcars"), Label: "jchiu", } addMutation(t, ol, edge, Set) require.EqualValues(t, 1, ol.Length(0)) checkValue(t, ol, "newcars") // Del a value othercars and but don't merge. edge = &task.DirectedEdge{ Value: []byte("othercars"), Label: "jchiu", } addMutation(t, ol, edge, Del) require.NotEqual(t, 0, ol.Length(0)) checkValue(t, ol, "newcars") // Del a value newcars and but don't merge. edge = &task.DirectedEdge{ Value: []byte("newcars"), Label: "jchiu", } addMutation(t, ol, edge, Del) require.Equal(t, 0, ol.Length(0)) }
func TestSortFloatsDesc(t *testing.T) { list := getInput(FloatID, []string{"22.2", "11.2", "11.5", "2.12"}) ul := getUIDList(4) require.NoError(t, floatType.Sort(list, ul, true)) require.EqualValues(t, []uint64{100, 300, 200, 400}, ul.Uids) require.EqualValues(t, []string{"2.22E+01", "1.15E+01", "1.12E+01", "2.12E+00"}, toString(t, list)) }
func TestSortDates(t *testing.T) { in := []string{"2022-01-01", "2022-02-03", "2021-01-05", "2021-01-07"} list := getInput(DateID, in) ul := getUIDList(4) require.NoError(t, dateType.Sort(list, ul, false)) require.EqualValues(t, []uint64{300, 400, 100, 200}, ul.Uids) require.EqualValues(t, []string{"2021-01-05", "2021-01-07", "2022-01-01", "2022-02-03"}, toString(t, list)) }
func TestMarshalAnnounceResponse(t *testing.T) { peers := util.CompactIPv4Peers{ {[]byte{127, 0, 0, 1}, 2}, {[]byte{255, 0, 0, 3}, 4}, } b, err := peers.MarshalBinary() require.NoError(t, err) require.EqualValues(t, "\x7f\x00\x00\x01\x00\x02\xff\x00\x00\x03\x00\x04", b) require.EqualValues(t, 12, binary.Size(AnnounceResponseHeader{})) }
func TestDecoderConsecutive(t *testing.T) { d := NewDecoder(bytes.NewReader([]byte("i1ei2e"))) var i int err := d.Decode(&i) require.NoError(t, err) require.EqualValues(t, 1, i) err = d.Decode(&i) require.NoError(t, err) require.EqualValues(t, 2, i) err = d.Decode(&i) require.Equal(t, io.EOF, err) }
func TestKeys(t *testing.T) { k, ok := Keys(map[string]string{"hi": "", "ho": ""}) require.True(t, ok) require.EqualValues(t, []string{"hi", "ho"}, k) k, ok = Keys(map[int]string{2: "", 3: ""}) require.False(t, ok) k, ok = Keys(TestStruct{}) require.True(t, ok) require.EqualValues(t, []string{"A1", "A2"}, k) k, ok = Keys(TestStruct2{}) require.True(t, ok) require.EqualValues(t, []string{"A2", "lol"}, k) }
func TestSortDateTimes(t *testing.T) { in := []string{ "2016-01-02T15:04:05", "2006-01-02T15:04:05", "2006-01-02T15:04:06", "2006-01-02T15:04:01", } list := getInput(DateTimeID, in) ul := getUIDList(4) require.NoError(t, dateTimeType.Sort(list, ul, false)) require.EqualValues(t, []uint64{400, 200, 300, 100}, ul.Uids) require.EqualValues(t, []string{"2006-01-02T15:04:01Z", "2006-01-02T15:04:05Z", "2006-01-02T15:04:06Z", "2016-01-02T15:04:05Z"}, toString(t, list)) }
func TestDescriptorTransform(t *testing.T) { hSink := dummySink() ld := core.LabelDescriptor{ Key: "k1", Description: "d1", } smd := core.MetricDescriptor{ Name: "test/metric/1", Units: core.UnitsBytes, ValueType: core.ValueInt64, Type: core.MetricGauge, Labels: []core.LabelDescriptor{ld}, } md := hSink.descriptorToDefinition(&smd) assert.Equal(t, smd.Name, md.Id) assert.Equal(t, 3, len(md.Tags)) // descriptorTag, unitsTag, typesTag, k1 assert.Equal(t, smd.Units.String(), md.Tags[unitsTag]) assert.Equal(t, "d1", md.Tags["k1_description"]) smd.Type = core.MetricCumulative md = hSink.descriptorToDefinition(&smd) assert.EqualValues(t, md.Type, metrics.Counter) }
func testCycle(t *testing.T, base interface{}, ff interface{}) { setXValue(t, base) buf, err := json.MarshalIndent(base, " ", " ") require.NoError(t, err, "base[%T] failed to Marshal", base) ffDst := emptyInterface(ff) baseDst := emptyInterface(base) err = json.Unmarshal(buf, ffDst) errGo := json.Unmarshal(buf, baseDst) if outputFileOnError && err != nil { typeName := reflect.Indirect(reflect.ValueOf(base)).Type().String() file, err := os.Create(fmt.Sprintf("fail-%s-unmarshal-decoder-input.json", typeName)) if err == nil { file.Write(buf) file.Close() } if errGo == nil { file, err := os.Create(fmt.Sprintf("fail-%s-unmarshal-decoder-output-base.txt", typeName)) if err == nil { fmt.Fprintf(file, "%#v", baseDst) file.Close() } } } require.Nil(t, err, "json.Unmarshal of encoded ff[%T],\nErrors golang:%v,\nffjson:%v", ff, errGo, err) require.Nil(t, errGo, "json.Unmarshal of encoded ff[%T],\nerrors golang:%v,\nffjson:%v", base, errGo, err) require.EqualValues(t, baseDst, ffDst, "json.Unmarshal of base[%T] into ff[%T]", base, ff) }
func TestDebug1(t *testing.T) { dir, dir2, _ := populateGraph(t) defer os.RemoveAll(dir) defer os.RemoveAll(dir2) // Alright. Now we have everything set up. Let's create the query. query := ` { debug(_uid_:0x01) { name gender alive friend { _count_ } } } ` js := processToJSON(t, query) var mp map[string]interface{} require.NoError(t, json.Unmarshal([]byte(js), &mp)) resp := mp["debug"] uid := resp.([]interface{})[0].(map[string]interface{})["_uid_"].(string) require.EqualValues(t, "0x1", uid) latency := mp["server_latency"] require.NotNil(t, latency) _, ok := latency.(map[string]interface{}) require.True(t, ok) }
// writes 25,000 metrics to the listener with 10 different writers func TestWriteHTTPHighTraffic(t *testing.T) { listener := &HttpListener{ServiceAddress: ":8286"} parser, _ := parsers.NewInfluxParser() listener.SetParser(parser) acc := &testutil.Accumulator{} require.NoError(t, listener.Start(acc)) defer listener.Stop() time.Sleep(time.Millisecond * 25) // post many messages to listener var wg sync.WaitGroup for i := 0; i < 10; i++ { wg.Add(1) go func() { for i := 0; i < 500; i++ { resp, err := http.Post("http://localhost:8286/write?db=mydb", "", bytes.NewBuffer([]byte(testMsgs))) require.NoError(t, err) require.EqualValues(t, 204, resp.StatusCode) } wg.Done() }() } wg.Wait() time.Sleep(time.Millisecond * 50) listener.Gather(acc) require.Equal(t, int64(25000), int64(acc.NMetrics())) }
func TestToProtoMultiRoot(t *testing.T) { dir, dir2, _ := populateGraph(t) defer os.RemoveAll(dir) defer os.RemoveAll(dir2) query := ` { me(anyof("name", "Michonne Rick Glenn")) { name } } ` gq, _, err := gql.Parse(query) require.NoError(t, err) ctx := context.Background() sg, err := ToSubGraph(ctx, gq) require.NoError(t, err) ch := make(chan error) go ProcessGraph(ctx, sg, nil, ch) err = <-ch require.NoError(t, err) var l Latency pb, err := sg.ToProtocolBuffer(&l) require.NoError(t, err) expectedPb := `attribute: "_root_" children: < attribute: "me" properties: < prop: "name" value: < str_val: "Michonne" > > > children: < attribute: "me" properties: < prop: "name" value: < str_val: "Rick Grimes" > > > children: < attribute: "me" properties: < prop: "name" value: < str_val: "Glenn Rhee" > > > ` require.EqualValues(t, expectedPb, proto.MarshalTextString(pb)) }
func assertFailedEntry(t *testing.T, expected string, entries []crossdock.Entry) { require.True(t, len(entries) > 0, "Must have some entries %+v", entries) entry := entries[len(entries)-1] require.EqualValues(t, "failed", entry["status"], "Entries: %v", entries) require.NotEmpty(t, entry["output"], "Entries: %v", entries) output := entry["output"].(string) assert.True(t, strings.Contains(output, expected), "Output must contain %s: %s", expected, output) }
func (s *endpointTestSuite) assertListContainsOnly(flagList []string, list *flagSetJSON) { existing := []string{} for _, f := range list.Flags { existing = append(existing, f.Name) } sort.Strings(flagList) require.EqualValues(s.T(), flagList, existing, "expected set of listed flags must match") }
func TestParseArgs(t *testing.T) { t.Log("simple plugin command") { args := []string{"bitrise", ":example"} pluginName, pluginArgs, isPlugin := ParseArgs(args) require.Equal(t, true, isPlugin) require.Equal(t, "example", pluginName) require.Equal(t, 0, len(pluginArgs)) } t.Log("simple plugin command - with bitrise flags") { args := []string{"bitrise", "-l", "debug", ":example"} pluginName, pluginArgs, isPlugin := ParseArgs(args) require.Equal(t, true, isPlugin) require.Equal(t, "example", pluginName) require.Equal(t, 0, len(pluginArgs)) } t.Log("plugin command - with args") { args := []string{"bitrise", ":example", "hello", "bitrise"} pluginName, pluginArgs, isPlugin := ParseArgs(args) require.Equal(t, true, isPlugin) require.Equal(t, "example", pluginName) require.EqualValues(t, []string{"hello", "bitrise"}, pluginArgs) } t.Log("plugin command - with falg") { args := []string{"bitrise", ":example", "hello", "--name", "bitrise"} pluginName, pluginArgs, isPlugin := ParseArgs(args) require.Equal(t, true, isPlugin) require.Equal(t, "example", pluginName) require.EqualValues(t, []string{"hello", "--name", "bitrise"}, pluginArgs) } t.Log("not plugin command") { args := []string{"bitrise", "hello", "bitrise"} pluginName, pluginArgs, isPlugin := ParseArgs(args) require.Equal(t, false, isPlugin) require.Equal(t, "", pluginName) require.Equal(t, 0, len(pluginArgs)) } }
func TestCancelRequestOptimized(t *testing.T) { r, w := io.Pipe() c := &connection{ PeerMaxRequests: 1, peerPieces: func() bitmap.Bitmap { var bm bitmap.Bitmap bm.Set(1, true) return bm }(), rw: struct { io.Reader io.Writer }{ Writer: w, }, conn: new(net.TCPConn), // For the locks t: &Torrent{cl: &Client{}}, } assert.Len(t, c.Requests, 0) c.Request(newRequest(1, 2, 3)) require.Len(t, c.Requests, 1) // Posting this message should removing the pending Request. require.True(t, c.Cancel(newRequest(1, 2, 3))) assert.Len(t, c.Requests, 0) // Check that write optimization filters out the Request, due to the // Cancel. We should have received an Interested, due to the initial // request, and then keep-alives until we close the connection. go c.writer(0) b := make([]byte, 9) n, err := io.ReadFull(r, b) require.NoError(t, err) require.EqualValues(t, len(b), n) require.EqualValues(t, "\x00\x00\x00\x01\x02"+"\x00\x00\x00\x00", string(b)) time.Sleep(time.Millisecond) c.mu().Lock() c.Close() c.mu().Unlock() w.Close() b, err = ioutil.ReadAll(r) require.NoError(t, err) // A single keep-alive will have gone through, as writer would be stuck // trying to flush it, and then promptly close. require.EqualValues(t, "\x00\x00\x00\x00", string(b)) }
func TestGroupByKey(t *testing.T) { var ks []byte gb := GroupBy(StringIterator("AAAABBBCCDAABBB"), nil) for gb.Next() { ks = append(ks, gb.Value().(Group).Key().(byte)) } t.Log(ks) require.EqualValues(t, "ABCDAB", ks) }
func TestDBGetChecksum(t *testing.T) { tempBaseDir, err := ioutil.TempDir("", "notary-test-") _, store := SetUpSQLite(t, tempBaseDir) defer os.RemoveAll(tempBaseDir) ts := data.SignedTimestamp{ Signatures: make([]data.Signature, 0), Signed: data.Timestamp{ SignedCommon: data.SignedCommon{ Type: data.TUFTypes[data.CanonicalTimestampRole], Version: 1, Expires: data.DefaultExpires(data.CanonicalTimestampRole), }, }, } j, err := json.Marshal(&ts) require.NoError(t, err) update := MetaUpdate{ Role: data.CanonicalTimestampRole, Version: 1, Data: j, } checksumBytes := sha256.Sum256(j) checksum := hex.EncodeToString(checksumBytes[:]) store.UpdateCurrent("gun", update) // create and add a newer timestamp. We're going to try and get the one // created above by checksum ts = data.SignedTimestamp{ Signatures: make([]data.Signature, 0), Signed: data.Timestamp{ SignedCommon: data.SignedCommon{ Type: data.TUFTypes[data.CanonicalTimestampRole], Version: 2, Expires: data.DefaultExpires(data.CanonicalTimestampRole), }, }, } newJ, err := json.Marshal(&ts) require.NoError(t, err) update = MetaUpdate{ Role: data.CanonicalTimestampRole, Version: 2, Data: newJ, } store.UpdateCurrent("gun", update) cDate, data, err := store.GetChecksum("gun", data.CanonicalTimestampRole, checksum) require.NoError(t, err) require.EqualValues(t, j, data) // the creation date was sometime wthin the last minute require.True(t, cDate.After(time.Now().Add(-1*time.Minute))) require.True(t, cDate.Before(time.Now().Add(5*time.Second))) }
func TestConvertToEdges(t *testing.T) { q1 := `_uid_:0x01 <type> _uid_:0x02 . _uid_:0x01 <character> _uid_:0x03 .` nquads, err := convertToNQuad(context.Background(), q1) require.NoError(t, err) mr, err := convertToEdges(context.Background(), nquads) require.NoError(t, err) require.EqualValues(t, len(mr.edges), 2) }
func TestGet(t *testing.T) { path, err := ioutil.TempDir("", "storetest_") require.NoError(t, err) defer os.RemoveAll(path) s, err := NewStore(path) require.NoError(t, err) k := []byte("mykey") require.NoError(t, s.SetOne(k, []byte("neo"))) val, err := s.Get(k) require.NoError(t, err) require.EqualValues(t, val.Data(), "neo") require.NoError(t, s.SetOne(k, []byte("the one"))) val, err = s.Get(k) require.NoError(t, err) require.EqualValues(t, val.Data(), "the one") }
func TestToProtoFilterAnd(t *testing.T) { dir, dir2, _ := populateGraph(t) defer os.RemoveAll(dir) defer os.RemoveAll(dir2) // Alright. Now we have everything set up. Let's create the query. query := ` { me(_uid_:0x01) { name gender friend @filter(anyof("name", "Andrea") && anyof("name", "Glenn Rhee")) { name } } } ` gq, _, err := gql.Parse(query) require.NoError(t, err) ctx := context.Background() sg, err := ToSubGraph(ctx, gq) require.NoError(t, err) ch := make(chan error) go ProcessGraph(ctx, sg, nil, ch) err = <-ch require.NoError(t, err) var l Latency pb, err := sg.ToProtocolBuffer(&l) require.NoError(t, err) expectedPb := `attribute: "_root_" children: < attribute: "me" properties: < prop: "name" value: < str_val: "Michonne" > > properties: < prop: "gender" value: < bytes_val: "female" > > > ` require.EqualValues(t, expectedPb, proto.MarshalTextString(pb)) }