diff --git a/examples/client/client.go b/examples/client/client.go
index 41cef9a..9ff867c 100644
--- a/examples/client/client.go
+++ b/examples/client/client.go
@@ -14,7 +14,7 @@ func main() {
 
 	config := &opcua.ClientConfig{
 		Address: netx.Address{
-			Host: "127.0.0.1",
+			Host: "localhost",
 			Port: 4840,
 		},
 		Logger: logger,
diff --git a/examples/server/server.go b/examples/server/server.go
index ed9dabd..4f4e22d 100644
--- a/examples/server/server.go
+++ b/examples/server/server.go
@@ -13,14 +13,18 @@ func main() {
 	logger := slog.Default()
 
 	config := &opcua.ServerConfig{
-		Host:               "127.0.0.1",
+		Host:               "localhost",
 		Port:               4840,
 		ReceiverBufferSize: 1024,
 		ReadTimeout:        5 * time.Second,
 		Logger:             logger,
 	}
 
-	server := opcua.NewServer(config)
+	server, err := opcua.NewServer(config)
+	if err != nil {
+		logger.Error("Failed to create server", slog.String("error", err.Error()))
+		os.Exit(1)
+	}
 
 	port, err := server.Run()
 	if err != nil {
diff --git a/opcua/client.go b/opcua/client.go
index 984b4ec..90b5d43 100644
--- a/opcua/client.go
+++ b/opcua/client.go
@@ -65,6 +65,10 @@ func (c *Client) Send(buf *buffer.Buffer) (*buffer.Buffer, error) {
 	if err != nil {
 		return nil, err
 	}
+	err = result.Skip(8)
+	if err != nil {
+		return nil, err
+	}
 	return result, nil
 }
 
diff --git a/opcua/client_test.go b/opcua/client_test.go
deleted file mode 100644
index 1a072be..0000000
--- a/opcua/client_test.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package opcua
-
-import (
-	"github.com/shoothzj/gox/netx"
-	"github.com/stretchr/testify/require"
-	"log/slog"
-	"testing"
-)
-
-func TestClientConnect(t *testing.T) {
-	logger := slog.Default()
-
-	serverConfig := &ServerConfig{
-		Host:   "localhost",
-		Port:   0,
-		Logger: logger,
-	}
-	server := NewServer(serverConfig)
-
-	port, err := server.Run()
-	require.NoError(t, err)
-	defer server.Close()
-
-	clientConfig := &ClientConfig{
-		Address: netx.Address{
-			Host: "127.0.0.1",
-			Port: port,
-		},
-		Logger: logger,
-	}
-	client, err := NewClient(clientConfig)
-	require.NoError(t, err)
-
-	client.close()
-}
diff --git a/opcua/server.go b/opcua/server.go
index bd0edfe..da7873d 100644
--- a/opcua/server.go
+++ b/opcua/server.go
@@ -35,14 +35,20 @@ type Server struct {
 	quit  chan bool
 }
 
-func NewServer(config *ServerConfig) *Server {
+func NewServer(config *ServerConfig) (*Server, error) {
+	if config.ReceiverBufferSize == 0 {
+		config.ReceiverBufferSize = 1024
+	}
+	if config.ReceiverBufferSize < 9 {
+		return nil, fmt.Errorf("receiver buffer size must be at least 9 bytes")
+	}
 	server := &Server{
 		config: config,
 		quit:   make(chan bool),
 		logger: config.Logger,
 	}
 	server.logger.Info("server initialized", slog.String("host", config.Host), slog.Int("port", config.Port))
-	return server
+	return server, nil
 }
 
 func (s *Server) Run() (int, error) {
@@ -181,7 +187,7 @@ func (s *Server) react(conn *opcuaConn, bytes []byte) ([]byte, error) {
 	var err error
 	switch messageType {
 	case "HEL":
-		buf, err = s.handleHello(bytes[4:])
+		buf, err = s.handleHello(bytes[8:])
 	default:
 		return nil, fmt.Errorf("unknown message type: %s", messageType)
 	}
diff --git a/opcua/server_test.go b/opcua/server_test.go
index e3e671a..3815e84 100644
--- a/opcua/server_test.go
+++ b/opcua/server_test.go
@@ -1,12 +1,47 @@
 package opcua
 
 import (
+	"github.com/shoothzj/gox/netx"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"log/slog"
 	"testing"
 )
 
+type testSimpleClientServer struct {
+	client *Client
+	server *Server
+}
+
+func newTestSimpleClientServer(t *testing.T, serverConfig *ServerConfig, clientConfig *ClientConfig) *testSimpleClientServer {
+	server, err := NewServer(serverConfig)
+	require.NoError(t, err, "Server creation should not fail")
+
+	port, err := server.Run()
+	require.NoError(t, err, "Server should start without error")
+
+	clientConfig.Address = netx.Address{
+		Host: serverConfig.Host,
+		Port: port,
+	}
+	client, err := NewClient(clientConfig)
+	require.NoError(t, err, "Client creation should not fail")
+
+	return &testSimpleClientServer{
+		client: client,
+		server: server,
+	}
+}
+
+func (s *testSimpleClientServer) close() {
+	if s.client != nil {
+		s.client.close()
+	}
+	if s.server != nil {
+		_ = s.server.Close()
+	}
+}
+
 func TestStartWithZeroPort(t *testing.T) {
 	config := &ServerConfig{
 		Host:   "localhost",
@@ -14,7 +49,8 @@ func TestStartWithZeroPort(t *testing.T) {
 		Logger: slog.Default(),
 	}
 
-	server := NewServer(config)
+	server, err := NewServer(config)
+	require.NoError(t, err)
 
 	port, err := server.Run()
 	require.NoError(t, err, "Server should start without error")
@@ -24,3 +60,54 @@ func TestStartWithZeroPort(t *testing.T) {
 	err = server.Close()
 	assert.NoError(t, err, "Server should close without error")
 }
+
+func TestClientConnect(t *testing.T) {
+	logger := slog.Default()
+
+	serverConfig := &ServerConfig{
+		Host:   "localhost",
+		Port:   0,
+		Logger: logger,
+	}
+
+	clientConfig := &ClientConfig{
+		Logger: logger,
+	}
+
+	simpleClientServer := newTestSimpleClientServer(t, serverConfig, clientConfig)
+	defer simpleClientServer.close()
+}
+
+func TestMessageHello(t *testing.T) {
+	logger := slog.Default()
+
+	serverConfig := &ServerConfig{
+		Host:               "localhost",
+		Port:               0,
+		ReceiverBufferSize: 1024,
+		Logger:             logger,
+	}
+
+	clientConfig := &ClientConfig{
+		Logger: logger,
+	}
+
+	simpleClientServer := newTestSimpleClientServer(t, serverConfig, clientConfig)
+	defer simpleClientServer.close()
+
+	messageAcknowledge, err := simpleClientServer.client.Hello(&MessageHello{
+		Version:           0,
+		ReceiveBufferSize: 65535,
+		SendBufferSize:    65535,
+		MaxMessageSize:    2097152,
+		MaxChunkCount:     0,
+		EndpointUrl:       "opc.tcp://localhost:4840/opcua",
+	})
+	require.NoError(t, err)
+
+	assert.Equal(t, uint32(0), messageAcknowledge.Version)
+	assert.Equal(t, uint32(65535), messageAcknowledge.ReceiveBufferSize)
+	assert.Equal(t, uint32(65535), messageAcknowledge.SendBufferSize)
+	assert.Equal(t, uint32(2097152), messageAcknowledge.MaxMessageSize)
+	assert.Equal(t, uint32(64), messageAcknowledge.MaxChunkCount)
+}