forked from quic-go/quic-go
133 lines
2.6 KiB
Go
133 lines
2.6 KiB
Go
package self_test
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/tls"
|
|
"flag"
|
|
"log"
|
|
"math/rand"
|
|
"os"
|
|
"sync"
|
|
"testing"
|
|
|
|
"github.com/lucas-clemente/quic-go/internal/testdata"
|
|
"github.com/lucas-clemente/quic-go/internal/utils"
|
|
|
|
. "github.com/onsi/ginkgo"
|
|
. "github.com/onsi/gomega"
|
|
)
|
|
|
|
const alpn = "quic-go integration tests"
|
|
|
|
func getTLSConfig() *tls.Config {
|
|
conf := testdata.GetTLSConfig()
|
|
conf.NextProtos = []string{alpn}
|
|
return conf
|
|
}
|
|
|
|
func getTLSClientConfig() *tls.Config {
|
|
return &tls.Config{
|
|
RootCAs: testdata.GetRootCA(),
|
|
NextProtos: []string{alpn},
|
|
}
|
|
}
|
|
|
|
const (
|
|
dataLen = 500 * 1024 // 500 KB
|
|
dataLenLong = 50 * 1024 * 1024 // 50 MB
|
|
)
|
|
|
|
var (
|
|
// PRData contains dataLen bytes of pseudo-random data.
|
|
PRData = GeneratePRData(dataLen)
|
|
// PRDataLong contains dataLenLong bytes of pseudo-random data.
|
|
PRDataLong = GeneratePRData(dataLenLong)
|
|
)
|
|
|
|
// See https://en.wikipedia.org/wiki/Lehmer_random_number_generator
|
|
func GeneratePRData(l int) []byte {
|
|
res := make([]byte, l)
|
|
seed := uint64(1)
|
|
for i := 0; i < l; i++ {
|
|
seed = seed * 48271 % 2147483647
|
|
res[i] = byte(seed)
|
|
}
|
|
return res
|
|
}
|
|
|
|
const logBufSize = 100 * 1 << 20 // initial size of the log buffer: 100 MB
|
|
|
|
type syncedBuffer struct {
|
|
mutex sync.Mutex
|
|
|
|
*bytes.Buffer
|
|
}
|
|
|
|
func (b *syncedBuffer) Write(p []byte) (int, error) {
|
|
b.mutex.Lock()
|
|
n, err := b.Buffer.Write(p)
|
|
b.mutex.Unlock()
|
|
return n, err
|
|
}
|
|
|
|
func (b *syncedBuffer) Bytes() []byte {
|
|
b.mutex.Lock()
|
|
p := b.Buffer.Bytes()
|
|
b.mutex.Unlock()
|
|
return p
|
|
}
|
|
|
|
func (b *syncedBuffer) Reset() {
|
|
b.mutex.Lock()
|
|
b.Buffer.Reset()
|
|
b.mutex.Unlock()
|
|
}
|
|
|
|
var (
|
|
logFileName string // the log file set in the ginkgo flags
|
|
logBufOnce sync.Once
|
|
logBuf *syncedBuffer
|
|
)
|
|
|
|
// read the logfile command line flag
|
|
// to set call ginkgo -- -logfile=log.txt
|
|
func init() {
|
|
flag.StringVar(&logFileName, "logfile", "", "log file")
|
|
}
|
|
|
|
var _ = BeforeEach(func() {
|
|
log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds)
|
|
|
|
if debugLog() {
|
|
logBufOnce.Do(func() {
|
|
logBuf = &syncedBuffer{Buffer: bytes.NewBuffer(make([]byte, 0, logBufSize))}
|
|
})
|
|
utils.DefaultLogger.SetLogLevel(utils.LogLevelDebug)
|
|
log.SetOutput(logBuf)
|
|
}
|
|
})
|
|
|
|
var _ = AfterEach(func() {
|
|
if debugLog() {
|
|
logFile, err := os.Create(logFileName)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
logFile.Write(logBuf.Bytes())
|
|
logFile.Close()
|
|
logBuf.Reset()
|
|
}
|
|
})
|
|
|
|
// Debug says if this test is being logged
|
|
func debugLog() bool {
|
|
return len(logFileName) > 0
|
|
}
|
|
|
|
func TestSelf(t *testing.T) {
|
|
RegisterFailHandler(Fail)
|
|
RunSpecs(t, "Self integration tests")
|
|
}
|
|
|
|
var _ = BeforeSuite(func() {
|
|
rand.Seed(GinkgoRandomSeed())
|
|
})
|