From 86ed3601a2da9740422d7fc28322c7c6a1659e8c Mon Sep 17 00:00:00 2001
From: Tommy Lindgren <tommy.lindgren@zebware.com>
Date: Sun, 19 Oct 2025 10:03:47 +0200
Subject: [PATCH 1/2] Do not attempt to run example tests

---
 example_test.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/example_test.go b/example_test.go
index 4f095d9..e89f56b 100644
--- a/example_test.go
+++ b/example_test.go
@@ -1,3 +1,6 @@
+//go:build example
+// +build example
+
 package stomp_test
 
 import (

From 7885a6a7f168fa3de13850c4c9f91162b89394dd Mon Sep 17 00:00:00 2001
From: Tommy Lindgren <tommy.lindgren@zebware.com>
Date: Sun, 19 Oct 2025 10:44:16 +0200
Subject: [PATCH 2/2] Drop gocheck

---
 conn.go                                 |  26 +-
 conn_test.go                            | 434 ++++++++++++------------
 errors.go                               |   7 +
 frame/encode_test.go                    |  14 +-
 frame/frame.go                          |   8 +
 frame/frame_test.go                     |  54 ++-
 frame/header_test.go                    |  54 +--
 frame/heartbeat_test.go                 |  15 +-
 frame/reader_test.go                    | 117 ++++---
 frame/writer_test.go                    |  23 +-
 go.mod                                  |   3 +-
 go.sum                                  |  18 +
 id.go                                   |  17 -
 id_test.go                              |  43 ---
 send_options.go                         |   2 +-
 server/client/channel_test.go           |  47 ++-
 server/client/client_test.go            |  12 -
 server/client/frame_test.go             |  60 ++--
 server/client/subscription_list_test.go |  62 ++--
 server/client/tx_store_test.go          |  46 ++-
 server/client/util_test.go              |  16 +-
 server/queue/manager_test.go            |  16 +-
 server/queue/memory_queue_test.go       |  40 ++-
 server/queue/queue_test.go              |  12 -
 server/server_test.go                   |  95 +++---
 server/topic/manager_test.go            |  16 +-
 server/topic/testing_test.go            |  12 -
 server/topic/topic_test.go              |  26 +-
 stomp_test.go                           |  18 -
 subscription_test.go                    |  77 ++---
 testutil/fake_conn.go                   |  10 +-
 testutil/fake_conn_test.go              |  45 ++-
 transaction.go                          |   6 +-
 33 files changed, 659 insertions(+), 792 deletions(-)
 delete mode 100644 id.go
 delete mode 100644 id_test.go
 delete mode 100644 server/client/client_test.go
 delete mode 100644 server/queue/queue_test.go
 delete mode 100644 server/topic/testing_test.go
 delete mode 100644 stomp_test.go

diff --git a/conn.go b/conn.go
index 94c3108..59f5db5 100644
--- a/conn.go
+++ b/conn.go
@@ -35,6 +35,7 @@ const ReplyToHeader = "reply-to"
 // A Conn is a connection to a STOMP server. Create a Conn using either
 // the Dial or Connect function.
 type Conn struct {
+	lastId                    uint64
 	conn                      io.ReadWriteCloser
 	readCh                    chan *frame.Frame
 	writeCh                   chan writeRequest
@@ -166,7 +167,7 @@ func ConnectWithContext(ctx context.Context, conn io.ReadWriteCloser, opts ...fu
 	if ok && isNetConn {
 		connection.SetReadDeadline(deadline)
 	}
-	
+
 	response, err := reader.Read()
 	if err != nil {
 		return nil, err
@@ -487,7 +488,7 @@ func (c *Conn) Disconnect() error {
 
 	ch := make(chan *frame.Frame)
 	c.writeCh <- writeRequest{
-		Frame: frame.New(frame.DISCONNECT, frame.Receipt, allocateId()),
+		Frame: frame.New(frame.DISCONNECT, frame.Receipt, c.AllocateID()),
 		C:     ch,
 	}
 
@@ -538,7 +539,7 @@ func (c *Conn) Send(destination, contentType string, body []byte, opts ...func(*
 		return ErrAlreadyClosed
 	}
 
-	f, err := createSendFrame(destination, contentType, body, opts)
+	f, err := createSendFrame(c, destination, contentType, body, opts)
 	if err != nil {
 		return err
 	}
@@ -609,12 +610,16 @@ func sendDataToWriteChWithTimeout(ch chan writeRequest, request writeRequest, ti
 	}
 }
 
-func createSendFrame(destination, contentType string, body []byte, opts []func(*frame.Frame) error) (*frame.Frame, error) {
+func createSendFrame(conn *Conn, destination, contentType string, body []byte, opts []func(*frame.Frame) error) (*frame.Frame, error) {
 	// Set the content-length before the options, because this provides
 	// an opportunity to remove content-length.
 	f := frame.New(frame.SEND, frame.ContentLength, strconv.Itoa(len(body)))
 	f.Body = body
 	f.Header.Set(frame.Destination, destination)
+	f.Conn = conn
+	defer func() {
+		f.Conn = nil
+	}()
 	if contentType != "" {
 		f.Header.Set(frame.ContentType, contentType)
 	}
@@ -728,7 +733,7 @@ func (c *Conn) Subscribe(destination string, ack AckMode, opts ...func(*frame.Fr
 	// create one.
 	id, ok := subscribeFrame.Header.Contains(frame.Id)
 	if !ok {
-		id = allocateId()
+		id = c.AllocateID()
 		subscribeFrame.Header.Add(frame.Id, id)
 	}
 
@@ -803,7 +808,7 @@ func (c *Conn) Begin() *Transaction {
 // BeginWithError is used to start a transaction, but also returns the error
 // (if any) from sending the frame to start the transaction.
 func (c *Conn) BeginWithError() (*Transaction, error) {
-	id := allocateId()
+	id := c.AllocateID()
 	f := frame.New(frame.BEGIN, frame.Transaction, id)
 	err := c.sendFrame(f)
 	return &Transaction{id: id, conn: c}, err
@@ -857,3 +862,12 @@ func (c *Conn) createAckNackFrame(msg *Message, ack bool) (*frame.Frame, error)
 
 	return f, nil
 }
+
+// AllocateID returns a unique number for the current
+// process. Starts at one and increases. Used for
+// allocating subscription ids, receipt ids,
+// transaction ids, etc.
+func (c *Conn) AllocateID() string {
+	id := atomic.AddUint64(&c.lastId, 1)
+	return strconv.FormatUint(id, 10)
+}
diff --git a/conn_test.go b/conn_test.go
index dec0bea..8bd4696 100644
--- a/conn_test.go
+++ b/conn_test.go
@@ -4,13 +4,14 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"testing"
 	"time"
 
 	"github.com/go-stomp/stomp/v3/frame"
 	"github.com/go-stomp/stomp/v3/testutil"
+	"github.com/stretchr/testify/require"
 
 	"github.com/golang/mock/gomock"
-	. "gopkg.in/check.v1"
 )
 
 type fakeReaderWriter struct {
@@ -31,8 +32,8 @@ func (rw *fakeReaderWriter) Close() error {
 	return rw.conn.Close()
 }
 
-func (s *StompSuite) Test_conn_option_set_logger(c *C) {
-	fc1, fc2 := testutil.NewFakeConn(c)
+func TestStompConnOptionSetLogger(t *testing.T) {
+	fc1, fc2 := testutil.NewFakeConn(t)
 	go func() {
 
 		defer func() {
@@ -43,25 +44,25 @@ func (s *StompSuite) Test_conn_option_set_logger(c *C) {
 		reader := frame.NewReader(fc2)
 		writer := frame.NewWriter(fc2)
 		f1, err := reader.Read()
-		c.Assert(err, IsNil)
-		c.Assert(f1.Command, Equals, "CONNECT")
+		require.NoError(t, err)
+		require.Equal(t, "CONNECT", f1.Command)
 		f2 := frame.New("CONNECTED")
 		err = writer.Write(f2)
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 	}()
 
-	ctrl := gomock.NewController(s.t)
+	ctrl := gomock.NewController(t)
 	mockLogger := testutil.NewMockLogger(ctrl)
 
 	conn, err := Connect(fc1, ConnOpt.Logger(mockLogger))
-	c.Assert(err, IsNil)
-	c.Check(conn, NotNil)
+	require.NoError(t, err)
+	require.NotNil(t, conn)
 
-	c.Assert(conn.log, Equals, mockLogger)
+	require.Equal(t, mockLogger, conn.log)
 }
 
-func (s *StompSuite) Test_unsuccessful_connect(c *C) {
-	fc1, fc2 := testutil.NewFakeConn(c)
+func TestStompUnsuccessfulConnect(t *testing.T) {
+	fc1, fc2 := testutil.NewFakeConn(t)
 	stop := make(chan struct{})
 
 	go func() {
@@ -73,19 +74,19 @@ func (s *StompSuite) Test_unsuccessful_connect(c *C) {
 		reader := frame.NewReader(fc2)
 		writer := frame.NewWriter(fc2)
 		f1, err := reader.Read()
-		c.Assert(err, IsNil)
-		c.Assert(f1.Command, Equals, "CONNECT")
+		require.NoError(t, err)
+		require.Equal(t, "CONNECT", f1.Command)
 		f2 := frame.New("ERROR", "message", "auth-failed")
 		err = writer.Write(f2)
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 	}()
 
 	conn, err := Connect(fc1)
-	c.Assert(conn, IsNil)
-	c.Assert(err, ErrorMatches, "auth-failed")
+	require.Nil(t, conn)
+	require.Equal(t, "auth-failed", err.Error())
 }
 
-func (s *StompSuite) Test_successful_connect_and_disconnect(c *C) {
+func TestSuccessfulConnectAndDisconnect(t *testing.T) {
 	testcases := []struct {
 		Options           []func(*Conn) error
 		NegotiatedVersion string
@@ -118,8 +119,7 @@ func (s *StompSuite) Test_successful_connect_and_disconnect(c *C) {
 	}
 
 	for _, tc := range testcases {
-		resetId()
-		fc1, fc2 := testutil.NewFakeConn(c)
+		fc1, fc2 := testutil.NewFakeConn(t)
 		stop := make(chan struct{})
 
 		go func() {
@@ -131,10 +131,10 @@ func (s *StompSuite) Test_successful_connect_and_disconnect(c *C) {
 			writer := frame.NewWriter(fc2)
 
 			f1, err := reader.Read()
-			c.Assert(err, IsNil)
-			c.Assert(f1.Command, Equals, "CONNECT")
+			require.NoError(t, err)
+			require.Equal(t, "CONNECT", f1.Command)
 			host, _ := f1.Header.Contains("host")
-			c.Check(host, Equals, tc.ExpectedHost)
+			require.Equal(t, tc.ExpectedHost, host)
 			connectedFrame := frame.New("CONNECTED")
 			if tc.NegotiatedVersion != "" {
 				connectedFrame.Header.Add("version", tc.NegotiatedVersion)
@@ -146,34 +146,34 @@ func (s *StompSuite) Test_successful_connect_and_disconnect(c *C) {
 				connectedFrame.Header.Add("server", tc.ExpectedServer)
 			}
 			err = writer.Write(connectedFrame)
-			c.Assert(err, IsNil)
+			require.NoError(t, err)
 
 			f2, err := reader.Read()
-			c.Assert(err, IsNil)
-			c.Assert(f2.Command, Equals, "DISCONNECT")
+			require.NoError(t, err)
+			require.Equal(t, "DISCONNECT", f2.Command)
 			receipt, _ := f2.Header.Contains("receipt")
-			c.Check(receipt, Equals, "1")
+			require.Equal(t, "1", receipt)
 
 			err = writer.Write(frame.New("RECEIPT", frame.ReceiptId, "1"))
-			c.Assert(err, IsNil)
+			require.NoError(t, err)
 
 		}()
 
 		client, err := Connect(fc1, tc.Options...)
-		c.Assert(err, IsNil)
-		c.Assert(client, NotNil)
-		c.Assert(client.Version(), Equals, tc.ExpectedVersion)
-		c.Assert(client.Session(), Equals, tc.ExpectedSession)
-		c.Assert(client.Server(), Equals, tc.ExpectedServer)
+		require.NoError(t, err)
+		require.NotNil(t, client)
+		require.Equal(t, tc.ExpectedVersion, client.Version())
+		require.Equal(t, tc.ExpectedSession, client.Session())
+		require.Equal(t, tc.ExpectedServer, client.Server())
 
 		err = client.Disconnect()
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 
 		<-stop
 	}
 }
 
-func (s *StompSuite) Test_successful_connect_get_headers(c *C) {
+func TestStompSuccessfulConnectGetHeaders(t *testing.T) {
 	var respHeaders *frame.Header
 
 	testcases := []struct {
@@ -187,8 +187,7 @@ func (s *StompSuite) Test_successful_connect_get_headers(c *C) {
 	}
 
 	for _, tc := range testcases {
-		resetId()
-		fc1, fc2 := testutil.NewFakeConn(c)
+		fc1, fc2 := testutil.NewFakeConn(t)
 		stop := make(chan struct{})
 
 		go func() {
@@ -200,43 +199,42 @@ func (s *StompSuite) Test_successful_connect_get_headers(c *C) {
 			writer := frame.NewWriter(fc2)
 
 			f1, err := reader.Read()
-			c.Assert(err, IsNil)
-			c.Assert(f1.Command, Equals, "CONNECT")
+			require.NoError(t, err)
+			require.Equal(t, "CONNECT", f1.Command)
 			connectedFrame := frame.New("CONNECTED")
 			for key, value := range tc.Headers {
 				connectedFrame.Header.Add(key, value)
 			}
 			err = writer.Write(connectedFrame)
-			c.Assert(err, IsNil)
+			require.NoError(t, err)
 
 			f2, err := reader.Read()
-			c.Assert(err, IsNil)
-			c.Assert(f2.Command, Equals, "DISCONNECT")
+			require.NoError(t, err)
+			require.Equal(t, "DISCONNECT", f2.Command)
 			receipt, _ := f2.Header.Contains("receipt")
-			c.Check(receipt, Equals, "1")
+			require.Equal(t, "1", receipt)
 
 			err = writer.Write(frame.New("RECEIPT", frame.ReceiptId, "1"))
-			c.Assert(err, IsNil)
+			require.NoError(t, err)
 
 		}()
 
 		client, err := Connect(fc1, tc.Options...)
-		c.Assert(err, IsNil)
-		c.Assert(client, NotNil)
-		c.Assert(respHeaders, NotNil)
+		require.NoError(t, err)
+		require.NotNil(t, client)
+		require.NotNil(t, respHeaders)
 		for key, value := range tc.Headers {
-			c.Assert(respHeaders.Get(key), Equals, value)
+			require.Equal(t, value, respHeaders.Get(key))
 		}
 		err = client.Disconnect()
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 
 		<-stop
 	}
 }
 
-func (s *StompSuite) Test_successful_connect_with_nonstandard_header(c *C) {
-	resetId()
-	fc1, fc2 := testutil.NewFakeConn(c)
+func TestStompSuccessfulConnectWithNonstandardHeader(t *testing.T) {
+	fc1, fc2 := testutil.NewFakeConn(t)
 	stop := make(chan struct{})
 
 	go func() {
@@ -248,49 +246,48 @@ func (s *StompSuite) Test_successful_connect_with_nonstandard_header(c *C) {
 		writer := frame.NewWriter(fc2)
 
 		f1, err := reader.Read()
-		c.Assert(err, IsNil)
-		c.Assert(f1.Command, Equals, "CONNECT")
-		c.Assert(f1.Header.Get("login"), Equals, "guest")
-		c.Assert(f1.Header.Get("passcode"), Equals, "guest")
-		c.Assert(f1.Header.Get("host"), Equals, "/")
-		c.Assert(f1.Header.Get("x-max-length"), Equals, "50")
+		require.NoError(t, err)
+		require.Equal(t, "CONNECT", f1.Command)
+		require.Equal(t, "guest", f1.Header.Get("login"))
+		require.Equal(t, "guest", f1.Header.Get("passcode"))
+		require.Equal(t, "/", f1.Header.Get("host"))
+		require.Equal(t, "50", f1.Header.Get("x-max-length"))
 		connectedFrame := frame.New("CONNECTED")
 		connectedFrame.Header.Add("session", "session-0voRHrG-VbBedx1Gwwb62Q")
 		connectedFrame.Header.Add("heart-beat", "0,0")
 		connectedFrame.Header.Add("server", "RabbitMQ/3.2.1")
 		connectedFrame.Header.Add("version", "1.0")
 		err = writer.Write(connectedFrame)
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 
 		f2, err := reader.Read()
-		c.Assert(err, IsNil)
-		c.Assert(f2.Command, Equals, "DISCONNECT")
+		require.NoError(t, err)
+		require.Equal(t, "DISCONNECT", f2.Command)
 		receipt, _ := f2.Header.Contains("receipt")
-		c.Check(receipt, Equals, "1")
+		require.Equal(t, "1", receipt)
 
 		err = writer.Write(frame.New("RECEIPT", frame.ReceiptId, "1"))
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 	}()
 
 	client, err := Connect(fc1,
 		ConnOpt.Login("guest", "guest"),
 		ConnOpt.Host("/"),
 		ConnOpt.Header("x-max-length", "50"))
-	c.Assert(err, IsNil)
-	c.Assert(client, NotNil)
-	c.Assert(client.Version(), Equals, V10)
-	c.Assert(client.Session(), Equals, "session-0voRHrG-VbBedx1Gwwb62Q")
-	c.Assert(client.Server(), Equals, "RabbitMQ/3.2.1")
+	require.NoError(t, err)
+	require.NotNil(t, client)
+	require.Equal(t, V10, client.Version())
+	require.Equal(t, "session-0voRHrG-VbBedx1Gwwb62Q", client.Session())
+	require.Equal(t, "RabbitMQ/3.2.1", client.Server())
 
 	err = client.Disconnect()
-	c.Assert(err, IsNil)
+	require.NotNil(t, client)
 
 	<-stop
 }
 
-func (s *StompSuite) Test_connect_not_panic_on_empty_response(c *C) {
-	resetId()
-	fc1, fc2 := testutil.NewFakeConn(c)
+func TestStompConnectNotPanicOnEmptyResponse(t *testing.T) {
+	fc1, fc2 := testutil.NewFakeConn(t)
 	stop := make(chan struct{})
 
 	go func() {
@@ -300,22 +297,21 @@ func (s *StompSuite) Test_connect_not_panic_on_empty_response(c *C) {
 		}()
 		reader := frame.NewReader(fc2)
 		_, err := reader.Read()
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 		_, err = fc2.Write([]byte("\n"))
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 	}()
 
 	client, err := Connect(fc1, ConnOpt.Host("the_server"))
-	c.Assert(err, NotNil)
-	c.Assert(client, IsNil)
+	require.Error(t, err)
+	require.Nil(t, client)
 
 	fc1.Close()
 	<-stop
 }
 
-func (s *StompSuite) Test_successful_disconnect_with_receipt_timeout(c *C) {
-	resetId()
-	fc1, fc2 := testutil.NewFakeConn(c)
+func TestSuccessfulDisconnectWithReceiptTimeout(t *testing.T) {
+	fc1, fc2 := testutil.NewFakeConn(t)
 
 	defer func() {
 		fc2.Close()
@@ -326,25 +322,25 @@ func (s *StompSuite) Test_successful_disconnect_with_receipt_timeout(c *C) {
 		writer := frame.NewWriter(fc2)
 
 		f1, err := reader.Read()
-		c.Assert(err, IsNil)
-		c.Assert(f1.Command, Equals, "CONNECT")
+		require.NoError(t, err)
+		require.Equal(t, "CONNECT", f1.Command)
 		connectedFrame := frame.New("CONNECTED")
 		err = writer.Write(connectedFrame)
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 	}()
 
-	client, err := Connect(fc1, ConnOpt.DisconnectReceiptTimeout(1 * time.Nanosecond))
-	c.Assert(err, IsNil)
-	c.Assert(client, NotNil)
+	client, err := Connect(fc1, ConnOpt.DisconnectReceiptTimeout(1*time.Nanosecond))
+	require.NoError(t, err)
+	require.NotNil(t, client)
 
 	err = client.Disconnect()
-	c.Assert(err, Equals, ErrDisconnectReceiptTimeout)
-	c.Assert(client.closed, Equals, true)
+	require.ErrorIs(t, err, ErrDisconnectReceiptTimeout)
+	require.True(t, client.closed)
 }
 
 // Sets up a connection for testing
-func connectHelper(c *C, version Version) (*Conn, *fakeReaderWriter) {
-	fc1, fc2 := testutil.NewFakeConn(c)
+func connectHelper(t testing.TB, version Version) (*Conn, *fakeReaderWriter) {
+	fc1, fc2 := testutil.NewFakeConn(t)
 	stop := make(chan struct{})
 
 	reader := frame.NewReader(fc2)
@@ -352,17 +348,17 @@ func connectHelper(c *C, version Version) (*Conn, *fakeReaderWriter) {
 
 	go func() {
 		f1, err := reader.Read()
-		c.Assert(err, IsNil)
-		c.Assert(f1.Command, Equals, "CONNECT")
+		require.NoError(t, err)
+		require.Equal(t, "CONNECT", f1.Command)
 		f2 := frame.New("CONNECTED", "version", version.String())
 		err = writer.Write(f2)
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 		close(stop)
 	}()
 
 	conn, err := Connect(fc1)
-	c.Assert(err, IsNil)
-	c.Assert(conn, NotNil)
+	require.NoError(t, err)
+	require.NotNil(t, conn)
 	<-stop
 	return conn, &fakeReaderWriter{
 		reader: reader,
@@ -371,22 +367,22 @@ func connectHelper(c *C, version Version) (*Conn, *fakeReaderWriter) {
 	}
 }
 
-func (s *StompSuite) Test_subscribe(c *C) {
+func TestStompSubscribe(t *testing.T) {
 	ackModes := []AckMode{AckAuto, AckClient, AckClientIndividual}
 	versions := []Version{V10, V11, V12}
 
 	for _, ackMode := range ackModes {
 		for _, version := range versions {
-			subscribeHelper(c, ackMode, version)
-			subscribeHelper(c, ackMode, version,
+			subscribeHelper(t, ackMode, version)
+			subscribeHelper(t, ackMode, version,
 				SubscribeOpt.Header("id", "client-1"),
 				SubscribeOpt.Header("custom", "true"))
 		}
 	}
 }
 
-func subscribeHelper(c *C, ackMode AckMode, version Version, opts ...func(*frame.Frame) error) {
-	conn, rw := connectHelper(c, version)
+func subscribeHelper(t testing.TB, ackMode AckMode, version Version, opts ...func(*frame.Frame) error) {
+	conn, rw := connectHelper(t, version)
 	stop := make(chan struct{})
 
 	go func() {
@@ -396,16 +392,16 @@ func subscribeHelper(c *C, ackMode AckMode, version Version, opts ...func(*frame
 		}()
 
 		f3, err := rw.Read()
-		c.Assert(err, IsNil)
-		c.Assert(f3.Command, Equals, "SUBSCRIBE")
+		require.NoError(t, err)
+		require.Equal(t, "SUBSCRIBE", f3.Command)
 
 		id, ok := f3.Header.Contains("id")
-		c.Assert(ok, Equals, true)
+		require.True(t, ok)
 
 		destination := f3.Header.Get("destination")
-		c.Assert(destination, Equals, "/queue/test-1")
+		require.Equal(t, "/queue/test-1", destination)
 		ack := f3.Header.Get("ack")
-		c.Assert(ack, Equals, ackMode.String())
+		require.Equal(t, ackMode.String(), ack)
 
 		for i := 1; i <= 5; i++ {
 			messageId := fmt.Sprintf("message-%d", i)
@@ -419,67 +415,67 @@ func subscribeHelper(c *C, ackMode AckMode, version Version, opts ...func(*frame
 			}
 			f4.Body = []byte(bodyText)
 			err = rw.Write(f4)
-			c.Assert(err, IsNil)
+			require.NoError(t, err)
 
 			if ackMode.ShouldAck() {
 				f5, _ := rw.Read()
-				c.Assert(f5.Command, Equals, "ACK")
+				require.Equal(t, "ACK", f5.Command)
 				if version == V12 {
-					c.Assert(f5.Header.Get(frame.Id), Equals, messageId)
+					require.Equal(t, messageId, f5.Header.Get(frame.Id))
 				} else {
-					c.Assert(f5.Header.Get("subscription"), Equals, id)
-					c.Assert(f5.Header.Get("message-id"), Equals, messageId)
+					require.Equal(t, id, f5.Header.Get("subscription"))
+					require.Equal(t, messageId, f5.Header.Get("message-id"))
 				}
 			}
 		}
 
 		f6, _ := rw.Read()
-		c.Assert(f6.Command, Equals, "UNSUBSCRIBE")
-		c.Assert(f6.Header.Get(frame.Receipt), Not(Equals), "")
-		c.Assert(f6.Header.Get(frame.Id), Equals, id)
+		require.Equal(t, "UNSUBSCRIBE", f6.Command)
+		require.NotEqual(t, "", f6.Header.Get(frame.Receipt))
+		require.Equal(t, id, f6.Header.Get(frame.Id))
 		err = rw.Write(frame.New(frame.RECEIPT, frame.ReceiptId, f6.Header.Get(frame.Receipt)))
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 
 		f7, _ := rw.Read()
-		c.Assert(f7.Command, Equals, "DISCONNECT")
+		require.Equal(t, "DISCONNECT", f7.Command)
 		err = rw.Write(frame.New(frame.RECEIPT, frame.ReceiptId, f7.Header.Get(frame.Receipt)))
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 	}()
 
 	var sub *Subscription
 	var err error
 	sub, err = conn.Subscribe("/queue/test-1", ackMode, opts...)
 
-	c.Assert(sub, NotNil)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
+	require.NotNil(t, sub)
 
 	for i := 1; i <= 5; i++ {
 		msg := <-sub.C
 		messageId := fmt.Sprintf("message-%d", i)
 		bodyText := fmt.Sprintf("Message body %d", i)
-		c.Assert(msg.Subscription, Equals, sub)
-		c.Assert(msg.Body, DeepEquals, []byte(bodyText))
-		c.Assert(msg.Destination, Equals, "/queue/test-1")
-		c.Assert(msg.Header.Get(frame.MessageId), Equals, messageId)
+		require.Equal(t, sub, msg.Subscription)
+		require.Equal(t, []byte(bodyText), msg.Body)
+		require.Equal(t, "/queue/test-1", msg.Destination)
+		require.Equal(t, messageId, msg.Header.Get(frame.MessageId))
 		if version == V12 && ackMode.ShouldAck() {
-			c.Assert(msg.Header.Get(frame.Ack), Equals, messageId)
+			require.Equal(t, messageId, msg.Header.Get(frame.Ack))
 		}
 
-		c.Assert(msg.ShouldAck(), Equals, ackMode.ShouldAck())
+		require.Equal(t, ackMode.ShouldAck(), msg.ShouldAck())
 		if msg.ShouldAck() {
 			err = msg.Conn.Ack(msg)
-			c.Assert(err, IsNil)
+			require.NoError(t, err)
 		}
 	}
 
 	err = sub.Unsubscribe(SubscribeOpt.Header("custom", "true"))
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	err = conn.Disconnect()
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 }
 
-func (s *StompSuite) TestTransaction(c *C) {
+func TestStompTransaction(t *testing.T) {
 
 	ackModes := []AckMode{AckAuto, AckClient, AckClientIndividual}
 	versions := []Version{V10, V11, V12}
@@ -490,15 +486,15 @@ func (s *StompSuite) TestTransaction(c *C) {
 		for _, version := range versions {
 			for _, abort := range aborts {
 				for _, nack := range nacks {
-					subscribeTransactionHelper(c, ackMode, version, abort, nack)
+					subscribeTransactionHelper(t, ackMode, version, abort, nack)
 				}
 			}
 		}
 	}
 }
 
-func subscribeTransactionHelper(c *C, ackMode AckMode, version Version, abort bool, nack bool) {
-	conn, rw := connectHelper(c, version)
+func subscribeTransactionHelper(t *testing.T, ackMode AckMode, version Version, abort bool, nack bool) {
+	conn, rw := connectHelper(t, version)
 	stop := make(chan struct{})
 
 	go func() {
@@ -508,14 +504,14 @@ func subscribeTransactionHelper(c *C, ackMode AckMode, version Version, abort bo
 		}()
 
 		f3, err := rw.Read()
-		c.Assert(err, IsNil)
-		c.Assert(f3.Command, Equals, "SUBSCRIBE")
+		require.NoError(t, err)
+		require.Equal(t, "SUBSCRIBE", f3.Command)
 		id, ok := f3.Header.Contains("id")
-		c.Assert(ok, Equals, true)
+		require.True(t, ok)
 		destination := f3.Header.Get("destination")
-		c.Assert(destination, Equals, "/queue/test-1")
+		require.Equal(t, "/queue/test-1", destination)
 		ack := f3.Header.Get("ack")
-		c.Assert(ack, Equals, ackMode.String())
+		require.Equal(t, ackMode.String(), ack)
 
 		for i := 1; i <= 5; i++ {
 			messageId := fmt.Sprintf("message-%d", i)
@@ -529,164 +525,164 @@ func subscribeTransactionHelper(c *C, ackMode AckMode, version Version, abort bo
 			}
 			f4.Body = []byte(bodyText)
 			err = rw.Write(f4)
-			c.Assert(err, IsNil)
+			require.NoError(t, err)
 
 			beginFrame, err := rw.Read()
-			c.Assert(err, IsNil)
-			c.Assert(beginFrame, NotNil)
-			c.Check(beginFrame.Command, Equals, "BEGIN")
+			require.NoError(t, err)
+			require.NotNil(t, beginFrame)
+			require.Equal(t, "BEGIN", beginFrame.Command)
 			tx, ok := beginFrame.Header.Contains(frame.Transaction)
 
-			c.Assert(ok, Equals, true)
+			require.True(t, ok)
 
 			if ackMode.ShouldAck() {
 				f5, _ := rw.Read()
 				if nack && version.SupportsNack() {
-					c.Assert(f5.Command, Equals, "NACK")
+					require.Equal(t, "NACK", f5.Command)
 				} else {
-					c.Assert(f5.Command, Equals, "ACK")
+					require.Equal(t, "ACK", f5.Command)
 				}
 				if version == V12 {
-					c.Assert(f5.Header.Get(frame.Id), Equals, messageId)
+					require.Equal(t, messageId, f5.Header.Get(frame.Id))
 				} else {
-					c.Assert(f5.Header.Get("subscription"), Equals, id)
-					c.Assert(f5.Header.Get("message-id"), Equals, messageId)
+					require.Equal(t, id, f5.Header.Get("subscription"))
+					require.Equal(t, messageId, f5.Header.Get("message-id"))
 				}
-				c.Assert(f5.Header.Get("transaction"), Equals, tx)
+				require.Equal(t, tx, f5.Header.Get("transaction"))
 			}
 
 			sendFrame, _ := rw.Read()
-			c.Assert(sendFrame, NotNil)
-			c.Assert(sendFrame.Command, Equals, "SEND")
-			c.Assert(sendFrame.Header.Get("transaction"), Equals, tx)
+			require.NotNil(t, sendFrame)
+			require.Equal(t, "SEND", sendFrame.Command)
+			require.Equal(t, tx, sendFrame.Header.Get("transaction"))
 
 			commitFrame, _ := rw.Read()
-			c.Assert(commitFrame, NotNil)
+			require.NotNil(t, commitFrame)
 			if abort {
-				c.Assert(commitFrame.Command, Equals, "ABORT")
+				require.Equal(t, "ABORT", commitFrame.Command)
 			} else {
-				c.Assert(commitFrame.Command, Equals, "COMMIT")
+				require.Equal(t, "COMMIT", commitFrame.Command)
 			}
-			c.Assert(commitFrame.Header.Get("transaction"), Equals, tx)
+			require.Equal(t, tx, commitFrame.Header.Get("transaction"))
 		}
 
 		f6, _ := rw.Read()
-		c.Assert(f6.Command, Equals, "UNSUBSCRIBE")
-		c.Assert(f6.Header.Get(frame.Receipt), Not(Equals), "")
-		c.Assert(f6.Header.Get(frame.Id), Equals, id)
+		require.Equal(t, "UNSUBSCRIBE", f6.Command)
+		require.NotEqual(t, "", f6.Header.Get(frame.Receipt))
+		require.Equal(t, id, f6.Header.Get(frame.Id))
 		err = rw.Write(frame.New(frame.RECEIPT, frame.ReceiptId, f6.Header.Get(frame.Receipt)))
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 
 		f7, _ := rw.Read()
-		c.Assert(f7.Command, Equals, "DISCONNECT")
+		require.Equal(t, "DISCONNECT", f7.Command)
 		err = rw.Write(frame.New(frame.RECEIPT, frame.ReceiptId, f7.Header.Get(frame.Receipt)))
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 	}()
 
 	sub, err := conn.Subscribe("/queue/test-1", ackMode)
-	c.Assert(sub, NotNil)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
+	require.NotNil(t, sub)
 
 	for i := 1; i <= 5; i++ {
 		msg := <-sub.C
 		messageId := fmt.Sprintf("message-%d", i)
 		bodyText := fmt.Sprintf("Message body %d", i)
-		c.Assert(msg.Subscription, Equals, sub)
-		c.Assert(msg.Body, DeepEquals, []byte(bodyText))
-		c.Assert(msg.Destination, Equals, "/queue/test-1")
-		c.Assert(msg.Header.Get(frame.MessageId), Equals, messageId)
+		require.Equal(t, sub, msg.Subscription)
+		require.Equal(t, []byte(bodyText), msg.Body)
+		require.Equal(t, "/queue/test-1", msg.Destination)
+		require.Equal(t, messageId, msg.Header.Get(frame.MessageId))
 
-		c.Assert(msg.ShouldAck(), Equals, ackMode.ShouldAck())
+		require.Equal(t, ackMode.ShouldAck(), msg.ShouldAck())
 		tx := msg.Conn.Begin()
-		c.Assert(tx.Id(), Not(Equals), "")
+		require.NotEqual(t, "", tx.Id())
 		if msg.ShouldAck() {
 			if nack && version.SupportsNack() {
 				err = tx.Nack(msg)
-				c.Assert(err, IsNil)
+				require.NoError(t, err)
 			} else {
 				err = tx.Ack(msg)
-				c.Assert(err, IsNil)
+				require.NoError(t, err)
 			}
 		}
 		err = tx.Send("/queue/another-queue", "text/plain", []byte(bodyText))
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 		if abort {
 			err = tx.Abort()
-			c.Assert(err, IsNil)
+			require.NoError(t, err)
 		} else {
 			err = tx.Commit()
-			c.Assert(err, IsNil)
+			require.NoError(t, err)
 		}
 	}
 
 	err = sub.Unsubscribe()
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	err = conn.Disconnect()
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 }
 
-func (s *StompSuite) TestHeartBeatReadTimeout(c *C) {
-	conn, rw := createHeartBeatConnection(c, 100, 10000, time.Millisecond)
+func TestStompHeartBeatReadTimeout(t *testing.T) {
+	conn, rw := createHeartBeatConnection(t, 100, 10000, time.Millisecond)
 
 	go func() {
 		f1, err := rw.Read()
-		c.Assert(err, IsNil)
-		c.Assert(f1.Command, Equals, "SUBSCRIBE")
+		require.NoError(t, err)
+		require.Equal(t, "SUBSCRIBE", f1.Command)
 		messageFrame := frame.New("MESSAGE",
 			"destination", f1.Header.Get("destination"),
 			"message-id", "1",
 			"subscription", f1.Header.Get("id"))
 		messageFrame.Body = []byte("Message body")
 		err = rw.Write(messageFrame)
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 	}()
 
 	sub, err := conn.Subscribe("/queue/test1", AckAuto)
-	c.Assert(err, IsNil)
-	c.Check(conn.readTimeout, Equals, 101*time.Millisecond)
+	require.NoError(t, err)
+	require.Equal(t, 101*time.Millisecond, conn.readTimeout)
 	//println("read timeout", conn.readTimeout.String())
 
 	msg, ok := <-sub.C
-	c.Assert(msg, NotNil)
-	c.Assert(ok, Equals, true)
+	require.NotNil(t, msg)
+	require.True(t, ok)
 
 	msg, ok = <-sub.C
-	c.Assert(msg, NotNil)
-	c.Assert(ok, Equals, true)
-	c.Assert(msg.Err, NotNil)
-	c.Assert(msg.Err.Error(), Equals, "read timeout")
+	require.NotNil(t, msg)
+	require.True(t, ok)
+	require.Error(t, msg.Err)
+	require.Equal(t, "read timeout", msg.Err.Error())
 
 	msg, ok = <-sub.C
-	c.Assert(msg, IsNil)
-	c.Assert(ok, Equals, false)
+	require.Nil(t, msg)
+	require.False(t, ok)
 
 	stats := conn.Stats()
-	c.Assert(stats.WritesSent, Equals, int64(1))
-	c.Assert(stats.ReadsReceived, Equals, int64(1))
+	require.Equal(t, int64(1), stats.WritesSent)
+	require.Equal(t, int64(1), stats.ReadsReceived)
 }
 
-func (s *StompSuite) TestHeartBeatWriteTimeout(c *C) {
-	c.Skip("not finished yet")
-	conn, rw := createHeartBeatConnection(c, 10000, 100, time.Millisecond*1)
+func TestStompHeartBeatWriteTimeout(t *testing.T) {
+	t.Skip("not finished yet")
+	conn, rw := createHeartBeatConnection(t, 10000, 100, time.Millisecond*1)
 
 	go func() {
 		f1, err := rw.Read()
-		c.Assert(err, IsNil)
-		c.Assert(f1, IsNil)
+		require.NoError(t, err)
+		require.Nil(t, f1)
 
 	}()
 
 	time.Sleep(250)
 	err := conn.Disconnect()
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 }
 
 func createHeartBeatConnection(
-	c *C,
+	t testing.TB,
 	readTimeout, writeTimeout int,
 	readTimeoutError time.Duration) (*Conn, *fakeReaderWriter) {
-	fc1, fc2 := testutil.NewFakeConn(c)
+	fc1, fc2 := testutil.NewFakeConn(t)
 	stop := make(chan struct{})
 
 	reader := frame.NewReader(fc2)
@@ -694,13 +690,13 @@ func createHeartBeatConnection(
 
 	go func() {
 		f1, err := reader.Read()
-		c.Assert(err, IsNil)
-		c.Assert(f1.Command, Equals, "CONNECT")
-		c.Assert(f1.Header.Get("heart-beat"), Equals, "1,1")
+		require.NoError(t, err)
+		require.Equal(t, "CONNECT", f1.Command)
+		require.Equal(t, "1,1", f1.Header.Get("heart-beat"))
 		f2 := frame.New("CONNECTED", "version", "1.2")
 		f2.Header.Add("heart-beat", fmt.Sprintf("%d,%d", readTimeout, writeTimeout))
 		err = writer.Write(f2)
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 		close(stop)
 	}()
 
@@ -708,8 +704,8 @@ func createHeartBeatConnection(
 		ConnOpt.HeartBeat(time.Millisecond, time.Millisecond),
 		ConnOpt.HeartBeatError(readTimeoutError),
 		ConnOpt.WithStats())
-	c.Assert(conn, NotNil)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
+	require.NotNil(t, conn)
 	<-stop
 	return conn, &fakeReaderWriter{
 		reader: reader,
@@ -723,8 +719,7 @@ func sendFrameHelper(f *frame.Frame, c chan *frame.Frame) {
 	c <- f
 }
 
-//// GIVEN_TheTimeoutIsExceededBeforeTheReceiptIsReceived_WHEN_CallingReadReceiptWithTimeout_THEN_ReturnAnError
-func (s *StompSuite) Test_TimeoutTriggers(c *C) {
+func TestStompTimeoutTriggers(t *testing.T) {
 	const timeout = 1 * time.Millisecond
 	f := frame.Frame{}
 	request := writeRequest{
@@ -734,11 +729,10 @@ func (s *StompSuite) Test_TimeoutTriggers(c *C) {
 
 	err := readReceiptWithTimeout(request.C, timeout, ErrMsgReceiptTimeout)
 
-	c.Assert(err, NotNil)
+	require.Error(t, err)
 }
 
-//// GIVEN_TheChannelReceivesTheReceiptBeforeTheTimeoutExpires_WHEN_CallingReadReceiptWithTimeout_THEN_DoNotReturnAnError
-func (s *StompSuite) Test_ChannelReceviesReceipt(c *C) {
+func TestStompChannelReceviesReceipt(t *testing.T) {
 	const timeout = 1 * time.Second
 	f := frame.Frame{}
 	request := writeRequest{
@@ -752,11 +746,10 @@ func (s *StompSuite) Test_ChannelReceviesReceipt(c *C) {
 	go sendFrameHelper(&receipt, request.C)
 	err := readReceiptWithTimeout(request.C, timeout, ErrMsgReceiptTimeout)
 
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 }
 
-//// GIVEN_TheChannelReceivesMessage_AND_TheMessageIsNotAReceipt_WHEN_CallingReadReceiptWithTimeout_THEN_ReturnAnError
-func (s *StompSuite) Test_ChannelReceviesNonReceipt(c *C) {
+func TestStompChannelReceviesNonReceipt(t *testing.T) {
 	const timeout = 1 * time.Second
 	f := frame.Frame{}
 	request := writeRequest{
@@ -770,11 +763,10 @@ func (s *StompSuite) Test_ChannelReceviesNonReceipt(c *C) {
 	go sendFrameHelper(&receipt, request.C)
 	err := readReceiptWithTimeout(request.C, timeout, ErrMsgReceiptTimeout)
 
-	c.Assert(err, NotNil)
+	require.Error(t, err)
 }
 
-//// GIVEN_TheTimeoutIsSetToZero_AND_TheMessageIsReceived_WHEN_CallingReadReceiptWithTimeout_THEN_DoNotReturnAnError
-func (s *StompSuite) Test_ZeroTimeout(c *C) {
+func TestStompZeroTimeout(t *testing.T) {
 	const timeout = 0 * time.Second
 	f := frame.Frame{}
 	request := writeRequest{
@@ -788,11 +780,11 @@ func (s *StompSuite) Test_ZeroTimeout(c *C) {
 	go sendFrameHelper(&receipt, request.C)
 	err := readReceiptWithTimeout(request.C, timeout, ErrMsgReceiptTimeout)
 
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 }
 
-func (s *StompSuite) Test_ConnectWithContext(c *C) {
-	fc1, fc2 := testutil.NewFakeConn(c)
+func TestStompConnectWithContext(t *testing.T) {
+	fc1, fc2 := testutil.NewFakeConn(t)
 
 	go func() {
 		buff := make([]byte, 1024)
@@ -803,7 +795,7 @@ func (s *StompSuite) Test_ConnectWithContext(c *C) {
 	defer cancel()
 
 	_, err := ConnectWithContext(ctx, fc1)
-	// the err here is "io timeout" because the server did not reply to any stomp message 
+	// the err here is "io timeout" because the server did not reply to any stomp message
 	// and the connection waited longer than the 5 seconds we set
-	c.Assert(err, NotNil)
+	require.Error(t, err)
 }
diff --git a/errors.go b/errors.go
index 913ca90..3aabe71 100644
--- a/errors.go
+++ b/errors.go
@@ -34,6 +34,13 @@ func (e Error) Error() string {
 	return e.Message
 }
 
+func (e Error) Is(target error) bool {
+	if err, ok := target.(Error); ok {
+		return e.Message == err.Message
+	}
+	return false
+}
+
 func missingHeader(name string) Error {
 	return newErrorMessage("missing header: " + name)
 }
diff --git a/frame/encode_test.go b/frame/encode_test.go
index 99a1ab9..617922a 100644
--- a/frame/encode_test.go
+++ b/frame/encode_test.go
@@ -1,15 +1,13 @@
 package frame
 
 import (
-	. "gopkg.in/check.v1"
-)
-
-type EncodeSuite struct{}
+	"testing"
 
-var _ = Suite(&EncodeSuite{})
+	"github.com/stretchr/testify/require"
+)
 
-func (s *EncodeSuite) TestUnencodeValue(c *C) {
+func TestEncodeUnencodeValue(t *testing.T) {
 	val, err := unencodeValue([]byte(`Contains\r\nNewLine and \c colon and \\ backslash`))
-	c.Check(err, IsNil)
-	c.Check(val, Equals, "Contains\r\nNewLine and : colon and \\ backslash")
+	require.NoError(t, err)
+	require.Equal(t, "Contains\r\nNewLine and : colon and \\ backslash", val)
 }
diff --git a/frame/frame.go b/frame/frame.go
index a94b5f1..ba5ca3f 100644
--- a/frame/frame.go
+++ b/frame/frame.go
@@ -10,6 +10,14 @@ type Frame struct {
 	Command string
 	Header  *Header
 	Body    []byte
+
+	// Conn is temporarily set to the connection while processing the send
+	// options so the SendOpt functions can allocate IDs.
+	Conn conn
+}
+
+type conn interface {
+	AllocateID() string
 }
 
 // New creates a new STOMP frame with the specified command and headers.
diff --git a/frame/frame_test.go b/frame/frame_test.go
index 1f31a1e..2bf3c14 100644
--- a/frame/frame_test.go
+++ b/frame/frame_test.go
@@ -3,65 +3,57 @@ package frame
 import (
 	"testing"
 
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/require"
 )
 
-func TestFrame(t *testing.T) {
-	TestingT(t)
-}
-
-type FrameSuite struct{}
-
-var _ = Suite(&FrameSuite{})
-
-func (s *FrameSuite) TestNew(c *C) {
+func TestFrameNew(t *testing.T) {
 	f := New("CCC")
-	c.Check(f.Header.Len(), Equals, 0)
-	c.Check(f.Command, Equals, "CCC")
+	require.Equal(t, 0, f.Header.Len())
+	require.Equal(t, "CCC", f.Command)
 
 	f = New("DDDD", "abc", "def")
-	c.Check(f.Header.Len(), Equals, 1)
+	require.Equal(t, 1, f.Header.Len())
 	k, v := f.Header.GetAt(0)
-	c.Check(k, Equals, "abc")
-	c.Check(v, Equals, "def")
-	c.Check(f.Command, Equals, "DDDD")
+	require.Equal(t, "abc", k)
+	require.Equal(t, "def", v)
+	require.Equal(t, "DDDD", f.Command)
 
 	f = New("EEEEEEE", "abc", "def", "hij", "klm")
-	c.Check(f.Command, Equals, "EEEEEEE")
-	c.Check(f.Header.Len(), Equals, 2)
+	require.Equal(t, "EEEEEEE", f.Command)
+	require.Equal(t, 2, f.Header.Len())
 	k, v = f.Header.GetAt(0)
-	c.Check(k, Equals, "abc")
-	c.Check(v, Equals, "def")
+	require.Equal(t, "abc", k)
+	require.Equal(t, "def", v)
 	k, v = f.Header.GetAt(1)
-	c.Check(k, Equals, "hij")
-	c.Check(v, Equals, "klm")
+	require.Equal(t, "hij", k)
+	require.Equal(t, "klm", v)
 }
 
-func (s *FrameSuite) TestClone(c *C) {
+func TestFrameClone(t *testing.T) {
 	f1 := &Frame{
 		Command: "AAAA",
 	}
 
 	f2 := f1.Clone()
-	c.Check(f2.Command, Equals, f1.Command)
-	c.Check(f2.Header, IsNil)
-	c.Check(f2.Body, IsNil)
+	require.Equal(t, f1.Command, f2.Command)
+	require.Nil(t, f2.Header)
+	require.Nil(t, f2.Body)
 
 	f1.Header = NewHeader("aaa", "1", "bbb", "2", "ccc", "3")
 
 	f2 = f1.Clone()
-	c.Check(f2.Header.Len(), Equals, f1.Header.Len())
+	require.Equal(t, f2.Header.Len(), f2.Header.Len())
 	for i := 0; i < f1.Header.Len(); i++ {
 		k1, v1 := f1.Header.GetAt(i)
 		k2, v2 := f2.Header.GetAt(i)
-		c.Check(k1, Equals, k2)
-		c.Check(v1, Equals, v2)
+		require.Equal(t, k1, k2)
+		require.Equal(t, v1, v2)
 	}
 
 	f1.Body = []byte{1, 2, 3, 4, 5, 6, 5, 4, 77, 88, 99, 0xaa, 0xbb, 0xcc, 0xff}
 	f2 = f1.Clone()
-	c.Check(len(f2.Body), Equals, len(f1.Body))
+	require.Len(t, f2.Body, len(f1.Body))
 	for i := 0; i < len(f1.Body); i++ {
-		c.Check(f1.Body[i], Equals, f2.Body[i])
+		require.Equal(t, f1.Body[i], f2.Body[i])
 	}
 }
diff --git a/frame/header_test.go b/frame/header_test.go
index 11330db..85cf46d 100644
--- a/frame/header_test.go
+++ b/frame/header_test.go
@@ -1,23 +1,25 @@
 package frame
 
 import (
-	. "gopkg.in/check.v1"
+	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
-func (s *FrameSuite) TestHeaderGetSetAddDel(c *C) {
+func TestHeaderGetSetAddDel(t *testing.T) {
 	h := &Header{}
-	c.Assert(h.Get("xxx"), Equals, "")
+	require.Equal(t, "", h.Get("xxx"))
 	h.Add("xxx", "yyy")
-	c.Assert(h.Get("xxx"), Equals, "yyy")
+	require.Equal(t, "yyy", h.Get("xxx"))
 	h.Add("xxx", "zzz")
-	c.Assert(h.GetAll("xxx"), DeepEquals, []string{"yyy", "zzz"})
+	require.Equal(t, []string{"yyy", "zzz"}, h.GetAll("xxx"))
 	h.Set("xxx", "111")
-	c.Assert(h.Get("xxx"), Equals, "111")
+	require.Equal(t, h.Get("xxx"), "111")
 	h.Del("xxx")
-	c.Assert(h.Get("xxx"), Equals, "")
+	require.Equal(t, "", h.Get("xxx"))
 }
 
-func (s *FrameSuite) TestHeaderClone(c *C) {
+func TestHeaderClone(t *testing.T) {
 	h := Header{}
 	h.Set("xxx", "yyy")
 	h.Set("yyy", "zzz")
@@ -25,42 +27,42 @@ func (s *FrameSuite) TestHeaderClone(c *C) {
 	hc := h.Clone()
 	h.Del("xxx")
 	h.Del("yyy")
-	c.Assert(hc.Get("xxx"), Equals, "yyy")
-	c.Assert(hc.Get("yyy"), Equals, "zzz")
+	require.Equal(t, "yyy", hc.Get("xxx"))
+	require.Equal(t, "zzz", hc.Get("yyy"))
 }
 
-func (s *FrameSuite) TestHeaderContains(c *C) {
+func TestHeaderContains(t *testing.T) {
 	h := NewHeader("xxx", "yyy", "zzz", "aaa", "xxx", "ccc")
 	v, ok := h.Contains("xxx")
-	c.Assert(v, Equals, "yyy")
-	c.Assert(ok, Equals, true)
+	require.Equal(t, "yyy", v)
+	require.True(t, ok)
 
 	v, ok = h.Contains("123")
-	c.Assert(v, Equals, "")
-	c.Assert(ok, Equals, false)
+	require.Equal(t, v, "")
+	require.False(t, ok)
 }
 
-func (s *FrameSuite) TestContentLength(c *C) {
+func TestHeaderContentLength(t *testing.T) {
 	h := NewHeader("xxx", "yy", "content-length", "202", "zz", "123")
 	cl, ok, err := h.ContentLength()
-	c.Assert(cl, Equals, 202)
-	c.Assert(ok, Equals, true)
-	c.Assert(err, Equals, nil)
+	require.Equal(t, 202, cl)
+	require.True(t, ok)
+	require.NoError(t, err)
 
 	h.Set("content-length", "twenty")
 	cl, ok, err = h.ContentLength()
-	c.Assert(cl, Equals, 0)
-	c.Assert(ok, Equals, true)
-	c.Assert(err, NotNil)
+	require.Equal(t, 0, cl)
+	require.True(t, ok)
+	require.Error(t, err)
 
 	h.Del("content-length")
 	cl, ok, err = h.ContentLength()
-	c.Assert(cl, Equals, 0)
-	c.Assert(ok, Equals, false)
-	c.Assert(err, IsNil)
+	require.Equal(t, 0, cl)
+	require.False(t, ok)
+	require.NoError(t, err)
 }
 
-func (s *FrameSuite) TestLit(c *C) {
+func TestHeaderLit(t *testing.T) {
 	_ = Frame{
 		Command: "CONNECT",
 		Header:  NewHeader("login", "xxx", "passcode", "yyy"),
diff --git a/frame/heartbeat_test.go b/frame/heartbeat_test.go
index 6dff501..85e53bd 100644
--- a/frame/heartbeat_test.go
+++ b/frame/heartbeat_test.go
@@ -1,12 +1,13 @@
 package frame
 
 import (
+	"testing"
 	"time"
 
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/require"
 )
 
-func (s *FrameSuite) TestParseHeartBeat(c *C) {
+func TestFrameParseHeartBeat(t *testing.T) {
 	testCases := []struct {
 		Input             string
 		ExpectedDuration1 time.Duration
@@ -63,15 +64,15 @@ func (s *FrameSuite) TestParseHeartBeat(c *C) {
 
 	for _, tc := range testCases {
 		d1, d2, err := ParseHeartBeat(tc.Input)
-		c.Check(d1, Equals, tc.ExpectedDuration1)
-		c.Check(d2, Equals, tc.ExpectedDuration2)
+		require.Equal(t, tc.ExpectedDuration1, d1)
+		require.Equal(t, tc.ExpectedDuration2, d2)
 		if tc.ExpectError || tc.ExpectedError != nil {
-			c.Check(err, NotNil)
+			require.Error(t, err)
 			if tc.ExpectedError != nil {
-				c.Check(err, Equals, tc.ExpectedError)
+				require.ErrorIs(t, err, tc.ExpectedError)
 			}
 		} else {
-			c.Check(err, IsNil)
+			require.NoError(t, err)
 		}
 	}
 }
diff --git a/frame/reader_test.go b/frame/reader_test.go
index d3baabf..220dca3 100644
--- a/frame/reader_test.go
+++ b/frame/reader_test.go
@@ -3,30 +3,27 @@ package frame
 import (
 	"io"
 	"strings"
+	"testing"
 	"testing/iotest"
 
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/require"
 )
 
-type ReaderSuite struct{}
-
-var _ = Suite(&ReaderSuite{})
-
-func (s *ReaderSuite) TestConnect(c *C) {
+func TestReaderConnect(t *testing.T) {
 	reader := NewReader(strings.NewReader("CONNECT\nlogin:xxx\npasscode:yyy\n\n\x00"))
 
 	frame, err := reader.Read()
-	c.Assert(err, IsNil)
-	c.Assert(frame, NotNil)
-	c.Assert(len(frame.Body), Equals, 0)
+	require.Nil(t, err)
+	require.NotNil(t, frame)
+	require.Len(t, frame.Body, 0)
 
 	// ensure we are at the end of input
 	frame, err = reader.Read()
-	c.Assert(frame, IsNil)
-	c.Assert(err, Equals, io.EOF)
+	require.Nil(t, frame)
+	require.ErrorIs(t, err, io.EOF)
 }
 
-func (s *ReaderSuite) TestMultipleReads(c *C) {
+func TestReaderMultipleReads(t *testing.T) {
 	text := "SEND\ndestination:xxx\n\nPayload\x00\n" +
 		"SEND\ndestination:yyy\ncontent-length:12\n" +
 		"dodgy\\c\\n\\cheader:dodgy\\c\\n\\r\\nvalue\\  \\\n\n" +
@@ -44,97 +41,97 @@ func (s *ReaderSuite) TestMultipleReads(c *C) {
 		//ioreader = iotest.NewReadLogger("RX", ioreader)
 		reader := NewReader(ioreader)
 		frame, err := reader.Read()
-		c.Assert(err, IsNil)
-		c.Assert(frame, NotNil)
-		c.Assert(frame.Command, Equals, "SEND")
-		c.Assert(frame.Header.Len(), Equals, 1)
+		require.NoError(t, err)
+		require.NotNil(t, frame)
+		require.Equal(t, "SEND", frame.Command)
+		require.Equal(t, 1, frame.Header.Len())
 		v := frame.Header.Get("destination")
-		c.Assert(v, Equals, "xxx")
-		c.Assert(string(frame.Body), Equals, "Payload")
+		require.Equal(t, "xxx", v)
+		require.Equal(t, "Payload", string(frame.Body))
 
 		// now read a heart-beat from the input
 		frame, err = reader.Read()
-		c.Assert(err, IsNil)
-		c.Assert(frame, IsNil)
+		require.NoError(t, err)
+		require.Nil(t, frame)
 
 		// this frame has content-length
 		frame, err = reader.Read()
-		c.Assert(err, IsNil)
-		c.Assert(frame, NotNil)
-		c.Assert(frame.Command, Equals, "SEND")
-		c.Assert(frame.Header.Len(), Equals, 3)
+		require.NoError(t, err)
+		require.NotNil(t, frame)
+		require.Equal(t, "SEND", frame.Command)
+		require.Equal(t, 3, frame.Header.Len())
 		v = frame.Header.Get("destination")
-		c.Assert(v, Equals, "yyy")
+		require.Equal(t, "yyy", v)
 		n, ok, err := frame.Header.ContentLength()
-		c.Assert(n, Equals, 12)
-		c.Assert(ok, Equals, true)
-		c.Assert(err, IsNil)
+		require.Equal(t, 12, n)
+		require.True(t, ok)
+		require.NoError(t, err)
 		k, v := frame.Header.GetAt(2)
-		c.Assert(k, Equals, "dodgy:\n:header")
-		c.Assert(v, Equals, "dodgy:\n\r\nvalue\\  \\")
-		c.Assert(string(frame.Body), Equals, "123456789AB\x00")
+		require.Equal(t, "dodgy:\n:header", k)
+		require.Equal(t, "dodgy:\n\r\nvalue\\  \\", v)
+		require.Equal(t, "123456789AB\x00", string(frame.Body))
 
 		// ensure we are at the end of input
 		frame, err = reader.Read()
-		c.Assert(frame, IsNil)
-		c.Assert(err, Equals, io.EOF)
+		require.Nil(t, frame)
+		require.ErrorIs(t, err, io.EOF)
 	}
 }
 
-func (s *ReaderSuite) TestSendWithContentLength(c *C) {
+func TestReaderSendWithContentLength(t *testing.T) {
 	reader := NewReader(strings.NewReader("SEND\ndestination:xxx\ncontent-length:5\n\n\x00\x01\x02\x03\x04\x00"))
 
 	frame, err := reader.Read()
-	c.Assert(err, IsNil)
-	c.Assert(frame, NotNil)
-	c.Assert(frame.Command, Equals, "SEND")
-	c.Assert(frame.Header.Len(), Equals, 2)
+	require.NoError(t, err)
+	require.NotNil(t, frame)
+	require.Equal(t, "SEND", frame.Command)
+	require.Equal(t, 2, frame.Header.Len())
 	v := frame.Header.Get("destination")
-	c.Assert(v, Equals, "xxx")
-	c.Assert(frame.Body, DeepEquals, []byte{0x00, 0x01, 0x02, 0x03, 0x04})
+	require.Equal(t, "xxx", v)
+	require.Equal(t, []byte{0x00, 0x01, 0x02, 0x03, 0x04}, frame.Body)
 
 	// ensure we are at the end of input
 	frame, err = reader.Read()
-	c.Assert(frame, IsNil)
-	c.Assert(err, Equals, io.EOF)
+	require.Nil(t, frame)
+	require.ErrorIs(t, err, io.EOF)
 }
 
-func (s *ReaderSuite) TestInvalidCommand(c *C) {
+func TestReaderInvalidCommand(t *testing.T) {
 	reader := NewReader(strings.NewReader("sEND\ndestination:xxx\ncontent-length:5\n\n\x00\x01\x02\x03\x04\x00"))
 
 	frame, err := reader.Read()
-	c.Check(frame, IsNil)
-	c.Assert(err, NotNil)
-	c.Check(err.Error(), Equals, "invalid command")
+	require.Nil(t, frame)
+	require.Error(t, err)
+	require.Equal(t, "invalid command", err.Error())
 }
 
-func (s *ReaderSuite) TestMissingNull(c *C) {
+func TestReaderMissingNull(t *testing.T) {
 	reader := NewReader(strings.NewReader("SEND\ndeestination:xxx\ncontent-length:5\n\n\x00\x01\x02\x03\x04\n"))
 
 	f, err := reader.Read()
-	c.Check(f, IsNil)
-	c.Assert(err, NotNil)
-	c.Check(err.Error(), Equals, "invalid frame format")
+	require.Nil(t, f)
+	require.Error(t, err)
+	require.Equal(t, "invalid frame format", err.Error())
 }
 
-func (s *ReaderSuite) TestSubscribeWithoutId(c *C) {
-	c.Skip("TODO: implement validate")
+func TestReaderSubscribeWithoutId(t *testing.T) {
+	t.Skip("TODO: implement validate")
 
 	reader := NewReader(strings.NewReader("SUBSCRIBE\ndestination:xxx\nIId:7\n\n\x00"))
 
 	frame, err := reader.Read()
-	c.Check(frame, IsNil)
-	c.Assert(err, NotNil)
-	c.Check(err.Error(), Equals, "missing header: id")
+	require.Nil(t, frame)
+	require.Error(t, err)
+	require.Equal(t, "missing header: id", err.Error())
 }
 
-func (s *ReaderSuite) TestUnsubscribeWithoutId(c *C) {
-	c.Skip("TODO: implement validate")
+func TestReaderUnsubscribeWithoutId(t *testing.T) {
+	t.Skip("TODO: implement validate")
 
 	reader := NewReader(strings.NewReader("UNSUBSCRIBE\nIId:7\n\n\x00"))
 
 	frame, err := reader.Read()
-	c.Check(frame, IsNil)
-	c.Assert(err, NotNil)
-	c.Check(err.Error(), Equals, "missing header: id")
+	require.Nil(t, frame)
+	require.Error(t, err)
+	require.Equal(t, "missing header: id", err.Error())
 }
diff --git a/frame/writer_test.go b/frame/writer_test.go
index ea5a1f5..4eeed6b 100644
--- a/frame/writer_test.go
+++ b/frame/writer_test.go
@@ -3,15 +3,12 @@ package frame
 import (
 	"bytes"
 	"strings"
+	"testing"
 
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/require"
 )
 
-type WriterSuite struct{}
-
-var _ = Suite(&WriterSuite{})
-
-func (s *WriterSuite) TestWrites(c *C) {
+func TestWriterWrites(t *testing.T) {
 	var frameTexts = []string{
 		"CONNECT\nlogin:xxx\npasscode:yyy\n\n\x00",
 
@@ -27,22 +24,22 @@ func (s *WriterSuite) TestWrites(c *C) {
 	}
 
 	for _, frameText := range frameTexts {
-		writeToBufferAndCheck(c, frameText)
+		writeToBufferAndCheck(t, frameText)
 	}
 }
 
-func writeToBufferAndCheck(c *C, frameText string) {
+func writeToBufferAndCheck(t *testing.T, frameText string) {
 	reader := NewReader(strings.NewReader(frameText))
 
 	frame, err := reader.Read()
-	c.Assert(err, IsNil)
-	c.Assert(frame, NotNil)
+	require.NoError(t, err)
+	require.NotNil(t, frame)
 
 	var b bytes.Buffer
 	var writer = NewWriter(&b)
 	err = writer.Write(frame)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	newFrameText := b.String()
-	c.Check(newFrameText, Equals, frameText)
-	c.Check(b.String(), Equals, frameText)
+	require.Equal(t, frameText, newFrameText)
+	require.Equal(t, frameText, b.String())
 }
diff --git a/go.mod b/go.mod
index 365a3bd..ff9953f 100644
--- a/go.mod
+++ b/go.mod
@@ -4,5 +4,6 @@ go 1.15
 
 require (
 	github.com/golang/mock v1.6.0
-	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c
+	github.com/stretchr/testify v1.11.1
+	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 )
diff --git a/go.sum b/go.sum
index 1f0429d..d7be973 100644
--- a/go.sum
+++ b/go.sum
@@ -1,3 +1,6 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
 github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
 github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
@@ -5,6 +8,17 @@ github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfn
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
@@ -28,5 +42,9 @@ golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/id.go b/id.go
deleted file mode 100644
index cd84748..0000000
--- a/id.go
+++ /dev/null
@@ -1,17 +0,0 @@
-package stomp
-
-import (
-	"strconv"
-	"sync/atomic"
-)
-
-var _lastId uint64
-
-// allocateId returns a unique number for the current
-// process. Starts at one and increases. Used for
-// allocating subscription ids, receipt ids,
-// transaction ids, etc.
-func allocateId() string {
-	id := atomic.AddUint64(&_lastId, 1)
-	return strconv.FormatUint(id, 10)
-}
diff --git a/id_test.go b/id_test.go
deleted file mode 100644
index 074ce6b..0000000
--- a/id_test.go
+++ /dev/null
@@ -1,43 +0,0 @@
-package stomp
-
-import (
-	. "gopkg.in/check.v1"
-	"runtime"
-)
-
-// only used during testing, does not need to be thread-safe
-func resetId() {
-	_lastId = 0
-}
-
-func (s *StompSuite) SetUpSuite(c *C) {
-	resetId()
-	runtime.GOMAXPROCS(runtime.NumCPU())
-}
-
-func (s *StompSuite) TearDownSuite(c *C) {
-	runtime.GOMAXPROCS(1)
-}
-
-func (s *StompSuite) TestAllocateId(c *C) {
-	c.Assert(allocateId(), Equals, "1")
-	c.Assert(allocateId(), Equals, "2")
-
-	ch := make(chan bool, 50)
-	for i := 0; i < 50; i++ {
-		go doAllocate(100, ch)
-	}
-
-	for i := 0; i < 50; i++ {
-		<-ch
-	}
-
-	c.Assert(allocateId(), Equals, "5003")
-}
-
-func doAllocate(count int, ch chan bool) {
-	for i := 0; i < count; i++ {
-		_ = allocateId()
-	}
-	ch <- true
-}
diff --git a/send_options.go b/send_options.go
index bd81b00..0a42cea 100644
--- a/send_options.go
+++ b/send_options.go
@@ -30,7 +30,7 @@ func init() {
 		if f.Command != frame.SEND {
 			return ErrInvalidCommand
 		}
-		id := allocateId()
+		id := f.Conn.AllocateID()
 		f.Header.Set(frame.Receipt, id)
 		return nil
 	}
diff --git a/server/client/channel_test.go b/server/client/channel_test.go
index 083a600..4aa0b16 100644
--- a/server/client/channel_test.go
+++ b/server/client/channel_test.go
@@ -1,15 +1,12 @@
 package client
 
 import (
-	. "gopkg.in/check.v1"
-)
-
-// Test suite for testing that channels work the way I expect.
-type ChannelSuite struct{}
+	"testing"
 
-var _ = Suite(&ChannelSuite{})
+	"github.com/stretchr/testify/require"
+)
 
-func (s *ChannelSuite) TestChannelWhenClosed(c *C) {
+func TestChannelWhenClosed(t *testing.T) {
 
 	ch := make(chan int, 10)
 
@@ -18,22 +15,22 @@ func (s *ChannelSuite) TestChannelWhenClosed(c *C) {
 
 	select {
 	case i, ok := <-ch:
-		c.Assert(i, Equals, 1)
-		c.Assert(ok, Equals, true)
+		require.Equal(t, 1, i)
+		require.True(t, ok)
 	default:
-		c.Error("expected value on channel")
+		t.Fatal("expected value on channel")
 	}
 
 	select {
 	case i := <-ch:
-		c.Assert(i, Equals, 2)
+		require.Equal(t, 2, i)
 	default:
-		c.Error("expected value on channel")
+		t.Fatal("expected value on channel")
 	}
 
 	select {
 	case _ = <-ch:
-		c.Error("not expecting anything on the channel")
+		t.Fatal("not expecting anything on the channel")
 	default:
 	}
 
@@ -42,27 +39,27 @@ func (s *ChannelSuite) TestChannelWhenClosed(c *C) {
 
 	select {
 	case i := <-ch:
-		c.Assert(i, Equals, 3)
+		require.Equal(t, 3, i)
 	default:
-		c.Error("expected value on channel")
+		t.Fatal("expected value on channel")
 	}
 
 	select {
 	case _, ok := <-ch:
-		c.Assert(ok, Equals, false)
+		require.False(t, ok)
 	default:
-		c.Error("expected value on channel")
+		t.Fatal("expected value on channel")
 	}
 
 	select {
 	case _, ok := <-ch:
-		c.Assert(ok, Equals, false)
+		require.False(t, ok)
 	default:
-		c.Error("expected value on channel")
+		t.Fatal("expected value on channel")
 	}
 }
 
-func (s *ChannelSuite) TestMultipleChannels(c *C) {
+func TestChannelMultipleChannels(t *testing.T) {
 
 	ch1 := make(chan int, 10)
 	ch2 := make(chan string, 10)
@@ -71,18 +68,18 @@ func (s *ChannelSuite) TestMultipleChannels(c *C) {
 
 	select {
 	case i, ok := <-ch1:
-		c.Assert(i, Equals, 1)
-		c.Assert(ok, Equals, true)
+		require.Equal(t, 1, i)
+		require.True(t, ok)
 	case _ = <-ch2:
 	default:
-		c.Error("expected value on channel")
+		t.Fatal("expected value on channel")
 	}
 
 	select {
 	case _ = <-ch1:
-		c.Error("not expected")
+		t.Fatal("not expected")
 	case _ = <-ch2:
-		c.Error("not expected")
+		t.Fatal("not expected")
 	default:
 	}
 }
diff --git a/server/client/client_test.go b/server/client/client_test.go
deleted file mode 100644
index 034e86d..0000000
--- a/server/client/client_test.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package client
-
-import (
-	"gopkg.in/check.v1"
-	"testing"
-)
-
-// Runs all gocheck tests in this package.
-// See other *_test.go files for gocheck tests.
-func TestClient(t *testing.T) {
-	check.TestingT(t)
-}
diff --git a/server/client/frame_test.go b/server/client/frame_test.go
index 508e6cb..97637da 100644
--- a/server/client/frame_test.go
+++ b/server/client/frame_test.go
@@ -1,82 +1,80 @@
 package client
 
 import (
+	"testing"
+
 	"github.com/go-stomp/stomp/v3"
 	"github.com/go-stomp/stomp/v3/frame"
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/require"
 )
 
-type FrameSuite struct{}
-
-var _ = Suite(&FrameSuite{})
-
-func (s *FrameSuite) TestDetermineVersion_V10_Connect(c *C) {
+func TestFrameDetermineVersion_V10_Connect(t *testing.T) {
 	f := frame.New(frame.CONNECT)
 	version, err := determineVersion(f)
-	c.Check(err, IsNil)
-	c.Check(version, Equals, stomp.V10)
+	require.NoError(t, err)
+	require.Equal(t, stomp.V10, version)
 }
 
-func (s *FrameSuite) TestDetermineVersion_V10_Stomp(c *C) {
+func TestFrameDetermineVersion_V10_Stomp(t *testing.T) {
 	// the "STOMP" command was introduced in V1.1, so it must
 	// have an accept-version header
 	f := frame.New(frame.STOMP)
 	_, err := determineVersion(f)
-	c.Check(err, Equals, missingHeader(frame.AcceptVersion))
+	require.ErrorIs(t, err, missingHeader(frame.AcceptVersion))
 }
 
-func (s *FrameSuite) TestDetermineVersion_V11_Connect(c *C) {
+func TestFrameDetermineVersion_V11_Connect(t *testing.T) {
 	f := frame.New(frame.CONNECT)
 	f.Header.Add(frame.AcceptVersion, "1.1")
 	version, err := determineVersion(f)
-	c.Check(version, Equals, stomp.V11)
-	c.Check(err, IsNil)
+	require.NoError(t, err)
+	require.Equal(t, stomp.V11, version)
 }
 
-func (s *FrameSuite) TestDetermineVersion_MultipleVersions(c *C) {
+func TestFrameDetermineVersion_MultipleVersions(t *testing.T) {
 	f := frame.New(frame.CONNECT)
 	f.Header.Add(frame.AcceptVersion, "1.2,1.1,1.0,2.0")
 	version, err := determineVersion(f)
-	c.Check(version, Equals, stomp.V12)
-	c.Check(err, IsNil)
+	require.NoError(t, err)
+	require.Equal(t, stomp.V12, version)
 }
 
-func (s *FrameSuite) TestDetermineVersion_IncompatibleVersions(c *C) {
+func TestFrameDetermineVersion_IncompatibleVersions(t *testing.T) {
 	f := frame.New(frame.CONNECT)
 	f.Header.Add(frame.AcceptVersion, "0.2,0.1,1.3,2.0")
 	version, err := determineVersion(f)
-	c.Check(version, Equals, stomp.Version(""))
-	c.Check(err, Equals, unknownVersion)
+	require.ErrorIs(t, err, unknownVersion)
+	require.Equal(t, stomp.Version(""), version)
 }
 
-func (s *FrameSuite) TestHeartBeat(c *C) {
+func TestFrameHeartBeat(t *testing.T) {
 	f := frame.New(frame.CONNECT,
 		frame.AcceptVersion, "1.2",
 		frame.Host, "XX")
 
 	// no heart-beat header means zero values
 	x, y, err := getHeartBeat(f)
-	c.Check(x, Equals, 0)
-	c.Check(y, Equals, 0)
-	c.Check(err, IsNil)
+	require.NoError(t, err)
+	require.Equal(t, 0, x)
+	require.Equal(t, 0, y)
 
 	f.Header.Add("heart-beat", "123,456")
 	x, y, err = getHeartBeat(f)
-	c.Check(x, Equals, 123)
-	c.Check(y, Equals, 456)
-	c.Check(err, IsNil)
+	require.NoError(t, err)
+	require.Equal(t, 123, x)
+	require.Equal(t, 456, y)
 
 	f.Header.Set(frame.HeartBeat, "invalid")
 	x, y, err = getHeartBeat(f)
-	c.Check(x, Equals, 0)
-	c.Check(y, Equals, 0)
-	c.Check(err, Equals, invalidHeartBeat)
+	require.Equal(t, 0, x)
+	require.Equal(t, 0, y)
+	require.ErrorIs(t, err, invalidHeartBeat)
 
 	f.Header.Del(frame.HeartBeat)
 	_, _, err = getHeartBeat(f)
-	c.Check(err, IsNil)
+	require.NoError(t, err)
 
 	f.Command = frame.SEND
 	_, _, err = getHeartBeat(f)
-	c.Check(err, Equals, invalidOperationForFrame)
+	require.ErrorIs(t, err, invalidOperationForFrame)
 }
diff --git a/server/client/subscription_list_test.go b/server/client/subscription_list_test.go
index 8d471e6..0b55d88 100644
--- a/server/client/subscription_list_test.go
+++ b/server/client/subscription_list_test.go
@@ -1,14 +1,12 @@
 package client
 
 import (
-	. "gopkg.in/check.v1"
-)
-
-type SubscriptionListSuite struct{}
+	"testing"
 
-var _ = Suite(&SubscriptionListSuite{})
+	"github.com/stretchr/testify/require"
+)
 
-func (s *SubscriptionListSuite) TestAddAndGet(c *C) {
+func TestSubscriptionListAddAndGet(t *testing.T) {
 	sub1 := newSubscription(nil, "/dest", "1", "client")
 	sub2 := newSubscription(nil, "/dest", "2", "client")
 	sub3 := newSubscription(nil, "/dest", "3", "client")
@@ -18,19 +16,19 @@ func (s *SubscriptionListSuite) TestAddAndGet(c *C) {
 	sl.Add(sub2)
 	sl.Add(sub3)
 
-	c.Check(sl.Get(), Equals, sub1)
+	require.Equal(t, sub1, sl.Get())
 
 	// add the subscription again, should go to the back
 	sl.Add(sub1)
 
-	c.Check(sl.Get(), Equals, sub2)
-	c.Check(sl.Get(), Equals, sub3)
-	c.Check(sl.Get(), Equals, sub1)
+	require.Equal(t, sub2, sl.Get())
+	require.Equal(t, sub3, sl.Get())
+	require.Equal(t, sub1, sl.Get())
 
-	c.Check(sl.Get(), IsNil)
+	require.Nil(t, sl.Get())
 }
 
-func (s *SubscriptionListSuite) TestAddAndRemove(c *C) {
+func TestSubscriptionListAddAndRemove(t *testing.T) {
 	sub1 := newSubscription(nil, "/dest", "1", "client")
 	sub2 := newSubscription(nil, "/dest", "2", "client")
 	sub3 := newSubscription(nil, "/dest", "3", "client")
@@ -40,17 +38,17 @@ func (s *SubscriptionListSuite) TestAddAndRemove(c *C) {
 	sl.Add(sub2)
 	sl.Add(sub3)
 
-	c.Check(sl.subs.Len(), Equals, 3)
+	require.Equal(t, 3, sl.subs.Len())
 
 	// now remove the second subscription
 	sl.Remove(sub2)
 
-	c.Check(sl.Get(), Equals, sub1)
-	c.Check(sl.Get(), Equals, sub3)
-	c.Check(sl.Get(), IsNil)
+	require.Equal(t, sub1, sl.Get())
+	require.Equal(t, sub3, sl.Get())
+	require.Nil(t, sl.Get())
 }
 
-func (s *SubscriptionListSuite) TestAck(c *C) {
+func TestSubscriptionListAck(t *testing.T) {
 	sub1 := &Subscription{dest: "/dest1", id: "1", ack: "client", msgId: 101}
 	sub2 := &Subscription{dest: "/dest3", id: "2", ack: "client-individual", msgId: 102}
 	sub3 := &Subscription{dest: "/dest4", id: "3", ack: "client", msgId: 103}
@@ -62,7 +60,7 @@ func (s *SubscriptionListSuite) TestAck(c *C) {
 	sl.Add(sub3)
 	sl.Add(sub4)
 
-	c.Check(sl.subs.Len(), Equals, 4)
+	require.Equal(t, 4, sl.subs.Len())
 
 	var subs []*Subscription
 	callback := func(s *Subscription) {
@@ -72,16 +70,16 @@ func (s *SubscriptionListSuite) TestAck(c *C) {
 	// now remove the second subscription
 	sl.Ack(103, callback)
 
-	c.Assert(len(subs), Equals, 2)
-	c.Assert(subs[0], Equals, sub1)
-	c.Assert(subs[1], Equals, sub3)
+	require.Len(t, subs, 2)
+	require.Equal(t, sub1, subs[0])
+	require.Equal(t, sub3, subs[1])
 
-	c.Assert(sl.Get(), Equals, sub2)
-	c.Assert(sl.Get(), Equals, sub4)
-	c.Assert(sl.Get(), IsNil)
+	require.Equal(t, sub2, sl.Get())
+	require.Equal(t, sub4, sl.Get())
+	require.Nil(t, sl.Get())
 }
 
-func (s *SubscriptionListSuite) TestNack(c *C) {
+func TestSubscriptionListNack(t *testing.T) {
 	sub1 := &Subscription{dest: "/dest1", id: "1", ack: "client", msgId: 101}
 	sub2 := &Subscription{dest: "/dest3", id: "2", ack: "client-individual", msgId: 102}
 	sub3 := &Subscription{dest: "/dest4", id: "3", ack: "client", msgId: 103}
@@ -93,7 +91,7 @@ func (s *SubscriptionListSuite) TestNack(c *C) {
 	sl.Add(sub3)
 	sl.Add(sub4)
 
-	c.Check(sl.subs.Len(), Equals, 4)
+	require.Equal(t, 4, sl.subs.Len())
 
 	var subs []*Subscription
 	callback := func(s *Subscription) {
@@ -103,11 +101,11 @@ func (s *SubscriptionListSuite) TestNack(c *C) {
 	// now remove the second subscription
 	sl.Nack(103, callback)
 
-	c.Assert(len(subs), Equals, 1)
-	c.Assert(subs[0], Equals, sub3)
+	require.Len(t, subs, 1)
+	require.Equal(t, sub3, subs[0])
 
-	c.Assert(sl.Get(), Equals, sub1)
-	c.Assert(sl.Get(), Equals, sub2)
-	c.Assert(sl.Get(), Equals, sub4)
-	c.Assert(sl.Get(), IsNil)
+	require.Equal(t, sub1, sl.Get())
+	require.Equal(t, sub2, sl.Get())
+	require.Equal(t, sub4, sl.Get())
+	require.Nil(t, sl.Get())
 }
diff --git a/server/client/tx_store_test.go b/server/client/tx_store_test.go
index eca2774..17e105f 100644
--- a/server/client/tx_store_test.go
+++ b/server/client/tx_store_test.go
@@ -1,32 +1,30 @@
 package client
 
 import (
+	"testing"
+
 	"github.com/go-stomp/stomp/v3/frame"
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/require"
 )
 
-type TxStoreSuite struct{}
-
-var _ = Suite(&TxStoreSuite{})
-
-func (s *TxStoreSuite) TestDoubleBegin(c *C) {
+func TestTxStoreDoubleBegin(t *testing.T) {
 	txs := txStore{}
 
 	err := txs.Begin("tx1")
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	err = txs.Begin("tx1")
-	c.Assert(err, Equals, txAlreadyInProgress)
+	require.ErrorIs(t, err, txAlreadyInProgress)
 }
 
-func (s *TxStoreSuite) TestSuccessfulTx(c *C) {
+func TestTxStoreSuccessfulTx(t *testing.T) {
 	txs := txStore{}
 
 	err := txs.Begin("tx1")
-	c.Check(err, IsNil)
+	require.NoError(t, err)
 
 	err = txs.Begin("tx2")
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	f1 := frame.New(frame.MESSAGE,
 		frame.Destination, "/queue/1")
@@ -41,11 +39,11 @@ func (s *TxStoreSuite) TestSuccessfulTx(c *C) {
 		frame.Destination, "/queue/4")
 
 	err = txs.Add("tx1", f1)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	err = txs.Add("tx1", f2)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	err = txs.Add("tx1", f3)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	err = txs.Add("tx2", f4)
 
 	var tx1 []*frame.Frame
@@ -54,7 +52,7 @@ func (s *TxStoreSuite) TestSuccessfulTx(c *C) {
 		tx1 = append(tx1, f)
 		return nil
 	})
-	c.Check(err, IsNil)
+	require.NoError(t, err)
 
 	var tx2 []*frame.Frame
 
@@ -62,20 +60,20 @@ func (s *TxStoreSuite) TestSuccessfulTx(c *C) {
 		tx2 = append(tx2, f)
 		return nil
 	})
-	c.Check(err, IsNil)
+	require.NoError(t, err)
 
-	c.Check(len(tx1), Equals, 3)
-	c.Check(tx1[0], Equals, f1)
-	c.Check(tx1[1], Equals, f2)
-	c.Check(tx1[2], Equals, f3)
+	require.Len(t, tx1, 3)
+	require.Equal(t, f1, tx1[0])
+	require.Equal(t, f2, tx1[1])
+	require.Equal(t, f3, tx1[2])
 
-	c.Check(len(tx2), Equals, 1)
-	c.Check(tx2[0], Equals, f4)
+	require.Len(t, tx2, 1)
+	require.Equal(t, f4, tx2[0])
 
 	// already committed, so should cause an error
 	err = txs.Commit("tx1", func(f *frame.Frame) error {
-		c.Fatal("should not be called")
+		t.Fatal("should not be called")
 		return nil
 	})
-	c.Check(err, Equals, txUnknown)
+	require.ErrorIs(t, err, txUnknown)
 }
diff --git a/server/client/util_test.go b/server/client/util_test.go
index c577f61..52f4ac3 100644
--- a/server/client/util_test.go
+++ b/server/client/util_test.go
@@ -1,23 +1,21 @@
 package client
 
 import (
-	. "gopkg.in/check.v1"
 	"math"
+	"testing"
 	"time"
-)
-
-type UtilSuite struct{}
 
-var _ = Suite(&UtilSuite{})
+	"github.com/stretchr/testify/require"
+)
 
-func (s *UtilSuite) TestAsMilliseconds(c *C) {
+func TestUtilAsMilliseconds(t *testing.T) {
 	d := time.Duration(30) * time.Millisecond
-	c.Check(asMilliseconds(d, math.MaxInt32), Equals, 30)
+	require.Equal(t, 30, asMilliseconds(d, math.MaxInt32))
 
 	// approximately one year
 	d = time.Duration(365) * time.Duration(24) * time.Hour
-	c.Check(asMilliseconds(d, math.MaxInt32), Equals, math.MaxInt32)
+	require.Equal(t, math.MaxInt32, asMilliseconds(d, math.MaxInt32))
 
 	d = time.Duration(365) * time.Duration(24) * time.Hour
-	c.Check(asMilliseconds(d, maxHeartBeat), Equals, maxHeartBeat)
+	require.Equal(t, maxHeartBeat, asMilliseconds(d, maxHeartBeat))
 }
diff --git a/server/queue/manager_test.go b/server/queue/manager_test.go
index d74bd54..ac434d0 100644
--- a/server/queue/manager_test.go
+++ b/server/queue/manager_test.go
@@ -1,21 +1,19 @@
 package queue
 
 import (
-	. "gopkg.in/check.v1"
-)
-
-type ManagerSuite struct{}
+	"testing"
 
-var _ = Suite(&ManagerSuite{})
+	"github.com/stretchr/testify/require"
+)
 
-func (s *ManagerSuite) TestManager(c *C) {
+func TestManager(t *testing.T) {
 	mgr := NewManager(NewMemoryQueueStorage())
 
 	q1 := mgr.Find("/queue/1")
-	c.Assert(q1, NotNil)
+	require.NotNil(t, q1)
 
 	q2 := mgr.Find("/queue/2")
-	c.Assert(q2, NotNil)
+	require.NotNil(t, q2)
 
-	c.Assert(mgr.Find("/queue/1"), Equals, q1)
+	require.Equal(t, q1, mgr.Find("/queue/1"))
 }
diff --git a/server/queue/memory_queue_test.go b/server/queue/memory_queue_test.go
index 7037291..a7c57e4 100644
--- a/server/queue/memory_queue_test.go
+++ b/server/queue/memory_queue_test.go
@@ -1,15 +1,13 @@
 package queue
 
 import (
+	"testing"
+
 	"github.com/go-stomp/stomp/v3/frame"
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/require"
 )
 
-type MemoryQueueSuite struct{}
-
-var _ = Suite(&MemoryQueueSuite{})
-
-func (s *MemoryQueueSuite) Test1(c *C) {
+func TestMemoryQueue(t *testing.T) {
 	mq := NewMemoryQueueStorage()
 	mq.Start()
 
@@ -19,7 +17,7 @@ func (s *MemoryQueueSuite) Test1(c *C) {
 		frame.Subscription, "1")
 
 	err := mq.Enqueue("/queue/test", f1)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	f2 := frame.New(frame.MESSAGE,
 		frame.Destination, "/queue/test",
@@ -27,7 +25,7 @@ func (s *MemoryQueueSuite) Test1(c *C) {
 		frame.Subscription, "1")
 
 	err = mq.Enqueue("/queue/test", f2)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	f3 := frame.New(frame.MESSAGE,
 		frame.Destination, "/queue/test2",
@@ -35,30 +33,30 @@ func (s *MemoryQueueSuite) Test1(c *C) {
 		frame.Subscription, "2")
 
 	err = mq.Enqueue("/queue/test2", f3)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	// attempt to dequeue from a different queue
 	f, err := mq.Dequeue("/queue/other-queue")
-	c.Check(err, IsNil)
-	c.Assert(f, IsNil)
+	require.NoError(t, err)
+	require.Nil(t, f)
 
 	f, err = mq.Dequeue("/queue/test2")
-	c.Check(err, IsNil)
-	c.Assert(f, Equals, f3)
+	require.NoError(t, err)
+	require.Equal(t, f3, f)
 
 	f, err = mq.Dequeue("/queue/test")
-	c.Check(err, IsNil)
-	c.Assert(f, Equals, f1)
+	require.NoError(t, err)
+	require.Equal(t, f1, f)
 
 	f, err = mq.Dequeue("/queue/test")
-	c.Check(err, IsNil)
-	c.Assert(f, Equals, f2)
+	require.NoError(t, err)
+	require.Equal(t, f2, f)
 
 	f, err = mq.Dequeue("/queue/test")
-	c.Check(err, IsNil)
-	c.Assert(f, IsNil)
+	require.NoError(t, err)
+	require.Nil(t, f)
 
 	f, err = mq.Dequeue("/queue/test2")
-	c.Check(err, IsNil)
-	c.Assert(f, IsNil)
+	require.NoError(t, err)
+	require.Nil(t, f)
 }
diff --git a/server/queue/queue_test.go b/server/queue/queue_test.go
deleted file mode 100644
index 8517172..0000000
--- a/server/queue/queue_test.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package queue
-
-import (
-	"gopkg.in/check.v1"
-	"testing"
-)
-
-// Runs all gocheck tests in this package.
-// See other *_test.go files for gocheck tests.
-func TestQueue(t *testing.T) {
-	check.TestingT(t)
-}
diff --git a/server/server_test.go b/server/server_test.go
index 9ab099e..0a1bb2e 100644
--- a/server/server_test.go
+++ b/server/server_test.go
@@ -8,50 +8,33 @@ import (
 	"time"
 
 	"github.com/go-stomp/stomp/v3"
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/require"
 )
 
-func TestServer(t *testing.T) {
-	TestingT(t)
-}
-
-type ServerSuite struct{}
-
-var _ = Suite(&ServerSuite{})
-
-func (s *ServerSuite) SetUpSuite(c *C) {
-	runtime.GOMAXPROCS(runtime.NumCPU())
-}
-
-func (s *ServerSuite) TearDownSuite(c *C) {
-	runtime.GOMAXPROCS(1)
-}
-
-func (s *ServerSuite) TestConnectAndDisconnect(c *C) {
+func TestServerConnectAndDisconnect(t *testing.T) {
 	addr := ":59091"
 	l, err := net.Listen("tcp", addr)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	defer func() { l.Close() }()
 	go Serve(l)
 
 	conn, err := net.Dial("tcp", "127.0.0.1"+addr)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	client, err := stomp.Connect(conn)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	err = client.Disconnect()
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	conn.Close()
 }
 
-
-func (s *ServerSuite) TestHeartBeatingTolerance(c *C) {
+func TestServerHeartBeatingTolerance(t *testing.T) {
 	// Heart beat should not close connection exactly after not receiving message after cx
 	//  it should add a pretty decent amount of time to counter network delay of other timing issues
 	l, err := net.Listen("tcp", `127.0.0.1:0`)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	defer func() { l.Close() }()
 	serv := Server{
 		Addr:          l.Addr().String(),
@@ -62,30 +45,30 @@ func (s *ServerSuite) TestHeartBeatingTolerance(c *C) {
 	go serv.Serve(l)
 
 	conn, err := net.Dial("tcp", l.Addr().String())
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	defer conn.Close()
 
-	client, err := stomp.Connect(conn, 
-		stomp.ConnOpt.HeartBeat(5 * time.Millisecond, 5 * time.Millisecond),
+	client, err := stomp.Connect(conn,
+		stomp.ConnOpt.HeartBeat(5*time.Millisecond, 5*time.Millisecond),
 	)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	defer client.Disconnect()
 
 	time.Sleep(serv.HeartBeat * 20) // let it go for some time to allow client and server to exchange some heart beat
 
 	// Ensure the server has not closed his readChannel
 	err = client.Send("/topic/whatever", "text/plain", []byte("hello"))
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 }
 
-func (s *ServerSuite) TestSendToQueuesAndTopics(c *C) {
+func TestServerSendToQueuesAndTopics(t *testing.T) {
 	ch := make(chan bool, 2)
 	println("number cpus:", runtime.NumCPU())
 
 	addr := ":59092"
 
 	l, err := net.Listen("tcp", addr)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	defer func() { l.Close() }()
 	go Serve(l)
 
@@ -93,35 +76,35 @@ func (s *ServerSuite) TestSendToQueuesAndTopics(c *C) {
 	started := make(chan bool)
 
 	count := 100
-	go runReceiver(c, ch, count, "/topic/test-1", addr, started)
+	go runReceiver(t, ch, count, "/topic/test-1", addr, started)
 	<-started
-	go runReceiver(c, ch, count, "/topic/test-1", addr, started)
+	go runReceiver(t, ch, count, "/topic/test-1", addr, started)
 	<-started
-	go runReceiver(c, ch, count, "/topic/test-2", addr, started)
+	go runReceiver(t, ch, count, "/topic/test-2", addr, started)
 	<-started
-	go runReceiver(c, ch, count, "/topic/test-2", addr, started)
+	go runReceiver(t, ch, count, "/topic/test-2", addr, started)
 	<-started
-	go runReceiver(c, ch, count, "/topic/test-1", addr, started)
+	go runReceiver(t, ch, count, "/topic/test-1", addr, started)
 	<-started
-	go runReceiver(c, ch, count, "/queue/test-1", addr, started)
+	go runReceiver(t, ch, count, "/queue/test-1", addr, started)
 	<-started
-	go runSender(c, ch, count, "/queue/test-1", addr, started)
+	go runSender(t, ch, count, "/queue/test-1", addr, started)
 	<-started
-	go runSender(c, ch, count, "/queue/test-2", addr, started)
+	go runSender(t, ch, count, "/queue/test-2", addr, started)
 	<-started
-	go runReceiver(c, ch, count, "/queue/test-2", addr, started)
+	go runReceiver(t, ch, count, "/queue/test-2", addr, started)
 	<-started
-	go runSender(c, ch, count, "/topic/test-1", addr, started)
+	go runSender(t, ch, count, "/topic/test-1", addr, started)
 	<-started
-	go runReceiver(c, ch, count, "/queue/test-3", addr, started)
+	go runReceiver(t, ch, count, "/queue/test-3", addr, started)
 	<-started
-	go runSender(c, ch, count, "/queue/test-3", addr, started)
+	go runSender(t, ch, count, "/queue/test-3", addr, started)
 	<-started
-	go runSender(c, ch, count, "/queue/test-4", addr, started)
+	go runSender(t, ch, count, "/queue/test-4", addr, started)
 	<-started
-	go runSender(c, ch, count, "/topic/test-2", addr, started)
+	go runSender(t, ch, count, "/topic/test-2", addr, started)
 	<-started
-	go runReceiver(c, ch, count, "/queue/test-4", addr, started)
+	go runReceiver(t, ch, count, "/queue/test-4", addr, started)
 	<-started
 
 	for i := 0; i < 15; i++ {
@@ -129,12 +112,12 @@ func (s *ServerSuite) TestSendToQueuesAndTopics(c *C) {
 	}
 }
 
-func runSender(c *C, ch chan bool, count int, destination, addr string, started chan bool) {
+func runSender(t testing.TB, ch chan bool, count int, destination, addr string, started chan bool) {
 	conn, err := net.Dial("tcp", "127.0.0.1"+addr)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	client, err := stomp.Connect(conn)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	started <- true
 
@@ -147,23 +130,23 @@ func runSender(c *C, ch chan bool, count int, destination, addr string, started
 	ch <- true
 }
 
-func runReceiver(c *C, ch chan bool, count int, destination, addr string, started chan bool) {
+func runReceiver(t testing.TB, ch chan bool, count int, destination, addr string, started chan bool) {
 	conn, err := net.Dial("tcp", "127.0.0.1"+addr)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	client, err := stomp.Connect(conn)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	sub, err := client.Subscribe(destination, stomp.AckAuto)
-	c.Assert(err, IsNil)
-	c.Assert(sub, NotNil)
+	require.NoError(t, err)
+	require.NotNil(t, sub)
 
 	started <- true
 
 	for i := 0; i < count; i++ {
 		msg := <-sub.C
 		expectedText := fmt.Sprintf("%s test message %d", destination, i)
-		c.Assert(msg.Body, DeepEquals, []byte(expectedText))
+		require.Equal(t, []byte(expectedText), msg.Body)
 		//println("received", i)
 	}
 	ch <- true
diff --git a/server/topic/manager_test.go b/server/topic/manager_test.go
index 2fa76df..0ab45bf 100644
--- a/server/topic/manager_test.go
+++ b/server/topic/manager_test.go
@@ -1,21 +1,19 @@
 package topic
 
 import (
-	. "gopkg.in/check.v1"
-)
-
-type ManagerSuite struct{}
+	"testing"
 
-var _ = Suite(&ManagerSuite{})
+	"github.com/stretchr/testify/require"
+)
 
-func (s *ManagerSuite) TestManager(c *C) {
+func TestManager(t *testing.T) {
 	mgr := NewManager()
 
 	t1 := mgr.Find("topic1")
-	c.Assert(t1, NotNil)
+	require.NotNil(t, t1)
 
 	t2 := mgr.Find("topic2")
-	c.Assert(t2, NotNil)
+	require.NotNil(t, t2)
 
-	c.Assert(mgr.Find("topic1"), Equals, t1)
+	require.Equal(t, t1, mgr.Find("topic1"))
 }
diff --git a/server/topic/testing_test.go b/server/topic/testing_test.go
deleted file mode 100644
index 21ec5c6..0000000
--- a/server/topic/testing_test.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package topic
-
-import (
-	"gopkg.in/check.v1"
-	"testing"
-)
-
-// Runs all gocheck tests in this package.
-// See other *_test.go files for gocheck tests.
-func Test(t *testing.T) {
-	check.TestingT(t)
-}
diff --git a/server/topic/topic_test.go b/server/topic/topic_test.go
index 863c0d1..17cd6fc 100644
--- a/server/topic/topic_test.go
+++ b/server/topic/topic_test.go
@@ -1,15 +1,13 @@
 package topic
 
 import (
+	"testing"
+
 	"github.com/go-stomp/stomp/v3/frame"
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/require"
 )
 
-type TopicSuite struct{}
-
-var _ = Suite(&TopicSuite{})
-
-func (s *TopicSuite) TestTopicWithoutSubscription(c *C) {
+func TestTopicWithoutSubscription(t *testing.T) {
 	topic := newTopic("destination")
 
 	f := frame.New(frame.MESSAGE,
@@ -18,7 +16,7 @@ func (s *TopicSuite) TestTopicWithoutSubscription(c *C) {
 	topic.Enqueue(f)
 }
 
-func (s *TopicSuite) TestTopicWithOneSubscription(c *C) {
+func TestTopicWithOneSubscription(t *testing.T) {
 	sub := &fakeSubscription{}
 
 	topic := newTopic("destination")
@@ -29,11 +27,11 @@ func (s *TopicSuite) TestTopicWithOneSubscription(c *C) {
 
 	topic.Enqueue(f)
 
-	c.Assert(len(sub.Frames), Equals, 1)
-	c.Assert(sub.Frames[0], Equals, f)
+	require.Len(t, sub.Frames, 1)
+	require.Equal(t, f, sub.Frames[0])
 }
 
-func (s *TopicSuite) TestTopicWithTwoSubscriptions(c *C) {
+func TestTopicWithTwoSubscriptions(t *testing.T) {
 	sub1 := &fakeSubscription{}
 	sub2 := &fakeSubscription{}
 
@@ -47,10 +45,10 @@ func (s *TopicSuite) TestTopicWithTwoSubscriptions(c *C) {
 
 	topic.Enqueue(f)
 
-	c.Assert(len(sub1.Frames), Equals, 1)
-	c.Assert(len(sub2.Frames), Equals, 1)
-	c.Assert(sub1.Frames[0], Not(Equals), f)
-	c.Assert(sub2.Frames[0], Equals, f)
+	require.Len(t, sub1.Frames, 1)
+	require.Len(t, sub2.Frames, 1)
+	require.NotSame(t, f, sub1.Frames[0])
+	require.Equal(t, f, sub2.Frames[0])
 }
 
 type fakeSubscription struct {
diff --git a/stomp_test.go b/stomp_test.go
deleted file mode 100644
index f8feca0..0000000
--- a/stomp_test.go
+++ /dev/null
@@ -1,18 +0,0 @@
-package stomp
-
-import (
-	"testing"
-
-	"gopkg.in/check.v1"
-)
-
-// Runs all gocheck tests in this package.
-// See other *_test.go files for gocheck tests.
-func TestStomp(t *testing.T) {
-	check.Suite(&StompSuite{t})
-	check.TestingT(t)
-}
-
-type StompSuite struct {
-	t *testing.T
-}
diff --git a/subscription_test.go b/subscription_test.go
index 97c538b..61084b5 100644
--- a/subscription_test.go
+++ b/subscription_test.go
@@ -1,18 +1,17 @@
 package stomp
 
 import (
-	"github.com/go-stomp/stomp/v3/frame"
-	"github.com/go-stomp/stomp/v3/testutil"
 	"sync"
+	"testing"
 	"time"
 
-	. "gopkg.in/check.v1"
+	"github.com/go-stomp/stomp/v3/frame"
+	"github.com/go-stomp/stomp/v3/testutil"
+	"github.com/stretchr/testify/require"
 )
 
-func (s *StompSuite) Test_successful_unsubscribe_with_receipt_timeout(c *C) {
-	resetId()
-
-	wg, fc1, fc2 := runFakeConn(c,
+func TestStompSuccessfulUnsubscribeWithReceiptTimeout(t *testing.T) {
+	wg, fc1, fc2 := runFakeConn(t,
 		assertConnectFrame,
 		sendConnectedFrame,
 		assertSubscribeFrame,
@@ -22,22 +21,20 @@ func (s *StompSuite) Test_successful_unsubscribe_with_receipt_timeout(c *C) {
 	defer fc2.Close()
 
 	client, err := Connect(fc1, ConnOpt.UnsubscribeReceiptTimeout(1*time.Second))
-	c.Assert(err, IsNil)
-	c.Assert(client, NotNil)
+	require.NoError(t, err)
+	require.NotNil(t, client)
 
 	sub, err := client.Subscribe("/queue/test", AckAuto)
-	c.Assert(err, IsNil)
-	c.Assert(sub, NotNil)
+	require.NoError(t, err)
+	require.NotNil(t, sub)
 
 	err = sub.Unsubscribe()
-	c.Assert(err, Equals, &ErrUnsubscribeReceiptTimeout)
+	require.ErrorIs(t, err, ErrUnsubscribeReceiptTimeout)
 	wg.Wait()
 }
 
-func (s *StompSuite) Test_successful_unsubscribe_no_timeout(c *C) {
-	resetId()
-
-	wg, fc1, fc2 := runFakeConn(c,
+func TestStompSuccessfulUnsubscribeNoTimeout(t *testing.T) {
+	wg, fc1, fc2 := runFakeConn(t,
 		assertConnectFrame,
 		sendConnectedFrame,
 		assertSubscribeFrame,
@@ -48,23 +45,23 @@ func (s *StompSuite) Test_successful_unsubscribe_no_timeout(c *C) {
 	defer fc2.Close()
 
 	client, err := Connect(fc1)
-	c.Assert(err, IsNil)
-	c.Assert(client, NotNil)
+	require.NoError(t, err)
+	require.NotNil(t, client)
 
 	sub, err := client.Subscribe("/queue/test", AckAuto)
-	c.Assert(err, IsNil)
-	c.Assert(sub, NotNil)
+	require.NoError(t, err)
+	require.NotNil(t, sub)
 
 	err = sub.Unsubscribe()
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	wg.Wait()
 }
 
 // serverOperation is a function that performs a server operation that either reads or writes a frame and returns it.
-type serverOperation func(c *C, reader *frame.Reader, writer *frame.Writer, previousFrames []*frame.Frame) (*frame.Frame, error)
+type serverOperation func(t testing.TB, reader *frame.Reader, writer *frame.Writer, previousFrames []*frame.Frame) (*frame.Frame, error)
 
-func runFakeConn(c *C, operations ...serverOperation) (*sync.WaitGroup, *testutil.FakeConn, *testutil.FakeConn) {
-	client, server := testutil.NewFakeConn(c)
+func runFakeConn(t testing.TB, operations ...serverOperation) (*sync.WaitGroup, *testutil.FakeConn, *testutil.FakeConn) {
+	client, server := testutil.NewFakeConn(t)
 
 	wg := &sync.WaitGroup{}
 	go func() {
@@ -75,10 +72,10 @@ func runFakeConn(c *C, operations ...serverOperation) (*sync.WaitGroup, *testuti
 
 		frames := make([]*frame.Frame, 0)
 		for _, operation := range operations {
-			frame, err := operation(c, reader, writer, frames)
+			frame, err := operation(t, reader, writer, frames)
 			frames = append(frames, frame)
 			if err != nil {
-				c.Errorf("error in server operation: %v", err)
+				t.Fatalf("error in server operation: %v", err)
 				return
 			}
 		}
@@ -87,43 +84,43 @@ func runFakeConn(c *C, operations ...serverOperation) (*sync.WaitGroup, *testuti
 	return wg, client, server
 }
 
-func assertConnectFrame(c *C, reader *frame.Reader, _ *frame.Writer, _ []*frame.Frame) (*frame.Frame, error) {
+func assertConnectFrame(t testing.TB, reader *frame.Reader, _ *frame.Writer, _ []*frame.Frame) (*frame.Frame, error) {
 	f, err := reader.Read()
-	c.Assert(err, IsNil)
-	c.Assert(f.Command, Equals, frame.CONNECT)
+	require.NoError(t, err)
+	require.Equal(t, frame.CONNECT, f.Command)
 	return f, err
 }
 
-func sendConnectedFrame(c *C, _ *frame.Reader, writer *frame.Writer, _ []*frame.Frame) (*frame.Frame, error) {
+func sendConnectedFrame(t testing.TB, _ *frame.Reader, writer *frame.Writer, _ []*frame.Frame) (*frame.Frame, error) {
 	f := frame.New(frame.CONNECTED)
 	err := writer.Write(f)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	return f, err
 }
 
-func assertSubscribeFrame(c *C, reader *frame.Reader, _ *frame.Writer, _ []*frame.Frame) (*frame.Frame, error) {
+func assertSubscribeFrame(t testing.TB, reader *frame.Reader, _ *frame.Writer, _ []*frame.Frame) (*frame.Frame, error) {
 	f, err := reader.Read()
-	c.Assert(err, IsNil)
-	c.Assert(f.Command, Equals, frame.SUBSCRIBE)
+	require.NoError(t, err)
+	require.Equal(t, frame.SUBSCRIBE, f.Command)
 	return f, err
 }
 
-func assertUnsubscribeFrame(c *C, reader *frame.Reader, _ *frame.Writer, _ []*frame.Frame) (*frame.Frame, error) {
+func assertUnsubscribeFrame(t testing.TB, reader *frame.Reader, _ *frame.Writer, _ []*frame.Frame) (*frame.Frame, error) {
 	f, err := reader.Read()
-	c.Assert(err, IsNil)
-	c.Assert(f.Command, Equals, frame.UNSUBSCRIBE)
+	require.NoError(t, err)
+	require.Equal(t, frame.UNSUBSCRIBE, f.Command)
 	return f, err
 }
 
 // sendReceiptFrame returns a server operation that writes a RECEIPT frame to the writer based on the id of the previous frame
 func sendReceiptFrame(frameId int) serverOperation {
-	return func(c *C, _ *frame.Reader, writer *frame.Writer, previousFrames []*frame.Frame) (*frame.Frame, error) {
+	return func(t testing.TB, _ *frame.Reader, writer *frame.Writer, previousFrames []*frame.Frame) (*frame.Frame, error) {
 		f := frame.New(frame.RECEIPT)
 		previousFrame := previousFrames[frameId]
-		c.Assert(previousFrame, NotNil)
+		require.NotNil(t, previousFrame)
 		f.Header.Set(frame.ReceiptId, previousFrame.Header.Get(frame.Id))
 		err := writer.Write(f)
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 		return f, err
 	}
 }
diff --git a/testutil/fake_conn.go b/testutil/fake_conn.go
index 117bc34..a2aa062 100644
--- a/testutil/fake_conn.go
+++ b/testutil/fake_conn.go
@@ -2,9 +2,9 @@ package testutil
 
 import (
 	"errors"
-	. "gopkg.in/check.v1"
 	"io"
 	"net"
+	"testing"
 	"time"
 )
 
@@ -24,7 +24,7 @@ func (addr *FakeAddr) String() string {
 // the net.Conn interface and is useful for simulating I/O between
 // STOMP clients and a STOMP server.
 type FakeConn struct {
-	C            *C
+	T            testing.TB
 	writer       io.WriteCloser
 	reader       io.ReadCloser
 	localAddr    net.Addr
@@ -39,14 +39,14 @@ var (
 
 // NewFakeConn returns a pair of fake connections suitable for
 // testing.
-func NewFakeConn(c *C) (client *FakeConn, server *FakeConn) {
+func NewFakeConn(t testing.TB) (client *FakeConn, server *FakeConn) {
 	clientReader, serverWriter := io.Pipe()
 	serverReader, clientWriter := io.Pipe()
 	clientAddr := &FakeAddr{Value: "the-client:123"}
 	serverAddr := &FakeAddr{Value: "the-server:456"}
 
 	clientConn := &FakeConn{
-		C:          c,
+		T:          t,
 		reader:     clientReader,
 		writer:     clientWriter,
 		localAddr:  clientAddr,
@@ -54,7 +54,7 @@ func NewFakeConn(c *C) (client *FakeConn, server *FakeConn) {
 	}
 
 	serverConn := &FakeConn{
-		C:          c,
+		T:          t,
 		reader:     serverReader,
 		writer:     serverWriter,
 		localAddr:  serverAddr,
diff --git a/testutil/fake_conn_test.go b/testutil/fake_conn_test.go
index 0ca9273..f21da97 100644
--- a/testutil/fake_conn_test.go
+++ b/testutil/fake_conn_test.go
@@ -1,21 +1,14 @@
 package testutil
 
 import (
-	. "gopkg.in/check.v1"
 	"testing"
-)
-
-func TestTestUtil(t *testing.T) {
-	TestingT(t)
-}
 
-type FakeConnSuite struct{}
-
-var _ = Suite(&FakeConnSuite{})
+	"github.com/stretchr/testify/require"
+)
 
-func (s *FakeConnSuite) TestFakeConn(c *C) {
+func TestFakeConn(t *testing.T) {
 	//c.Skip("temporary")
-	fc1, fc2 := NewFakeConn(c)
+	fc1, fc2 := NewFakeConn(t)
 
 	one := []byte{1, 2, 3, 4}
 	two := []byte{5, 6, 7, 8, 9, 10, 11, 12, 13}
@@ -29,33 +22,33 @@ func (s *FakeConnSuite) TestFakeConn(c *C) {
 
 		rx1 := make([]byte, 6)
 		n, err := fc2.Read(rx1)
-		c.Assert(n, Equals, 4)
-		c.Assert(err, IsNil)
-		c.Assert(rx1[0:n], DeepEquals, one)
+		require.Equal(t, 4, n)
+		require.NoError(t, err)
+		require.Equal(t, one, rx1[0:n])
 
 		rx2 := make([]byte, 5)
 		n, err = fc2.Read(rx2)
-		c.Assert(n, Equals, 5)
-		c.Assert(err, IsNil)
-		c.Assert(rx2, DeepEquals, []byte{5, 6, 7, 8, 9})
+		require.Equal(t, 5, n)
+		require.NoError(t, err)
+		require.Equal(t, []byte{5, 6, 7, 8, 9}, rx2)
 
 		rx3 := make([]byte, 10)
 		n, err = fc2.Read(rx3)
-		c.Assert(n, Equals, 4)
-		c.Assert(err, IsNil)
-		c.Assert(rx3[0:n], DeepEquals, []byte{10, 11, 12, 13})
+		require.Equal(t, 4, n)
+		require.NoError(t, err)
+		require.Equal(t, []byte{10, 11, 12, 13}, rx3[0:n])
 	}()
 
-	c.Assert(fc1.C, Equals, c)
-	c.Assert(fc2.C, Equals, c)
+	require.Equal(t, t, fc1.T)
+	require.Equal(t, t, fc2.T)
 
 	n, err := fc1.Write(one)
-	c.Assert(n, Equals, 4)
-	c.Assert(err, IsNil)
+	require.Equal(t, 4, n)
+	require.NoError(t, err)
 
 	n, err = fc1.Write(two)
-	c.Assert(n, Equals, len(two))
-	c.Assert(err, IsNil)
+	require.Len(t, two, n)
+	require.NoError(t, err)
 
 	<-stop
 }
diff --git a/transaction.go b/transaction.go
index 0a8398f..bafab0d 100644
--- a/transaction.go
+++ b/transaction.go
@@ -52,7 +52,7 @@ func (tx *Transaction) abort(receipt bool) error {
 	f := frame.New(frame.ABORT, frame.Transaction, tx.id)
 
 	if receipt {
-		id := allocateId()
+		id := tx.conn.AllocateID()
 		f.Header.Set(frame.Receipt, id)
 	}
 
@@ -87,7 +87,7 @@ func (tx *Transaction) commit(receipt bool) error {
 	f := frame.New(frame.COMMIT, frame.Transaction, tx.id)
 
 	if receipt {
-		id := allocateId()
+		id := tx.conn.AllocateID()
 		f.Header.Set(frame.Receipt, id)
 	}
 
@@ -115,7 +115,7 @@ func (tx *Transaction) Send(destination, contentType string, body []byte, opts .
 		return ErrCompletedTransaction
 	}
 
-	f, err := createSendFrame(destination, contentType, body, opts)
+	f, err := createSendFrame(tx.conn, destination, contentType, body, opts)
 	if err != nil {
 		return err
 	}