// TestLP tests a real-valued linear programming example func TestLP(t *testing.T) { lp := NewLP(0, 2) lp.SetVerboseLevel(NEUTRAL) lp.SetColName(0, "x") lp.SetColName(1, "y") assert.Equal(t, "x", lp.ColName(0)) assert.Equal(t, "y", lp.ColName(1)) lp.AddConstraint([]float64{120.0, 210.0}, LE, 15000) lp.AddConstraintSparse([]Entry{Entry{Col: 0, Val: 110.0}, Entry{Col: 1, Val: 30.0}}, LE, 4000) lp.AddConstraintSparse([]Entry{Entry{Col: 1, Val: 1.0}, Entry{Col: 0, Val: 1.0}}, LE, 75) lp.SetObjFn([]float64{143, 60}) lp.SetMaximize() lpString := "/* Objective function */\nmax: +143 x +60 y;\n\n/* Constraints */\n+120 x +210 y <= 15000;\n+110 x +30 y <= 4000;\n+x +y <= 75;\n" assert.Equal(t, lpString, lp.WriteToString()) lp.Solve() delta := 0.000001 assert.InDelta(t, 6315.625, lp.Objective(), delta) vars := lp.Variables() assert.Equal(t, len(vars), 2) assert.InDelta(t, 21.875, vars[0], delta) assert.InDelta(t, 53.125, vars[1], delta) }
func TestDecodeLineString(t *testing.T) { data, _ := hex.DecodeString("02000202020808") geom, err := Decode(bytes.NewReader(data)) if err != nil { t.Fatalf("Failed to decode point geometry: err = %s", err) } t.Logf("Geom: %+v\n", geom) p, ok := geom.(*LineString) if !ok { t.Fatalf("Expected LineString geometry") } assert.Equal(t, LINESTRING, p.Type()) assert.Equal(t, XY, p.Dim()) assert.Equal(t, 2, len(p.Coords)) assert.InDelta(t, 1, p.Coords[0][0], 1e-6) assert.InDelta(t, 1, p.Coords[0][1], 1e-6) assert.InDelta(t, 5, p.Coords[1][0], 1e-6) assert.InDelta(t, 5, p.Coords[1][1], 1e-6) }
func TestTanhKernelShouldPass1(t *testing.T) { k := TanhKernel(1) // test different dot products which // should be valid // when constant is 0, default to -1.0 assert.InDelta(t, math.Tanh(1.0-1.0), k([]float64{ 0.0, 1.0, 1.0, 0.0, }, []float64{ 0.0, 1.0, 0.0, 0.0, }), 5e-4, "Dot product should be valid") assert.InDelta(t, math.Tanh(6.0-1.0), k([]float64{ 15.0, 1.0, -1.0, 0.0, }, []float64{ 1.0, 1.0, 10.0, 0.0, }), 5e-4, "Dot product should be valid") assert.InDelta(t, math.Tanh(-84.0-1.0), k([]float64{ 15.0, 1.0, -1.0, 0.0, }, []float64{ 1.0, 1.0, 100.0, 0.0, }), 5e-4, "Dot product should be valid") }
// TestThreeSpecsOneOverfull verifies that the scheduler behaves reasonably // if one work spec has more jobs than its weight suggests. func TestThreeSpecsOneOverfull(t *testing.T) { metas := map[string]*WorkSpecMeta{ "one": &WorkSpecMeta{ Weight: 1, PendingCount: 0, AvailableCount: 1000, }, "two": &WorkSpecMeta{ Weight: 5, PendingCount: 0, AvailableCount: 1000, }, "three": &WorkSpecMeta{ Weight: 1, PendingCount: 99, AvailableCount: 1000, }, } trials := 1000 counts := runScheduler(t, metas, trials) // This setup produces a negative score for "three"! "one" // should have a score of 100, and "two" 500, but "three" // should come up with // (weight * (total pending + 1)) - pending * total weight // 1 * 100 - 99 * 7 = 100 - 693 = -593 // and so "three" should basically just get ignored. assert.InDelta(t, trials*1/6, counts["one"], 3*stdDev(trials, 1, 6)) assert.InDelta(t, trials*5/6, counts["two"], 3*stdDev(trials, 5, 6)) }
func TestLinearRegression(t *testing.T) { // http://www.itl.nist.gov/div898/strd/lls/data/LINKS/DATA/Norris.dat data := [][]float64{{0.1, 0.2}, {338.8, 337.4}, {118.1, 118.2}, {888.0, 884.6}, {9.2, 10.1}, {228.1, 226.5}, {668.5, 666.3}, {998.5, 996.3}, {449.1, 448.6}, {778.9, 777.0}, {559.2, 558.2}, {0.3, 0.4}, {0.1, 0.6}, {778.1, 775.5}, {668.8, 666.9}, {339.3, 338.0}, {448.9, 447.5}, {10.8, 11.6}, {557.7, 556.0}, {228.3, 228.1}, {998.0, 995.8}, {888.8, 887.6}, {119.6, 120.2}, {0.3, 0.3}, {0.6, 0.3}, {557.6, 556.8}, {339.3, 339.1}, {888.0, 887.2}, {998.5, 999.0}, {778.9, 779.0}, {10.2, 11.1}, {117.6, 118.3}, {228.9, 229.2}, {668.4, 669.1}, {449.2, 448.9}, {0.2, 0.5}} var xArray []float64 var yArray []float64 for _, values := range data { xArray = append(xArray, values[1]) yArray = append(yArray, values[0]) } regression := NewRegression() regression.PushAll(xArray, yArray) m, c := regression.Coefficients() assert := assert.New(t) assert.InDelta(m, 1.0021168180204547, 10E-12, "slope is not equal to spec") assert.InDelta(c, -0.262323073774029, 10E-12, "intercept is not equal to spec within reason") }
// TestTwoUnequalSpecsWithWork verifies that the simplified scheduler // picks two equivalent work specs with very different weights, and // with some pending work. func TestTwoUnequalSpecsWithWork(t *testing.T) { metas := map[string]*WorkSpecMeta{ "one": &WorkSpecMeta{ Weight: 1, AvailableCount: 1000, }, "two": &WorkSpecMeta{ Weight: 10, PendingCount: 2, AvailableCount: 998, }, } trials := 1000 counts := runScheduler(t, metas, trials) // These actual ratios come from the way the scheduler makes // its choices. There are 2 work units pending, and there // will be 3 in total if one more is added. Work spec "one" // "wants" 1/11 of this total, or 3/11 in all. Work spec // "two" "wants" 10/11 of this total, or 30/11, but already // has 22/11 pending, so it "wants" 8/11 more. assert.InDelta(t, trials*3/11, counts["one"], 3*stdDev(trials, 3, 11)) assert.InDelta(t, trials*8/11, counts["two"], 3*stdDev(trials, 8, 11)) }
func testJobs(t *testing.T, hd *HealthD) { recorder := httptest.NewRecorder() request, _ := http.NewRequest("GET", "/healthd/jobs", nil) hd.apiRouter().ServeHTTP(recorder, request) assert.Equal(t, 200, recorder.Code) var resp ApiResponseJobs err := json.Unmarshal(recorder.Body.Bytes(), &resp) assert.NoError(t, err) assert.Equal(t, len(resp.Jobs), 1) job := resp.Jobs[0] assert.Equal(t, job.Name, "foo") assert.EqualValues(t, job.Count, 2) assert.EqualValues(t, job.CountSuccess, 1) assert.EqualValues(t, job.CountValidationError, 1) assert.EqualValues(t, job.CountError, 0) assert.EqualValues(t, job.CountPanic, 0) assert.EqualValues(t, job.CountJunk, 0) assert.EqualValues(t, job.NanosSum, 14443) assert.EqualValues(t, job.NanosMin, 5678) assert.EqualValues(t, job.NanosMax, 8765) assert.InDelta(t, job.NanosAvg, 7221.5, 0.01) assert.InDelta(t, job.NanosSumSquares, 1.09064909e+08, 0.01) assert.InDelta(t, job.NanosStdDev, 2182.8386, 0.01) }
func TestLinesWithSimilarAngle(t *testing.T) { examples := []struct { angle float64 lines []polarLine similar []polarLine other []polarLine }{ { angle: 0, lines: []polarLine{polarLine{Theta: 0, Distance: 1}, polarLine{Theta: 0, Distance: 1000}, polarLine{Theta: 0.49}, polarLine{Theta: 0.5}, polarLine{Theta: -0.49}, polarLine{Theta: -0.5}}, similar: []polarLine{polarLine{Theta: 0, Distance: 1}, polarLine{Theta: 0, Distance: 1000}, polarLine{Theta: 0.49}, polarLine{Theta: -0.49}}, other: []polarLine{polarLine{Theta: 0.5}, polarLine{Theta: -0.5}}, }, { angle: 2 * math.Pi, lines: []polarLine{polarLine{Theta: 0, Distance: 1}, polarLine{Theta: 0, Distance: 1000}, polarLine{Theta: 0.49}, polarLine{Theta: 0.5}, polarLine{Theta: -0.49}, polarLine{Theta: -0.5}}, similar: []polarLine{polarLine{Theta: 0, Distance: 1}, polarLine{Theta: 0, Distance: 1000}, polarLine{Theta: 0.49}, polarLine{Theta: -0.49}}, other: []polarLine{polarLine{Theta: 0.5}, polarLine{Theta: -0.5}}, }, { angle: math.Pi, lines: []polarLine{polarLine{Theta: math.Pi + 0, Distance: 1}, polarLine{Theta: math.Pi + 0, Distance: 1000}, polarLine{Theta: math.Pi + 0.49}, polarLine{Theta: math.Pi + 0.5}, polarLine{Theta: math.Pi - 0.49}, polarLine{Theta: math.Pi - 0.5}}, similar: []polarLine{polarLine{Theta: math.Pi + 0, Distance: 1}, polarLine{Theta: math.Pi + 0, Distance: 1000}, polarLine{Theta: math.Pi + 0.49}, polarLine{Theta: math.Pi - 0.49}}, other: []polarLine{polarLine{Theta: math.Pi + 0.5}, polarLine{Theta: math.Pi - 0.5}}, }, { angle: math.Pi, lines: []polarLine{polarLine{Theta: 0, Distance: 1}, polarLine{Theta: 0, Distance: 1000}, polarLine{Theta: 0.49}, polarLine{Theta: 0.5}, polarLine{Theta: -0.49}, polarLine{Theta: -0.5}}, similar: []polarLine{}, other: []polarLine{polarLine{Theta: 0, Distance: 1}, polarLine{Theta: 0, Distance: 1000}, polarLine{Theta: 0.49}, polarLine{Theta: 0.5}, polarLine{Theta: -0.49}, polarLine{Theta: -0.5}}, }, { angle: 0, lines: []polarLine{polarLine{Theta: 0, Distance: 1}, polarLine{Theta: 0, Distance: 1000}, polarLine{Theta: 0.49}, polarLine{Theta: -0.49}}, similar: []polarLine{polarLine{Theta: 0, Distance: 1}, polarLine{Theta: 0, Distance: 1000}, polarLine{Theta: 0.49}, polarLine{Theta: -0.49}}, other: []polarLine{}, }, } for _, tt := range examples { similar, other := linesWithSimilarAngle(tt.lines, tt.angle) if !assert.Len(t, similar, len(tt.similar)) { t.Logf("Got:\n%v\nexpecting:\n%v", similar, tt.similar) t.FailNow() } for i, line := range similar { assert.InDelta(t, tt.similar[i].Theta, line.Theta, thetaDelta) assert.Equal(t, tt.similar[i].Distance, line.Distance) } if !assert.Len(t, other, len(tt.other)) { t.Logf("Got:\n%v\nexpecting:\n%v", similar, tt.similar) t.FailNow() } for i, line := range other { assert.InDelta(t, tt.other[i].Theta, line.Theta, thetaDelta) assert.Equal(t, tt.other[i].Distance, line.Distance) } } }
// TestMIP tests a mixed-integer programming example func TestMIP(t *testing.T) { lp := NewLP(0, 4) lp.AddConstraintSparse([]Entry{{0, 1.0}, {1, 1.0}}, LE, 5.0) lp.AddConstraintSparse([]Entry{{0, 2.0}, {1, -1.0}}, GE, 0.0) lp.AddConstraintSparse([]Entry{{0, 1.0}, {1, 3.0}}, GE, 0.0) lp.AddConstraintSparse([]Entry{{2, 1.0}, {3, 1.0}}, GE, 0.5) lp.AddConstraintSparse([]Entry{{2, 1.0}}, GE, 1.1) lp.SetObjFn([]float64{-1.0, -2.0, 0.1, 3.0}) lp.SetInt(2, true) assert.Equal(t, lp.IsInt(2), true) lp.Solve() delta := 0.000001 assert.InDelta(t, -8.133333333, lp.Objective(), delta) vars := lp.Variables() assert.Equal(t, lp.NumCols(), 4) assert.Equal(t, len(vars), 4) assert.InDelta(t, 1.6666666666, vars[0], delta) assert.InDelta(t, 3.3333333333, vars[1], delta) assert.InDelta(t, 2.0, vars[2], delta) assert.InDelta(t, 0.0, vars[3], delta) }
func TestEncodePoint(t *testing.T) { expected := &geom.Point{ geom.Hdr{ Dim: geom.XYZ, Srid: 27700, }, []float64{-0.118340, 51.503475, -12.34567890}, } var sb bytes.Buffer err := Encode(expected, &sb) if err != nil { t.Fatalf("failed to marshal point: %s", err) } got := make(map[string]interface{}) err = json.Unmarshal(sb.Bytes(), &got) if err != nil { t.Fatalf("Failed to parse generated GeoJSON: error %s", err) } t.Logf("%s\n", string(sb.Bytes())) assert.Equal(t, "Point", got["type"]) coords := got["coordinates"].([]interface{}) assert.InDelta(t, -0.118340, coords[0].(float64), 1e-9) assert.InDelta(t, 51.503475, coords[1].(float64), 1e-9) assert.InDelta(t, -12.34567890, coords[2].(float64), 1e-9) }
func TestPolygon(t *testing.T) { datasets := []struct { data string srid uint32 dim geom.Dimension }{ {"002000000300006c340000000100000005403e0000000000004024000000000000404400000000000040440000000000004034000000000000404400000000000040240000000000004034000000000000403e0000000000004024000000000000", 27700, geom.XY}, // ewkb_xdr {"0103000020346c000001000000050000000000000000003e4000000000000024400000000000004440000000000000444000000000000034400000000000004440000000000000244000000000000034400000000000003e400000000000002440", 27700, geom.XY}, // ewkb_hdr {"00000000030000000100000005403e0000000000004024000000000000404400000000000040440000000000004034000000000000404400000000000040240000000000004034000000000000403e0000000000004024000000000000", 0, geom.XY}, // wkb_hdr {"010300000001000000050000000000000000003e4000000000000024400000000000004440000000000000444000000000000034400000000000004440000000000000244000000000000034400000000000003e400000000000002440", 0, geom.XY}, // wkb_xdr } for _, dataset := range datasets { t.Log("Decoding HEX String: DIM = ", dataset.dim, ", Data = ", dataset.data) data, err := hex.DecodeString(dataset.data) if err != nil { t.Fatal("Failed to decode HEX string: err = ", err) } r := bytes.NewReader(data) g, err := Decode(r) if err != nil { t.Fatal("Failed to parse Polygon: err = ", err) } assert.Equal(t, "polygon", g.Type()) polygon := g.(*geom.Polygon) t.Log(polygon) assert.Equal(t, dataset.dim, polygon.Dimension(), "Expected dim %v, but got %v ", dataset.dim, g.Dimension()) assert.Equal(t, dataset.srid, polygon.SRID(), "Expected srid %v, but got %v ", dataset.srid, g.SRID()) assert.Equal(t, 1, len(polygon.Rings)) lr := polygon.Rings[0] assert.Equal(t, 5, len(lr.Coordinates)) assert.InDelta(t, 30, lr.Coordinates[0][0], 1e-9) assert.InDelta(t, 10, lr.Coordinates[0][1], 1e-9) assert.InDelta(t, 40, lr.Coordinates[1][0], 1e-9) assert.InDelta(t, 40, lr.Coordinates[1][1], 1e-9) assert.InDelta(t, 20, lr.Coordinates[2][0], 1e-9) assert.InDelta(t, 40, lr.Coordinates[2][1], 1e-9) assert.InDelta(t, 10, lr.Coordinates[3][0], 1e-9) assert.InDelta(t, 20, lr.Coordinates[3][1], 1e-9) assert.InDelta(t, 30, lr.Coordinates[4][0], 1e-9) assert.InDelta(t, 10, lr.Coordinates[4][1], 1e-9) } }
func assertEqualColours(t *testing.T, expected *Colour, c *Colour) { assert := assert.New(t) colourEpsilon := 0.0001 assert.InDelta(expected.R, c.R, colourEpsilon) assert.InDelta(expected.G, c.G, colourEpsilon) assert.InDelta(expected.B, c.B, colourEpsilon) }
func TestEncodeMultiPoint(t *testing.T) { expected := &geom.MultiPoint{ geom.Hdr{ Dim: geom.XY, Srid: 4326, }, []geom.Point{ { geom.Hdr{ Dim: geom.XY, Srid: 4326, }, []float64{-105.01621, 39.57422}, }, { geom.Hdr{ Dim: geom.XY, Srid: 4326, }, []float64{-80.6665134, 35.0539943}, }, }, } var sb bytes.Buffer err := Encode(expected, &sb) if err != nil { t.Fatalf("failed to marshal MultiPoint: %s", err) } got := make(map[string]interface{}) err = json.Unmarshal(sb.Bytes(), &got) if err != nil { t.Fatalf("Failed to parse generated GeoJSON: error %s", err) } t.Logf("%s\n", string(sb.Bytes())) assert.Equal(t, "MultiPoint", got["type"]) coords := got["coordinates"].([]interface{}) assert.Equal(t, 2, len(coords)) coord := coords[0].([]interface{}) for idx, value := range expected.Points[0].Coordinate { assert.InDelta(t, value, coord[idx].(float64), 1e-9) } coord = coords[1].([]interface{}) for idx, value := range expected.Points[1].Coordinate { assert.InDelta(t, value, coord[idx].(float64), 1e-9) } }
func TestNormalising(t *testing.T) { assert := assert.New(t) v := NewVec3(1, 2, 3) normalised := v.Normalised() v.Normalise() assert.InDelta(1, v.Length(), Epsilon, "Normalising should make vector's lenght 1") assert.InDelta(1, normalised.Length(), Epsilon, "Normalised should return vector with length 1") }
func TestOnlineOneDXShouldPass1(t *testing.T) { // create the channel of data and errors stream := make(chan base.Datapoint, 100) errors := make(chan error, 20) model := NewLogistic(base.StochasticGA, .0001, 0, 0, nil, nil, 1) go model.OnlineLearn(errors, stream, func(theta [][]float64) {}) // start passing data to our datastream // // we could have data already in our channel // when we instantiated the Perceptron, though for iter := 0; iter < 3000; iter++ { for i := -40.0; i < 40; i += 0.15 { if 10+i/2 > 0 { stream <- base.Datapoint{ X: []float64{i}, Y: []float64{1.0}, } } else { stream <- base.Datapoint{ X: []float64{i}, Y: []float64{0}, } } } } // close the dataset close(stream) err, more := <-errors assert.Nil(t, err, "Learning error should be nil") assert.False(t, more, "There should be no errors returned") // test a larger dataset now iter := 0 for i := -100.0; i < 100; i += 0.347 { guess, err := model.Predict([]float64{i}) assert.Nil(t, err, "Prediction error should be nil") assert.Len(t, guess, 1, "Guess should have length 1") if i/2+10 > 0 { assert.InDelta(t, 1.0, guess[0], 0.499, "Guess should be 1 for i=%v", i) } else { assert.InDelta(t, 0.0, guess[0], 0.499, "Guess should be 0 for i=%v", i) } iter++ } fmt.Printf("Iter: %v\n", iter) }
func TestDistance(t *testing.T) { assert.InDelta(t, float64(distance(waterloo, kingsCross)), 3080.074, 0.001) d := math.Sqrt(float64(approximateSquareDistance(waterloo, kingsCross))) assert.InDelta(t, d, 3074.987, 0.001) d = math.Sqrt(float64(approximateSquareDistance(leicester, coventGarden))) assert.InDelta(t, d, 305.662, 0.001) d = math.Sqrt(float64(approximateSquareDistance(oxford, embankment))) assert.InDelta(t, d, 1593.763, 0.001) }
func TestCentroidsAndTraces(t *testing.T) { centroids, traces, f, reverse := CentroidsAndTraces(paramset, traceparams, 2) assert.Equal(t, 2, len(centroids)) assert.Equal(t, 4, len(traces)) var tr4 *Trace for _, clusterable := range traces { tr4 = clusterable.(*Trace) if tr4.ID == "tr4" { break } } assert.Equal(t, 0, tr4.Params[1], "Missing param should map to 0.") assert.Equal(t, 3, tr4.Params[0], "The value gpu should sort to last of the three params.") assert.Equal(t, traceparams["tr4"], reverse(tr4)) kmeansCentroid := f([]kmeans.Clusterable{tr4, tr4}) centroid := kmeansCentroid.(*Centroid) assert.Equal(t, 0.0, centroid.Distance(tr4)) var tr1 *Trace for _, clusterable := range traces { tr1 = clusterable.(*Trace) if tr1.ID == "tr1" { break } } assert.Equal(t, 2.0, centroid.Distance(tr1)) // Now run the k-means algorithm, which is deterministic for a fixed set of // starting centroids, so pick our centroids explicitly so we always get the // same answer. obs := make([]kmeans.Clusterable, len(traces)) for i, tr := range traces { obs[i] = tr } cent := []kmeans.Centroid{ f([]kmeans.Clusterable{tr1}), f([]kmeans.Clusterable{tr4}), } kmCentroids, kmClusters := kmeans.KMeans(obs, cent, 2, 10, f) assert.Equal(t, 2, len(kmCentroids)) assert.Equal(t, 2, len(kmClusters)) assert.Equal(t, 3, len(kmClusters[0])) assert.Equal(t, 1, len(kmClusters[1])) assert.Equal(t, "tr4", kmClusters[1][0].(*Trace).ID, "tr4 should be the singe member of the second cluster.") assert.InDelta(t, 2.7748, kmeans.TotalError(obs, kmCentroids), 0.01) // Run k-means again but with just one centroid and show the total error gets // larger. kmCentroids, kmClusters = kmeans.KMeans(obs, cent[:1], 2, 10, f) assert.Equal(t, 1, len(kmCentroids)) assert.Equal(t, 1, len(kmClusters)) assert.Equal(t, 4, len(kmClusters[0])) assert.InDelta(t, 4.42496, kmeans.TotalError(obs, kmCentroids), 0.01) }
// Test that ping command output is processed properly func TestProcessPingOutput(t *testing.T) { trans, rec, avg, err := processPingOutput(bsdPingOutput) assert.NoError(t, err) assert.Equal(t, 5, trans, "5 packets were transmitted") assert.Equal(t, 5, rec, "5 packets were transmitted") assert.InDelta(t, 20.224, avg, 0.001) trans, rec, avg, err = processPingOutput(linuxPingOutput) assert.NoError(t, err) assert.Equal(t, 5, trans, "5 packets were transmitted") assert.Equal(t, 5, rec, "5 packets were transmitted") assert.InDelta(t, 43.628, avg, 0.001) }
func TestQueueConsumerRunStopsGracefullyWhenCancelled(t *testing.T) { // log to /dev/null because the deleter is chatty log.SetOutput(ioutil.Discard) defer func() { log.SetOutput(os.Stderr) }() ctl := gomock.NewController(t) defer ctl.Finish() // delay so that the cancel occurs mid-receive delay := func(x interface{}) { time.Sleep(10 * time.Millisecond) } m := mock.NewMockSQSAPI(ctl) m.EXPECT().ReceiveMessage(gomock.Any()).Do(delay).Return(&sqs.ReceiveMessageOutput{}, nil).AnyTimes() m.EXPECT().DeleteMessageBatch(gomock.Any()).AnyTimes().Return(&sqs.DeleteMessageBatchOutput{}, nil) m.EXPECT().ChangeMessageVisibilityBatch(gomock.Any()).AnyTimes() s := &SQSService{Svc: m} q := NewConsumer(s, noop) q.delayAfterReceiveError = time.Millisecond ngo := runtime.NumGoroutine() // wait long enough to ensure ReceiveMessage is running ctx, _ := context.WithTimeout(context.Background(), 5*time.Millisecond) err := q.Run(ctx) assert.Error(t, err) time.Sleep(time.Millisecond) // time for goroutines to end assert.InDelta(t, ngo, runtime.NumGoroutine(), 2, "Should not leak goroutines") }
func TestHighTrafficUDP(t *testing.T) { listener := UdpListener{ ServiceAddress: ":8126", AllowedPendingMessages: 100000, } listener.parser, _ = parsers.NewInfluxParser() acc := &testutil.Accumulator{} // send multiple messages to socket err := listener.Start(acc) require.NoError(t, err) time.Sleep(time.Millisecond * 25) conn, err := net.Dial("udp", "127.0.0.1:8126") require.NoError(t, err) for i := 0; i < 20000; i++ { // arbitrary, just to give the OS buffer some slack handling the // packet storm. time.Sleep(time.Microsecond) fmt.Fprintf(conn, testMsgs) } time.Sleep(time.Millisecond) listener.Stop() // this is not an exact science, since UDP packets can easily get lost or // dropped, but assume that the OS will be able to // handle at least 90% of the sent UDP packets. assert.InDelta(t, 100000, len(acc.Metrics), 10000) }
func TestThatPIDOutputMatchesTheSimulation(t *testing.T) { P := 0.0870095459081994 // Proportional coefficient I := 7.32612847120554e-05 // Integrative coefficient D := 22.0896577752675 // Derivative coefficient N := 0.25625893108953 // Derivative filter coefficient pidController := New( P, I, D, N, conf.Conf.MinPIDOutputLimits, conf.Conf.MaxPIDOutputLimits) pidController.Set(0) for i := 0; i < len(simin); i++ { in := simin[i] expectedOut := simout[i] output := pidController.updateWithDuration(-in, 1.) assert.InDelta(t, expectedOut, output, 1e-4, "supposed to be the same") } }
func TestHoughLines(t *testing.T) { timg := image.NewGray(image.Rect(0, 0, 700, 500)) timg.SetGray(10, 10, color.Gray{1}) timg.SetGray(200, 10, color.Gray{1}) timg.SetGray(400, 10, color.Gray{1}) timg.SetGray(10, 200, color.Gray{1}) timg.SetGray(10, 400, color.Gray{1}) lines := houghLines(*timg, nil, 0, 10) if !assert.Len(t, lines, 6) { t.FailNow() } expectedLines := []polarLine{ polarLine{Theta: 1.570796, Distance: 10, Count: 3}, polarLine{Theta: 0.000000, Distance: 10, Count: 3}, polarLine{Theta: 0.785398, Distance: 148, Count: 2}, polarLine{Theta: 0.453786, Distance: 184, Count: 2}, polarLine{Theta: 1.117011, Distance: 184, Count: 2}, polarLine{Theta: 0.785398, Distance: 290, Count: 2}, } for i, line := range lines { expected := expectedLines[i] thetaOk := assert.InDelta(t, expected.Theta, line.Theta, 0.0001) distanceOk := assert.Equal(t, expected.Distance, line.Distance) countOk := assert.Equal(t, expected.Count, line.Count) if !thetaOk || !distanceOk || !countOk { t.Fatalf("%v expected to equal %v", line, expected) } } }
// TestTwoSpecsContinuous tests that a continuous work spec can be // returned according to its weight, provided it has no work units. func TestTwoSpecsContinuous(t *testing.T) { metas := map[string]*WorkSpecMeta{ "one": &WorkSpecMeta{ Weight: 1, AvailableCount: 1000, }, "two": &WorkSpecMeta{ Weight: 1, Continuous: true, }, } trials := 1000 counts := runScheduler(t, metas, trials) assert.InDelta(t, trials/2, counts["one"], 3*stdDev(trials, 1, 2)) assert.InDelta(t, trials/2, counts["two"], 3*stdDev(trials, 1, 2)) }
func TestStartStop(t *testing.T) { assert := assert.New(t) startGoroutineNum := runtime.NumGoroutine() for i := 0; i < 10; i++ { qa.Root(t, func(root string) { configFile := TestConfig(root) app := carbon.New(configFile) assert.NoError(app.ParseConfig()) assert.NoError(app.Start()) app.Stop() }) } endGoroutineNum := runtime.NumGoroutine() // GC worker etc if !assert.InDelta(startGoroutineNum, endGoroutineNum, 3) { p := pprof.Lookup("goroutine") p.WriteTo(os.Stdout, 1) } }
func TestVirtual_memory(t *testing.T) { v, err := VirtualMemory() if err != nil { t.Errorf("error %v", err) } empty := &VirtualMemoryStat{} if v == empty { t.Errorf("error %v", v) } assert.True(t, v.Total > 0) assert.True(t, v.Available > 0) assert.True(t, v.Used > 0) assert.Equal(t, v.Total, v.Available+v.Used, "Total should be computable from available + used: %v", v) assert.True(t, v.Free > 0) assert.True(t, v.Available > v.Free, "Free should be a subset of Available: %v", v) assert.InDelta(t, v.UsedPercent, 100*float64(v.Used)/float64(v.Total), 0.1, "UsedPercent should be how many percent of Total is Used: %v", v) }
func TestPointSimilarities(t *testing.T) { var examples = []struct { closestPoints []float64 idealPoints []float64 expectedMatches []float64 fit float64 }{ { closestPoints: preparePointDistances([]float64{2.5, 12, 21.5, 32.5}), idealPoints: []float64{2, 12, 22}, expectedMatches: []float64{2.5, 12, 21.5}, fit: 0.9888, }, { closestPoints: preparePointDistances([]float64{2.5, 12, 21.5, 32.5}), idealPoints: []float64{12, 22, 32}, expectedMatches: []float64{12, 21.5, 32.5}, fit: 0.9833, }, { closestPoints: preparePointDistances([]float64{0, 5, 10, 15, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 140}), idealPoints: []float64{10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, expectedMatches: []float64{10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, fit: 1.0, }, } for _, tt := range examples { fit, matchedPoints := pointSimilarities(tt.idealPoints, tt.closestPoints) assert.InDelta(t, tt.fit, fit, 0.0001) assert.EqualValues(t, tt.expectedMatches, matchedPoints) } }
func TestSettingLength(t *testing.T) { assert := assert.New(t) v := NewVec3(3, 4, 0) assert.InDelta(5, v.Length(), Epsilon, "Vector's length should be 5") v.SetLength(10) assertEqualVectors(t, NewVec3(6, 8, 0), v) }
func TestDPNBagUpdate(t *testing.T) { if runRestTests(t) == false { return } client := getClient(t) bag := testutil.MakeDPNBag() resp := client.DPNBagCreate(bag) require.NotNil(t, resp) require.Nil(t, resp.Error) // We have to set UpdatedAt ahead, or the server won't update // record we're sending. newTimestamp := time.Now().UTC().Add(1 * time.Second).Truncate(time.Second) newLocalId := fmt.Sprintf("GO-TEST-BAG-%s", uuid.NewV4().String()) dpnBag := resp.Bag() dpnBag.UpdatedAt = newTimestamp dpnBag.LocalId = newLocalId updateResp := client.DPNBagUpdate(dpnBag) require.NotNil(t, updateResp) require.Nil(t, updateResp.Error) updatedBag := updateResp.Bag() require.NotNil(t, updatedBag) assert.InDelta(t, newTimestamp.Unix(), updatedBag.UpdatedAt.Unix(), float64(2.0)) assert.Equal(t, newLocalId, updatedBag.LocalId) }
func TestMaxTime(t *testing.T) { assert := assert.New(t) b, err := New(time.Millisecond*200, 100000, 100000, 10, func(str interface{}) uint { return uint(len(str.(string))) }, ) assert.Nil(err) go func() { for i := 0; i < 10000; i++ { b.Put("a") time.Sleep(time.Millisecond) } }() before := time.Now() batch, err := b.Get() // This delta is normally 1-3 ms but running tests in CI with -race causes // this to run much slower. For now, just bump up the threshold. assert.InDelta(200, time.Since(before).Seconds()*1000, 50) assert.True(len(batch) > 0) assert.Nil(err) }
func TestStandardDeviationInt(t *testing.T) { zeroStdDevList := []int{1, 1, 1, 1, 1} assert.Equal(t, 0.0, StandardDeviationInt(zeroStdDevList)) knownStdDevList := []int{1, 2, 3, 4, 5} assert.InDelta(t, 1.5811, StandardDeviationInt(knownStdDevList), 0.0001) }