Exemple #1
1
func startSleepCommand(t *testing.T) *exec.Cmd {
	cmd := exec.Command("sh", "-c", "sleep 100")
	if err := cmd.Start(); err != nil {
		t.Error(err)
	}
	return cmd
}
Exemple #2
1
func TestConnQueryScan(t *testing.T) {
	t.Parallel()

	conn := mustConnect(t, *defaultConnConfig)
	defer closeConn(t, conn)

	var sum, rowCount int32

	rows, err := conn.Query("select generate_series(1,$1)", 10)
	if err != nil {
		t.Fatalf("conn.Query failed: ", err)
	}
	defer rows.Close()

	for rows.Next() {
		var n int32
		rows.Scan(&n)
		sum += n
		rowCount++
	}

	if rows.Err() != nil {
		t.Fatalf("conn.Query failed: ", err)
	}

	if rowCount != 10 {
		t.Error("Select called onDataRow wrong number of times")
	}
	if sum != 55 {
		t.Error("Wrong values returned")
	}
}
Exemple #3
1
func TestConnQueryEncoder(t *testing.T) {
	t.Parallel()

	conn := mustConnect(t, *defaultConnConfig)
	defer closeConn(t, conn)

	n := pgx.NullInt64{Int64: 1, Valid: true}

	rows, err := conn.Query("select $1::int8", &n)
	if err != nil {
		t.Fatalf("conn.Query failed: ", err)
	}

	ok := rows.Next()
	if !ok {
		t.Fatal("rows.Next terminated early")
	}

	var m pgx.NullInt64
	err = rows.Scan(&m)
	if err != nil {
		t.Fatalf("rows.Scan failed: ", err)
	}
	rows.Close()

	if !m.Valid {
		t.Error("m should be valid, but it wasn't")
	}

	if m.Int64 != 1 {
		t.Errorf("m.Int64 should have been 1, but it was %v", m.Int64)
	}

	ensureConnValid(t, conn)
}
func TestPerimeter(t *testing.T) {

	//Testing for circle
	for _, pair := range tests {
		c := Circle{pair.x, pair.y, pair.r}
		v := c.perimeter()
		if v != pair.perimeterC {
			t.Error(
				"For", pair.x, pair.y, pair.r,
				"expected", pair.perimeterC,
				"got", v,
			)
		}
	}

	//Testing for rectangle
	for _, pair1 := range testsRectanglePerimeter {
		r := Rectangle{pair1.x1, pair1.y1, pair1.x2, pair1.y2}
		v := r.perimeter()
		if v != pair1.perimeterR {
			t.Error(
				"For", pair1.x1, pair1.y1, pair1.x2, pair1.y2,
				"expected", pair1.perimeterR,
				"got", v,
			)
		}
	}

}
Exemple #5
0
func TestWatchFork(t *testing.T) {
	if skipTest(t) {
		return
	}

	pid := os.Getpid()

	tw := newTestWatcher(t)

	// no watches added yet, so this fork event will no be captured
	runCommand(t, "date")

	// watch fork events for this process
	if err := tw.watcher.Watch(pid, PROC_EVENT_FORK); err != nil {
		t.Error(err)
	}

	// this fork event will be captured,
	// the exec and exit events will not be captured
	runCommand(t, "cal")

	tw.close()

	if expectEvents(t, 1, "forks", tw.events.forks) {
		expectEventPid(t, "fork", pid, tw.events.forks[0])
	}

	expectEvents(t, 0, "execs", tw.events.execs)
	expectEvents(t, 0, "exits", tw.events.exits)
}
Exemple #6
0
func TestLinesToIgnore(t *testing.T) {
	// it 'ignores empty lines' do
	// expect(env("\n \t  \nfoo=bar\n \nfizz=buzz")).to eql('foo' => 'bar', 'fizz' => 'buzz')
	if !isIgnoredLine("\n") {
		t.Error("Line with nothing but line break wasn't ignored")
	}

	if !isIgnoredLine("\t\t ") {
		t.Error("Line full of whitespace wasn't ignored")
	}

	// it 'ignores comment lines' do
	// expect(env("\n\n\n # HERE GOES FOO \nfoo=bar")).to eql('foo' => 'bar')
	if !isIgnoredLine("# comment") {
		t.Error("Comment wasn't ignored")
	}

	if !isIgnoredLine("\t#comment") {
		t.Error("Indented comment wasn't ignored")
	}

	// make sure we're not getting false positives
	if isIgnoredLine("export OPTION_B='\\n'") {
		t.Error("ignoring a perfectly valid line to parse")
	}
}
func TestIntegrationLog(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration tests in short mode.")
	}
	oService := &routing.Service{Client: client}
	opts, err := oService.GetOptimizations(&routing.RouteQuery{
		Limit: 1,
	})
	if err != nil {
		t.Error("Error occured in external service:", err)
		return
	}
	if len(opts) < 1 {
		t.Skip("Not enough routes to test activity stream")
	}
	opt, err := oService.GetOptimization(&routing.OptimizationParameters{
		ProblemID: opts[0].ProblemID,
	})
	if len(opt.Routes) < 1 {
		t.Skip("Not enough routes to test activity stream")
	}
	err = service.Log("TestMessage", opt.Routes[0].ID)
	if err != nil {
		t.Error(err)
	}
}
Exemple #8
0
// ensure rate limit is still parsed, even for error responses
func TestDo_rateLimit_errorResponse(t *testing.T) {
	setup()
	defer teardown()

	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Add(headerRateLimit, "60")
		w.Header().Add(headerRateRemaining, "59")
		w.Header().Add(headerRateReset, "1372700873")
		http.Error(w, "Bad Request", 400)
	})

	req, _ := client.NewRequest("GET", "/", nil)
	_, err := client.Do(req, nil)

	if err == nil {
		t.Error("Expected error to be returned.")
	}
	if _, ok := err.(*RateLimitError); ok {
		t.Errorf("Did not expect a *RateLimitError error; got %#v.", err)
	}
	if got, want := client.Rate().Limit, 60; got != want {
		t.Errorf("Client rate limit = %v, want %v", got, want)
	}
	if got, want := client.Rate().Remaining, 59; got != want {
		t.Errorf("Client rate remaining = %v, want %v", got, want)
	}
	reset := time.Date(2013, 7, 1, 17, 47, 53, 0, time.UTC)
	if client.Rate().Reset.UTC() != reset {
		t.Errorf("Client rate reset = %v, want %v", client.Rate().Reset, reset)
	}
}
func testRegisterConsumer(t *testing.T) {
	subscription := make(map[string]int)
	subscription["topic1"] = 1

	consumerInfo := &ConsumerInfo{
		Version:      int16(1),
		Subscription: subscription,
		Pattern:      whiteListPattern,
		Timestamp:    time.Now().Unix(),
	}

	topicCount := &WildcardTopicsToNumStreams{
		Coordinator:           coordinator,
		ConsumerId:            fmt.Sprintf(consumerIdPattern, 0),
		TopicFilter:           NewWhiteList("topic1"),
		NumStreams:            1,
		ExcludeInternalTopics: true,
	}

	err := coordinator.RegisterConsumer(fmt.Sprintf(consumerIdPattern, 0), consumerGroup, topicCount)
	if err != nil {
		t.Error(err)
	}
	actualConsumerInfo, err := coordinator.GetConsumerInfo(fmt.Sprintf(consumerIdPattern, 0), consumerGroup)

	assert(t, actualConsumerInfo.Version, consumerInfo.Version)
	assert(t, actualConsumerInfo.Subscription, consumerInfo.Subscription)
	assert(t, actualConsumerInfo.Pattern, consumerInfo.Pattern)
}
Exemple #10
0
func testGetConsumersInGroup(t *testing.T) {
	consumers, err := coordinator.GetConsumersInGroup(consumerGroup)
	if err != nil {
		t.Error(err)
	}
	assert(t, len(consumers), 1)
}
Exemple #11
0
func TestMarshalBinary(t *testing.T) {
	s1 := New(testdata.TwoHoursData[0].T)
	for _, p := range testdata.TwoHoursData {
		s1.Push(p.T, p.V)
	}
	it1 := s1.Iter()
	it1.Next()
	b, err := s1.MarshalBinary()
	if err != nil {
		t.Error(err)
	}
	s2 := New(s1.T0)
	err = s2.UnmarshalBinary(b)
	if err != nil {
		t.Error(err)
	}
	it := s2.Iter()
	for _, w := range testdata.TwoHoursData {
		if !it.Next() {
			t.Fatalf("Next()=false, want true")
		}
		tt, vv := it.Values()
		// t.Logf("it.Values()=(%+v, %+v)\n", time.Unix(int64(tt), 0), vv)
		if w.T != tt || w.V != vv {
			t.Errorf("Values()=(%v,%v), want (%v,%v)\n", tt, vv, w.T, w.V)
		}
	}
}
Exemple #12
0
func TestUnionFsRemoveAll(t *testing.T) {
	wd, clean := setupUfs(t)
	defer clean()

	err := os.MkdirAll(wd+"/ro/dir/subdir", 0755)
	CheckSuccess(err)

	contents := "hello"
	fn := wd + "/ro/dir/subdir/y"
	err = ioutil.WriteFile(fn, []byte(contents), 0644)
	CheckSuccess(err)
	freezeRo(wd + "/ro")

	err = os.RemoveAll(wd + "/mnt/dir")
	if err != nil {
		t.Error("Should delete all")
	}

	for _, f := range []string{"dir/subdir/y", "dir/subdir", "dir"} {
		if fi, _ := os.Lstat(filepath.Join(wd, "mount", f)); fi != nil {
			t.Errorf("file %s should have disappeared: %v", f, fi)
		}
	}

	names, err := Readdirnames(wd + "/rw/DELETIONS")
	CheckSuccess(err)
	if len(names) != 3 {
		t.Fatal("unexpected names", names)
	}
}
Exemple #13
0
func TestTournamentAndElitism(t *testing.T) {
	var (
		src     = rand.NewSource(time.Now().UnixNano())
		rng     = rand.New(src)
		nbGenes = 2
		size    = 3
		indis   = makeIndividuals(size, nbGenes, rng)
	)
	for i := 0; i < size; i++ {
		indis[i] = makeIndividual(nbGenes, rng)
		indis[i].Fitness = float64(i)
	}
	var original = make([]Individual, len(indis))
	copy(original, indis)
	// All the individuals participate in the tournament
	var (
		elitism    = SelElitism{}
		tournament = SelTournament{size}
		elite, _   = elitism.Apply(size, indis, rng)
		tourney, _ = tournament.Apply(size, indis, rng)
	)
	elite.Sort()
	tourney.Sort()
	// Check the individual is from the initial population
	if elite[0].Fitness != tourney[0].Fitness {
		t.Error("Elitism and full tournament selection differed")
	}
}
func TestMultiWriter(t *testing.T) {
	sha1 := sha1.New()
	sink := new(bytes.Buffer)
	mw := MultiWriter(sha1, sink)

	sourceString := "My input text."
	source := strings.NewReader(sourceString)
	written, err := Copy(mw, source)

	if written != int64(len(sourceString)) {
		t.Errorf("short write of %d, not %d", written, len(sourceString))
	}

	if err != nil {
		t.Errorf("unexpected error: %v", err)
	}

	sha1hex := fmt.Sprintf("%x", sha1.Sum())
	if sha1hex != "01cb303fa8c30a64123067c5aa6284ba7ec2d31b" {
		t.Error("incorrect sha1 value")
	}

	if sink.String() != sourceString {
		t.Errorf("expected %q; got %q", sourceString, sink.String())
	}
}
Exemple #15
0
func Test_janitar(t *testing.T) {
	time.Sleep(12 * time.Second)
	if cache1.Len().Get() == 99999 {
		t.Error("err")
		return
	}
}
Exemple #16
0
func TestCacheComplete(t *testing.T) {
	paths := DefaultPaths()
	if len(paths) == 0 {
		t.Skip("No default paths available")
	}

	tests := []string{"mscorlib.dll", "System.dll"}

	t.Log(paths)
	c := Cache{paths: paths}
	for _, test := range tests {
		if asm, err := c.Load(test); err != nil {
			t.Error(err)
		} else {
			t.Logf("Found %s (%s)", test, asm.Name())
		}
	}

	tests2 := []content.Type{
		content.Type{Name: content.FullyQualifiedName{Absolute: "net://type/System.String"}},
	}
	for _, test := range tests2 {
		if res, err := c.Complete(&test); err != nil {
			t.Error(err)
		} else {
			t.Log(res)
		}
	}
}
Exemple #17
0
func Test_executing_a_regex_command(t *testing.T) {
	w := &wsman{}
	id := w.HandleCommand(MatchPattern(`echo .* >> C:\file.cmd`), func(out, err io.Writer) int {
		return 0
	})

	res := httptest.NewRecorder()
	req, _ := http.NewRequest("POST", "", strings.NewReader(fmt.Sprintf(`
		<env:Envelope xmlns:env="http://www.w3.org/2003/05/soap-envelope" xmlns:a="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:rsp="http://schemas.microsoft.com/wbem/wsman/1/windows/shell">
			<env:Header>
				<a:Action mustUnderstand="true">http://schemas.xmlsoap.org/ws/2004/09/shell/Command</a:Action>
			</env:Header>
			<env:Body>
				<rsp:CommandLine><rsp:Command>"echo %d >> C:\file.cmd"</rsp:Command></rsp:CommandLine>
			</env:Body>
		</env:Envelope>`, uuid.NewV4().String())))

	w.ServeHTTP(res, req)
	if res.Code != http.StatusOK {
		t.Errorf("Expected 200 OK but was %d.\n", res.Code)
	}

	env, err := xmlpath.Parse(res.Body)
	if err != nil {
		t.Error("Couldn't compile the SOAP response.")
	}

	xpath, _ := xmlpath.CompileWithNamespace(
		"//rsp:CommandId", soap.GetAllNamespaces())

	result, _ := xpath.String(env)
	if result != id {
		t.Errorf("Expected CommandId=%s but was \"%s\"", id, result)
	}
}
func testLineReader(t *testing.T, input []byte) {
	for stride := 1; stride < len(input); stride++ {
		done := 0
		reader := testReader{input, stride}
		l := NewReader(&reader, len(input)+1)
		for {
			line, isPrefix, err := l.ReadLine()
			if len(line) > 0 && err != nil {
				t.Errorf("ReadLine returned both data and error: %s", err)
			}
			if isPrefix {
				t.Errorf("ReadLine returned prefix")
			}
			if err != nil {
				if err != os.EOF {
					t.Fatalf("Got unknown error: %s", err)
				}
				break
			}
			if want := testOutput[done : done+len(line)]; !bytes.Equal(want, line) {
				t.Errorf("Bad line at stride %d: want: %x got: %x", stride, want, line)
			}
			done += len(line)
		}
		if done != len(testOutput) {
			t.Error("ReadLine didn't return everything")
		}
	}
}
Exemple #19
0
func makeIPNet(t *testing.T) *net.IPNet {
	_, net, err := net.ParseCIDR("1.2.3.0/24")
	if err != nil {
		t.Error(err)
	}
	return net
}
Exemple #20
0
func Test_Remove_Sync(t *testing.T) {
	FuncName := "GdLists.Remove() AND GdLists.Sync()"

	ssgl, _ := getGdListIns()
	Pssgl := &ssgl
	Pssgl.New()

	v := Pssgl.Remove(2)

	l := Pssgl.Len()
	a := len(Pssgl.Value)
	b := Pssgl.list.Len()
	// dd(l)
	// dd(a)
	// dd(b)

	if l != b || a-b != 1 {
		t.Error(FuncName + " ... failed!")
	}

	v.Sync()

	ls := Pssgl.Len()
	as := len(Pssgl.Value)
	// bs := Pssgl.list.Len()
	// dd(ls)
	// dd(as)
	// dd(bs)

	if as != ls || ls != 4 || Pssgl.Getter(2) != "4" {
		t.Error(FuncName + " ... failed!")
	}

	t.Log(FuncName + " ... ok!")
}
Exemple #21
0
func TestNoExistBinary(t *testing.T) {
	// Can't run a non-existent binary
	err := exec.Command("/no-exist-binary").Run()
	if err == nil {
		t.Error("expected error from /no-exist-binary")
	}
}
Exemple #22
0
func TestInstantiateZero(t *testing.T) {
	defer func() {
		recover()
	}()
	_ = lfucache.New(0)
	t.Error("Should not be able to instantiate zero-sized cache")
}
Exemple #23
0
func TestBufReader(t *testing.T) {
	reader, writer := io.Pipe()
	bufreader := NewBufReader(reader)

	// Write everything down to a Pipe
	// Usually, a pipe should block but because of the buffered reader,
	// the writes will go through
	done := make(chan bool)
	go func() {
		writer.Write([]byte("hello world"))
		writer.Close()
		done <- true
	}()

	// Drain the reader *after* everything has been written, just to verify
	// it is indeed buffering
	<-done
	output, err := ioutil.ReadAll(bufreader)
	if err != nil {
		t.Fatal(err)
	}
	if !bytes.Equal(output, []byte("hello world")) {
		t.Error(string(output))
	}
}
func TestRegexpTokenizer(t *testing.T) {
	tokenizer := RegexpTokenizer("[A-Z]+")
	expected, result := tokenizer("OH hello THERE"), []string{"OH", "THERE"}
	if !reflect.DeepEqual(expected, result) {
		t.Error("Expected", expected, "got", result)
	}
}
Exemple #25
0
func TestWatchExit(t *testing.T) {
	if skipTest(t) {
		return
	}

	tw := newTestWatcher(t)

	cmd := startSleepCommand(t)

	childPid := cmd.Process.Pid

	// watch for exit event of our child process
	if err := tw.watcher.Watch(childPid, PROC_EVENT_EXIT); err != nil {
		t.Error(err)
	}

	// kill our child process, triggers exit event
	syscall.Kill(childPid, syscall.SIGTERM)

	cmd.Wait()

	tw.close()

	expectEvents(t, 0, "forks", tw.events.forks)

	expectEvents(t, 0, "execs", tw.events.execs)

	if expectEvents(t, 1, "exits", tw.events.exits) {
		expectEventPid(t, "exit", childPid, tw.events.exits[0])
	}
}
func TestSuggestedActionAreaUnmarshalData(t *testing.T) {
	dataMock, err := getDataMock("./testdata/suggested_action_area.json")
	if err != nil {
		t.Error(err)
	}

	api := SuggestedActionAreaAPI{}
	api.RawResponse = dataMock

	result, err := api.unmarshalData()
	if err != nil {
		t.Error(err)
	}

	if len(result) != 2 {
		t.Error("Invalid result length: ", len(result))
	}

	fRes := result[0]
	if fRes.ID != 1 {
		t.Error("Invalid ID value: ", fRes.ID)
	}
	if fRes.Name != "Legal Framework" {
		t.Error("Invalid Name value: ", fRes.Name)
	}
}
Exemple #27
0
func runCommand(t *testing.T, name string) *exec.Cmd {
	cmd := exec.Command(name)
	if err := cmd.Run(); err != nil {
		t.Error(err)
	}
	return cmd
}
Exemple #28
0
func Test_Numeric(t *testing.T) {
	strWant := "0." + strings.Repeat("0123456789", 100)[1:]
	numWant, _ := big.NewRat(1, 1).SetString(strWant)
	numParam := param("@num", Numeric, numWant)

	withStatementResultSet(t, "SELECT @num;", []*Parameter{numParam}, func(rs *ResultSet) {
		// Use interface{}, so *resultSet.Any will be tested as well.
		var numHaveInterface interface{}

		_, err := rs.ScanNext(&numHaveInterface)
		if err != nil {
			t.Error("failed to scan next:", err)
		}

		numHave, ok := numHaveInterface.(*big.Rat)
		if !ok {
			t.Errorf("unexpected type: %T", numHaveInterface)
			return
		}

		strHave := numHave.FloatString(999)
		if strHave != strWant {
			t.Errorf("have: %s, but want: %s", strHave, strWant)
		}
	})
}
Exemple #29
0
func TestNew(t *testing.T) {
	config.SetHome(filepath.Join("..", "..", "cmd", "roy", "data"))
	mi, err := newMIMEInfo()
	if err != nil {
		t.Error(err)
	}
	tpmap := make(map[string]struct{})
	for _, v := range mi {
		//fmt.Println(v)
		//if len(v.Magic) > 1 {
		//	fmt.Printf("Multiple magics (%d): %s\n", len(v.Magic), v.MIME)
		//}
		for _, c := range v.Magic {
			for _, d := range c.Matches {
				tpmap[d.Typ] = struct{}{}
				if len(d.Mask) > 0 {
					if d.Typ == "string" {
						fmt.Println("MAGIC: " + d.Value)
					} else {
						fmt.Println("Type: " + d.Typ)
					}
					fmt.Println("MASK: " + d.Mask)
				}
			}
		}
	}
	/*
		for k, _ := range tpmap {
			fmt.Println(k)
		}
	*/
	if len(mi) != 1495 {
		t.Errorf("expecting %d MIMEInfos, got %d", 1495, len(mi))
	}
}
func TestSubstitueUser(t *testing.T) {
	usr, err := user.Current()
	if err != nil {
		t.Logf("SKIPPING TEST: unexpected error: %v", err)
		return
	}
	tests := []struct {
		input     string
		expected  string
		expectErr bool
	}{
		{input: "~/foo", expected: path.Join(os.Getenv("HOME"), "foo")},
		{input: "~" + usr.Username + "/bar", expected: usr.HomeDir + "/bar"},
		{input: "/foo/bar", expected: "/foo/bar"},
		{input: "~doesntexit/bar", expectErr: true},
	}
	for _, test := range tests {
		output, err := substituteUserHome(test.input)
		if test.expectErr {
			if err == nil {
				t.Error("unexpected non-error")
			}
			continue
		}
		if err != nil {
			t.Errorf("unexpected error: %v", err)
		}
		if output != test.expected {
			t.Errorf("expected: %s, saw: %s", test.expected, output)
		}
	}
}