func TestRenewInstancesConcurrently(t *testing.T) {
if testing.Short() {
t.Skip()
}
if testing.Short() {
t.SkipNow()
}
const numOfInstances = 10000
const numOfIterations = 10
const ttl = testMediumTTL
conf := createNewConfig(ttl)
catalog := newInMemoryCatalog(conf)
var ids [numOfInstances]string
for i := 0; i < numOfInstances; i++ {
hostSuffix := strconv.Itoa(i)
host := "192.168.0." + hostSuffix
instance := newServiceInstance("Calc", host, 9080)
id, _ := doRegister(catalog, instance)
ids[i] = id
}
var wg sync.WaitGroup
wg.Add(numOfInstances)
done := make(chan struct{})
for i := 0; i < numOfInstances; i++ {
id := ids[i]
go func() {
defer wg.Done()
for {
select {
case <-done:
return
default:
{
duration := randPercentOfDuration(0.25, 0.5, ttl)
time.Sleep(duration)
err := catalog.Renew(id)
assert.NoError(t, err, "Renewal of instance %v failed: %v", id, err)
}
}
}
}()
}
time.Sleep(ttl * numOfIterations)
close(done)
wg.Wait()
instances, err := catalog.List("Calc", protocolPredicate)
assert.NoError(t, err)
assert.Len(t, instances, numOfInstances, "Expected %v surviving instances, found %v", numOfInstances, len(instances))
}
func TestAfterTick(t *testing.T) {
const Count = 10
Delta := 100 * time.Millisecond
if testing.Short() {
Delta = 10 * time.Millisecond
}
for _, ttype := range []bool{false, true} {
setSandboxMode(ttype)
t0 := Now()
for i := 0; i < Count; i++ {
c := After(Delta)
if ttype {
go Advance(t, Delta)
}
<-c
}
t1 := Now()
d := t1.Sub(t0)
target := Delta * Count
if d < target*9/10 {
t.Fatalf("%d ticks of %s too fast: want %s, got %s", Count, Delta, target, d)
}
if !testing.Short() && d > target*30/10 {
t.Fatalf("%d ticks of %s too slow: want %s, got %s", Count, Delta, target, d)
}
}
}
func TestS3Replica(t *testing.T) {
t.Parallel()
t.Skip("This test is periodically failing to reach s3.")
// Create a source repo:
srcRepo := "repo_TestS3Replica_src"
require.NoError(t, Init(srcRepo))
// Create a file in the source repo:
writeFile(t, fmt.Sprintf("%s/master/myfile1", srcRepo), "foo")
if testing.Short() {
writeLots(t, fmt.Sprintf("%s/master/big_file", srcRepo), 1)
} else {
writeLots(t, fmt.Sprintf("%s/master/big_file", srcRepo), 10)
}
// Create a commit in the source repo:
require.NoError(t, Commit(srcRepo, "mycommit1", "master"))
// Create another file in the source repo:
writeFile(t, fmt.Sprintf("%s/master/myfile2", srcRepo), "bar")
if testing.Short() {
writeLots(t, fmt.Sprintf("%s/master/big_file", srcRepo), 1)
} else {
writeLots(t, fmt.Sprintf("%s/master/big_file", srcRepo), 10)
}
// Create a another commit in the source repo:
require.NoError(t, Commit(srcRepo, "mycommit2", "master"))
// Create a destination repo:
dstRepo := "repo_TestS3Replica_dst"
require.NoError(t, Init(dstRepo))
// Verify that the commits "mycommit1" and "mycommit2" do exist in source:
checkFile(t, fmt.Sprintf("%s/mycommit1/myfile1", srcRepo), "foo")
checkFile(t, fmt.Sprintf("%s/mycommit2/myfile2", srcRepo), "bar")
// Verify that the commits "mycommit1" and "mycommit2" do not exist in destination:
checkNoExists(t, fmt.Sprintf("%s/mycommit1", dstRepo))
checkNoExists(t, fmt.Sprintf("%s/mycommit2", dstRepo))
// Run a Pull to push all commits to s3
s3Replica := NewS3Replica(path.Join("pachyderm-test", uuid.NewV4().String()))
err := Pull(srcRepo, "", s3Replica)
require.NoError(t, err)
// Pull commits from s3 to a new local replica
err = s3Replica.Pull("", NewLocalReplica(dstRepo))
require.NoError(t, err)
// Verify that files from both commits are present:
checkFile(t, fmt.Sprintf("%s/mycommit1/myfile1", dstRepo), "foo")
checkFile(t, fmt.Sprintf("%s/mycommit2/myfile2", dstRepo), "bar")
checkFile(t, fmt.Sprintf("%s/master/myfile1", dstRepo), "foo")
checkFile(t, fmt.Sprintf("%s/master/myfile2", dstRepo), "bar")
}
// Test if errors from the underlying writer is passed upwards.
func TestWriteError(t *testing.T) {
t.Parallel()
buf := new(bytes.Buffer)
n := 65536
if !testing.Short() {
n *= 4
}
for i := 0; i < n; i++ {
fmt.Fprintf(buf, "asdasfasf%d%dfghfgujyut%dyutyu\n", i, i, i)
}
in := buf.Bytes()
// We create our own buffer to control number of writes.
copyBuffer := make([]byte, 128)
for l := 0; l < 10; l++ {
for fail := 1; fail <= 256; fail *= 2 {
// Fail after 'fail' writes
ew := &errorWriter{N: fail}
w, err := NewWriter(ew, l)
if err != nil {
t.Fatalf("NewWriter: level %d: %v", l, err)
}
n, err := io.CopyBuffer(w, struct{ io.Reader }{bytes.NewBuffer(in)}, copyBuffer)
if err == nil {
t.Fatalf("Level %d: Expected an error, writer was %#v", l, ew)
}
n2, err := w.Write([]byte{1, 2, 2, 3, 4, 5})
if n2 != 0 {
t.Fatal("Level", l, "Expected 0 length write, got", n)
}
if err == nil {
t.Fatal("Level", l, "Expected an error")
}
err = w.Flush()
if err == nil {
t.Fatal("Level", l, "Expected an error on flush")
}
err = w.Close()
if err == nil {
t.Fatal("Level", l, "Expected an error on close")
}
w.Reset(ioutil.Discard)
n2, err = w.Write([]byte{1, 2, 3, 4, 5, 6})
if err != nil {
t.Fatal("Level", l, "Got unexpected error after reset:", err)
}
if n2 == 0 {
t.Fatal("Level", l, "Got 0 length write, expected > 0")
}
if testing.Short() {
return
}
}
}
}
func TestWriterReset(t *testing.T) {
t.Parallel()
for level := 0; level <= 9; level++ {
if testing.Short() && level > 1 {
break
}
w, err := NewWriter(ioutil.Discard, level)
if err != nil {
t.Fatalf("NewWriter: %v", err)
}
buf := []byte("hello world")
n := 1024
if testing.Short() {
n = 10
}
for i := 0; i < n; i++ {
w.Write(buf)
}
w.Reset(ioutil.Discard)
wref, err := NewWriter(ioutil.Discard, level)
if err != nil {
t.Fatalf("NewWriter: %v", err)
}
// DeepEqual doesn't compare functions.
w.d.fill, wref.d.fill = nil, nil
w.d.step, wref.d.step = nil, nil
w.d.bulkHasher, wref.d.bulkHasher = nil, nil
w.d.bestSpeed, wref.d.bestSpeed = nil, nil
// hashMatch is always overwritten when used.
copy(w.d.hashMatch[:], wref.d.hashMatch[:])
if len(w.d.tokens) != 0 {
t.Errorf("level %d Writer not reset after Reset. %d tokens were present", level, len(w.d.tokens))
}
// As long as the length is 0, we don't care about the content.
w.d.tokens = wref.d.tokens
// We don't care if there are values in the window, as long as it is at d.index is 0
w.d.window = wref.d.window
if !reflect.DeepEqual(w, wref) {
t.Errorf("level %d Writer not reset after Reset", level)
}
}
testResetOutput(t, func(w io.Writer) (*Writer, error) { return NewWriter(w, NoCompression) })
testResetOutput(t, func(w io.Writer) (*Writer, error) { return NewWriter(w, DefaultCompression) })
testResetOutput(t, func(w io.Writer) (*Writer, error) { return NewWriter(w, BestCompression) })
dict := []byte("we are the world")
testResetOutput(t, func(w io.Writer) (*Writer, error) { return NewWriterDict(w, NoCompression, dict) })
testResetOutput(t, func(w io.Writer) (*Writer, error) { return NewWriterDict(w, DefaultCompression, dict) })
testResetOutput(t, func(w io.Writer) (*Writer, error) { return NewWriterDict(w, BestCompression, dict) })
}
func TestModSqrt(t *testing.T) {
var elt, mod, modx4, sq, sqrt Int
r := rand.New(rand.NewSource(9))
for i, s := range primes[1:] { // skip 2, use only odd primes
mod.SetString(s, 10)
modx4.Lsh(&mod, 2)
// test a few random elements per prime
for x := 1; x < 5; x++ {
elt.Rand(r, &modx4)
elt.Sub(&elt, &mod) // test range [-mod, 3*mod)
if !testModSqrt(t, &elt, &mod, &sq, &sqrt) {
t.Errorf("#%d: failed (sqrt(e) = %s)", i, &sqrt)
}
}
if testing.Short() && i > 2 {
break
}
}
if testing.Short() {
return
}
// exhaustive test for small values
for n := 3; n < 100; n++ {
mod.SetInt64(int64(n))
if !mod.ProbablyPrime(10) {
continue
}
isSquare := make([]bool, n)
// test all the squares
for x := 1; x < n; x++ {
elt.SetInt64(int64(x))
if !testModSqrt(t, &elt, &mod, &sq, &sqrt) {
t.Errorf("#%d: failed (sqrt(%d,%d) = %s)", x, &elt, &mod, &sqrt)
}
isSquare[sq.Uint64()] = true
}
// test all non-squares
for x := 1; x < n; x++ {
sq.SetInt64(int64(x))
z := sqrt.ModSqrt(&sq, &mod)
if !isSquare[x] && z != nil {
t.Errorf("#%d: failed (sqrt(%d,%d) = nil)", x, &sqrt, &mod)
}
}
}
}
// TestSendRecv checks the Send and Recv replication primitives.
func TestSendRecv(t *testing.T) {
t.Parallel()
// Create a source repo:
srcRepo := "repo_TestSendRecv_src"
require.NoError(t, Init(srcRepo))
// Create a file in the source repo:
writeFile(t, fmt.Sprintf("%s/master/myfile1", srcRepo), "foo")
if testing.Short() {
writeLots(t, fmt.Sprintf("%s/master/big_file", srcRepo), 1)
} else {
writeLots(t, fmt.Sprintf("%s/master/big_file", srcRepo), 10)
}
// Create a commit in the source repo:
require.NoError(t, Commit(srcRepo, "mycommit1", "master"))
// Create another file in the source repo:
writeFile(t, fmt.Sprintf("%s/master/myfile2", srcRepo), "bar")
if testing.Short() {
writeLots(t, fmt.Sprintf("%s/master/big_file", srcRepo), 1)
} else {
writeLots(t, fmt.Sprintf("%s/master/big_file", srcRepo), 10)
}
// Create a another commit in the source repo:
require.NoError(t, Commit(srcRepo, "mycommit2", "master"))
// Create a destination repo:
dstRepo := "repo_TestSendRecv_dst"
require.NoError(t, Init(dstRepo))
repo2Recv := func(r io.Reader) error { return recv(dstRepo, r) }
// Verify that the commits "mycommit1" and "mycommit2" do not exist in destination:
checkNoExists(t, fmt.Sprintf("%s/master/mycommit1", dstRepo))
checkNoExists(t, fmt.Sprintf("%s/master/mycommit2", dstRepo))
// Run a Send/Recv operation to fetch data from the older "mycommit1".
// This verifies that tree copying works:
require.NoError(t, send(srcRepo, "mycommit1", repo2Recv))
// Check that the file from mycommit1 exists, but not from mycommit2:
checkFile(t, fmt.Sprintf("%s/mycommit1/myfile1", dstRepo), "foo")
checkNoExists(t, fmt.Sprintf("%s/mycommit2/myfile2", dstRepo))
// Send again, this time starting from mycommit1 and going to mycommit2:
require.NoError(t, send(srcRepo, "mycommit2", repo2Recv))
// Verify that files from both commits are present:
checkFile(t, fmt.Sprintf("%s/mycommit1/myfile1", dstRepo), "foo")
checkFile(t, fmt.Sprintf("%s/mycommit2/myfile2", dstRepo), "bar")
}
func TestStackBarrierProfiling(t *testing.T) {
if (runtime.GOOS == "linux" && runtime.GOARCH == "arm") || runtime.GOOS == "openbsd" || runtime.GOOS == "solaris" || runtime.GOOS == "dragonfly" {
// This test currently triggers a large number of
// usleep(100)s. These kernels/arches have poor
// resolution timers, so this gives up a whole
// scheduling quantum. On Linux and OpenBSD (and
// probably Solaris), profiling signals are only
// generated when a process completes a whole
// scheduling quantum, so this test often gets zero
// profiling signals and fails.
t.Skipf("low resolution timers inhibit profiling signals (golang.org/issue/13405)")
return
}
if !strings.Contains(os.Getenv("GODEBUG"), "gcstackbarrierall=1") {
// Re-execute this test with constant GC and stack
// barriers at every frame.
testenv.MustHaveExec(t)
if runtime.GOARCH == "ppc64" || runtime.GOARCH == "ppc64le" {
t.Skip("gcstackbarrierall doesn't work on ppc64")
}
args := []string{"-test.run=TestStackBarrierProfiling"}
if testing.Short() {
args = append(args, "-test.short")
}
cmd := exec.Command(os.Args[0], args...)
cmd.Env = append([]string{"GODEBUG=gcstackbarrierall=1", "GOGC=1"}, os.Environ()...)
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("subprocess failed with %v:\n%s", err, out)
}
return
}
testCPUProfile(t, nil, func() {
// This is long enough that we're likely to get one or
// two samples in stackBarrier.
duration := 5 * time.Second
if testing.Short() {
duration = 200 * time.Millisecond
}
t := time.After(duration)
for {
deepStack(1000)
select {
case <-t:
return
default:
}
}
})
}
func TestWriterBig(t *testing.T) {
for i, fn := range filenames {
testFileLevelDict(t, fn, DefaultCompression, "")
testFileLevelDict(t, fn, NoCompression, "")
for level := BestSpeed; level <= BestCompression; level++ {
testFileLevelDict(t, fn, level, "")
if level >= 1 && testing.Short() && testenv.Builder() == "" {
break
}
}
if i == 0 && testing.Short() && testenv.Builder() == "" {
break
}
}
}
func TestDeflateInflateString(t *testing.T) {
if testing.Short() && testenv.Builder() == "" {
t.Skip("skipping in short mode")
}
for _, test := range deflateInflateStringTests {
gold, err := ioutil.ReadFile(test.filename)
if err != nil {
t.Error(err)
}
testToFromWithLimit(t, gold, test.label, test.limit)
if testing.Short() {
break
}
}
}
func TestIPCHost(t *testing.T) {
if testing.Short() {
return
}
rootfs, err := newRootfs()
ok(t, err)
defer remove(rootfs)
l, err := os.Readlink("/proc/1/ns/ipc")
ok(t, err)
config := newTemplateConfig(rootfs)
config.Namespaces.Remove(configs.NEWIPC)
buffers, exitCode, err := runContainer(config, "", "readlink", "/proc/self/ns/ipc")
ok(t, err)
if exitCode != 0 {
t.Fatalf("exit code not 0. code %d stderr %q", exitCode, buffers.Stderr)
}
if actual := strings.Trim(buffers.Stdout.String(), "\n"); actual != l {
t.Fatalf("ipc link not equal to host link %q %q", actual, l)
}
}
func TestPassExtraFiles(t *testing.T) {
if testing.Short() {
return
}
rootfs, err := newRootfs()
if err != nil {
t.Fatal(err)
}
defer remove(rootfs)
config := newTemplateConfig(rootfs)
container, err := factory.Create("test", config)
if err != nil {
t.Fatal(err)
}
defer container.Destroy()
var stdout bytes.Buffer
pipeout1, pipein1, err := os.Pipe()
pipeout2, pipein2, err := os.Pipe()
process := libcontainer.Process{
Args: []string{"sh", "-c", "cd /proc/$$/fd; echo -n *; echo -n 1 >3; echo -n 2 >4"},
Env: []string{"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"},
ExtraFiles: []*os.File{pipein1, pipein2},
Stdin: nil,
Stdout: &stdout,
}
err = container.Start(&process)
if err != nil {
t.Fatal(err)
}
waitProcess(&process, t)
out := string(stdout.Bytes())
// fd 5 is the directory handle for /proc/$$/fd
if out != "0 1 2 3 4 5" {
t.Fatalf("expected to have the file descriptors '0 1 2 3 4 5' passed to init, got '%s'", out)
}
var buf = []byte{0}
_, err = pipeout1.Read(buf)
if err != nil {
t.Fatal(err)
}
out1 := string(buf)
if out1 != "1" {
t.Fatalf("expected first pipe to receive '1', got '%s'", out1)
}
_, err = pipeout2.Read(buf)
if err != nil {
t.Fatal(err)
}
out2 := string(buf)
if out2 != "2" {
t.Fatalf("expected second pipe to receive '2', got '%s'", out2)
}
}
func TestQuit(t *testing.T) {
if testing.Short() {
t.Skip("skipping test in short mode")
}
cmd := exec.Command("sleep", "10000")
err := cmd.Start()
if err != nil {
t.Skip("couldn't run test helper command")
}
h := Handler{
process: cmd.Process,
}
err = h.Quit()
if err != nil {
t.Errorf("got %v, wanted %v", err, nil)
}
pid, err := ignoreInterrupt()
if err != nil {
t.Skip("couldn't run test helper command: %v", err)
}
h = Handler{
process: pid,
}
err = h.Quit()
if err != errProcessTookTooLong {
t.Errorf("got %v, wanted %v", err, errProcessTookTooLong)
}
}
func TestTimeout(t *testing.T) {
if testing.Short() {
t.Skip("Integration test - skipping for short mode.")
}
sleepForeverHandler := func(w http.ResponseWriter, req *http.Request) {
req.Close = true
notify := w.(http.CloseNotifier).CloseNotify()
<-notify
}
server := httptest.NewServer(http.HandlerFunc(sleepForeverHandler))
defer server.Close()
rg := NewRecordGenerator(500 * time.Millisecond)
host, port, err := net.SplitHostPort(server.Listener.Addr().String())
_, err = rg.loadFromMaster(host, port)
if err == nil {
t.Fatal("Expect error because of timeout handler")
}
urlErr, ok := (err).(*url.Error)
if !ok {
t.Fatalf("Expected url.Error, instead: %#v", urlErr)
}
netErr, ok := urlErr.Err.(net.Error)
if !ok {
t.Fatalf("Expected net.Error, instead: %#v", netErr)
}
if !netErr.Timeout() {
t.Errorf("Did not receive a timeout, instead: %#v", err)
}
}
func TestCost(t *testing.T) {
if testing.Short() {
return
}
pass := []byte("mypassword")
for c := 0; c < MinCost; c++ {
p, _ := newFromPassword(pass, c)
if p.cost != uint32(DefaultCost) {
t.Errorf("newFromPassword should default costs below %d to %d, but was %d", MinCost, DefaultCost, p.cost)
}
}
p, _ := newFromPassword(pass, 14)
if p.cost != 14 {
t.Errorf("newFromPassword should default cost to 14, but was %d", p.cost)
}
hp, _ := newFromHash(p.Hash())
if p.cost != hp.cost {
t.Errorf("newFromHash should maintain the cost at %d, but was %d", p.cost, hp.cost)
}
_, err := newFromPassword(pass, 32)
if err == nil {
t.Fatalf("newFromPassword: should return a cost error")
}
if err != InvalidCostError(32) {
t.Errorf("newFromPassword: should return cost error, got %#v", err)
}
}
func walkDirs(t *testing.T, dir string) {
// limit run time for short tests
if testing.Short() && time.Since(start) >= 750*time.Millisecond {
return
}
fis, err := ioutil.ReadDir(dir)
if err != nil {
t.Error(err)
return
}
// typecheck package in directory
files, err := pkgFilenames(dir)
if err != nil {
t.Error(err)
return
}
if files != nil {
typecheck(t, dir, files)
}
// traverse subdirectories, but don't walk into testdata
for _, fi := range fis {
if fi.IsDir() && fi.Name() != "testdata" {
walkDirs(t, filepath.Join(dir, fi.Name()))
}
}
}
func TestWildWildcardListener(t *testing.T) {
switch runtime.GOOS {
case "plan9":
t.Skipf("skipping test on %q", runtime.GOOS)
}
if testing.Short() || !*testExternal {
t.Skip("skipping test to avoid external network")
}
defer func() {
if recover() != nil {
t.Fatalf("panicked")
}
}()
if ln, err := Listen("tcp", ""); err == nil {
ln.Close()
}
if ln, err := ListenPacket("udp", ""); err == nil {
ln.Close()
}
if ln, err := ListenTCP("tcp", nil); err == nil {
ln.Close()
}
if ln, err := ListenUDP("udp", nil); err == nil {
ln.Close()
}
if ln, err := ListenIP("ip:icmp", nil); err == nil {
ln.Close()
}
}
func testChanSendBarrier(useSelect bool) {
var wg sync.WaitGroup
var globalMu sync.Mutex
outer := 100
inner := 100000
if testing.Short() {
outer = 10
inner = 1000
}
for i := 0; i < outer; i++ {
wg.Add(1)
go func() {
defer wg.Done()
var garbage []byte
for j := 0; j < inner; j++ {
_, err := doRequest(useSelect)
_, ok := err.(myError)
if !ok {
panic(1)
}
garbage = make([]byte, 1<<10)
}
globalMu.Lock()
global = garbage
globalMu.Unlock()
}()
}
wg.Wait()
}
// TestDualStackTCPListener tests both single and double listen
// to a test listener with various address families, differnet
// listening address and same port.
func TestDualStackTCPListener(t *testing.T) {
switch runtime.GOOS {
case "plan9":
t.Skipf("skipping test on %q", runtime.GOOS)
}
if !supportsIPv6 {
t.Skip("ipv6 is not supported")
}
for _, tt := range dualStackListenerTests {
if tt.wildcard && (testing.Short() || !*testExternal) {
continue
}
switch runtime.GOOS {
case "openbsd":
if tt.wildcard && differentWildcardAddr(tt.laddr1, tt.laddr2) {
tt.xerr = nil
}
}
l1, port := usableListenPort(t, tt.net1, tt.laddr1)
laddr := tt.laddr1 + ":" + port
checkFirstListener(t, tt.net1, laddr, l1)
laddr = tt.laddr2 + ":" + port
l2, err := Listen(tt.net2, laddr)
checkDualStackSecondListener(t, tt.net2, laddr, tt.xerr, err, l2)
l1.Close()
}
}
func TestAll(t *testing.T) {
if testing.Short() {
return
}
if *ngo < 1 {
*ngo = 1 // make sure test is run
}
if *verbose {
fmt.Printf("running test using %d goroutines\n", *ngo)
}
// generate filenames
filenames := make(chan string, 32)
go genFilenames(t, filenames)
// launch test goroutines
done := make(chan int)
for i := 0; i < *ngo; i++ {
go testFiles(t, filenames, done)
}
// wait for all test goroutines to complete
for i := 0; i < *ngo; i++ {
<-done
}
if *verbose {
fmt.Printf("processed %d files\n", nfiles)
}
}
// TestUDPListener tests both single and double listen to a test
// listener with same address family, same listening address and
// same port.
func TestUDPListener(t *testing.T) {
switch runtime.GOOS {
case "plan9":
t.Skipf("skipping test on %q", runtime.GOOS)
}
toudpnet := func(net string) string {
switch net {
case "tcp":
return "udp"
case "tcp4":
return "udp4"
case "tcp6":
return "udp6"
}
return "<nil>"
}
for _, tt := range listenerTests {
if tt.wildcard && (testing.Short() || !*testExternal) {
continue
}
if tt.ipv6 && !supportsIPv6 {
continue
}
tt.net = toudpnet(tt.net)
l1, port := usableListenPacketPort(t, tt.net, tt.laddr)
checkFirstListener(t, tt.net, tt.laddr+":"+port, l1)
l2, err := ListenPacket(tt.net, tt.laddr+":"+port)
checkSecondListener(t, tt.net, tt.laddr+":"+port, err, l2)
l1.Close()
}
}
func TestCPUProfileWithFork(t *testing.T) {
// Fork can hang if preempted with signals frequently enough (see issue 5517).
// Ensure that we do not do this.
heap := 1 << 30
if testing.Short() {
heap = 100 << 20
}
// This makes fork slower.
garbage := make([]byte, heap)
// Need to touch the slice, otherwise it won't be paged in.
done := make(chan bool)
go func() {
for i := range garbage {
garbage[i] = 42
}
done <- true
}()
<-done
var prof bytes.Buffer
if err := StartCPUProfile(&prof); err != nil {
t.Fatal(err)
}
defer StopCPUProfile()
for i := 0; i < 10; i++ {
exec.Command("go").CombinedOutput()
}
}
func TestDialTimeout(t *testing.T) {
if testing.Short() {
t.Skip("skipping in short mode")
}
listener := newLocalListener(t)
addr := listener.Addr().String()
defer listener.Close()
complete := make(chan bool)
defer close(complete)
go func() {
conn, err := listener.Accept()
if err != nil {
t.Error(err)
return
}
<-complete
conn.Close()
}()
dialer := &net.Dialer{
Timeout: 10 * time.Millisecond,
}
var err error
if _, err = DialWithDialer(dialer, "tcp", addr, nil); err == nil {
t.Fatal("DialWithTimeout completed successfully")
}
if !isTimeoutError(err) {
t.Errorf("resulting error not a timeout: %v\nType %T: %#v", err, err, err)
}
}
func TestMarshalUnmarshal(t *testing.T) {
rand := rand.New(rand.NewSource(0))
for i, iface := range messageTypes {
ty := reflect.ValueOf(iface).Type()
n := 100
if testing.Short() {
n = 5
}
for j := 0; j < n; j++ {
v, ok := quick.Value(ty, rand)
if !ok {
t.Errorf("#%d: failed to create value", i)
break
}
m1 := v.Elem().Interface()
m2 := iface
marshaled := marshal(msgIgnore, m1)
if err := unmarshal(m2, marshaled, msgIgnore); err != nil {
t.Errorf("#%d failed to unmarshal %#v: %s", i, m1, err)
break
}
if !reflect.DeepEqual(v.Interface(), m2) {
t.Errorf("#%d\ngot: %#v\nwant:%#v\n%x", i, m2, m1, marshaled)
break
}
}
}
}
func TestLookupGoogleSRV(t *testing.T) {
if testing.Short() || !*testExternal {
t.Skip("avoid external network")
}
if !supportsIPv4 || !*testIPv4 {
t.Skip("IPv4 is required")
}
for _, tt := range lookupGoogleSRVTests {
cname, srvs, err := LookupSRV(tt.service, tt.proto, tt.name)
if err != nil {
t.Fatal(err)
}
if len(srvs) == 0 {
t.Error("got no record")
}
if !strings.HasSuffix(cname, tt.cname) && !strings.HasSuffix(cname, tt.cname+".") {
t.Errorf("got %s; want %s", cname, tt.cname)
}
for _, srv := range srvs {
if !strings.HasSuffix(srv.Target, tt.target) && !strings.HasSuffix(srv.Target, tt.target+".") {
t.Errorf("got %v; want a record containing %s", srv, tt.target)
}
}
}
}
func TestFindPeer(t *testing.T) {
// t.Skip("skipping test to debug another")
if testing.Short() {
t.SkipNow()
}
ctx := context.Background()
_, peers, dhts := setupDHTS(ctx, 4, t)
defer func() {
for i := 0; i < 4; i++ {
dhts[i].Close()
dhts[i].host.Close()
}
}()
connect(t, ctx, dhts[0], dhts[1])
connect(t, ctx, dhts[1], dhts[2])
connect(t, ctx, dhts[1], dhts[3])
ctxT, _ := context.WithTimeout(ctx, time.Second)
p, err := dhts[0].FindPeer(ctxT, peers[2])
if err != nil {
t.Fatal(err)
}
if p.ID == "" {
t.Fatal("Failed to find peer.")
}
if p.ID != peers[2] {
t.Fatal("Didnt find expected peer.")
}
}
func TestPostgresqlDefaultsToAllDatabases(t *testing.T) {
if testing.Short() {
t.Skip("Skipping integration test in short mode")
}
p := &Postgresql{
Address: fmt.Sprintf("host=%s user=postgres sslmode=disable",
testutil.GetLocalHost()),
}
var acc testutil.Accumulator
err := p.Gather(&acc)
require.NoError(t, err)
var found bool
for _, pnt := range acc.Metrics {
if pnt.Measurement == "postgresql" {
if pnt.Tags["db"] == "postgres" {
found = true
break
}
}
}
assert.True(t, found)
}
func TestClean(t *testing.T) {
tests := cleantests
if runtime.GOOS == "windows" {
for i := range tests {
tests[i].result = filepath.FromSlash(tests[i].result)
}
tests = append(tests, wincleantests...)
}
for _, test := range tests {
if s := filepath.Clean(test.path); s != test.result {
t.Errorf("Clean(%q) = %q, want %q", test.path, s, test.result)
}
if s := filepath.Clean(test.result); s != test.result {
t.Errorf("Clean(%q) = %q, want %q", test.result, s, test.result)
}
}
if testing.Short() {
t.Skip("skipping malloc count in short mode")
}
if runtime.GOMAXPROCS(0) > 1 {
t.Log("skipping AllocsPerRun checks; GOMAXPROCS>1")
return
}
for _, test := range tests {
allocs := testing.AllocsPerRun(100, func() { filepath.Clean(test.result) })
if allocs > 0 {
t.Errorf("Clean(%q): %v allocs, want zero", test.result, allocs)
}
}
}
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)
}
}
func testExecPS(t *testing.T, userns bool) {
if testing.Short() {
return
}
rootfs, err := newRootfs()
ok(t, err)
defer remove(rootfs)
config := newTemplateConfig(rootfs)
if userns {
config.UidMappings = []configs.IDMap{{0, 0, 1000}}
config.GidMappings = []configs.IDMap{{0, 0, 1000}}
config.Namespaces = append(config.Namespaces, configs.Namespace{Type: configs.NEWUSER})
}
buffers, exitCode, err := runContainer(config, "", "ps")
if err != nil {
t.Fatalf("%s: %s", buffers, err)
}
if exitCode != 0 {
t.Fatalf("exit code not 0. code %d stderr %q", exitCode, buffers.Stderr)
}
lines := strings.Split(buffers.Stdout.String(), "\n")
if len(lines) < 2 {
t.Fatalf("more than one process running for output %q", buffers.Stdout.String())
}
expected := `1 root ps`
actual := strings.Trim(lines[1], "\n ")
if actual != expected {
t.Fatalf("expected output %q but received %q", expected, actual)
}
}
