Test with the smpp center

Oopsie!

.gitea/workflows/benchmark.yaml

@@ -2,8 +2,7 @@ name: Benchmark BufferPool
 on:
   push:
     branches:
-      - '*'
-      - '!benchmark'
+      - 'master'
 
 jobs:
   RunBenchmarks:

benchmark/benchmark.go

@@ -38,7 +38,7 @@ func main() {
 		log.Fatalf("Error creating result file %s with %v", resultFile, err)
 	}
 
-	cmd := exec.Command("go", "test", "-bench", ".", "./pdu")
+	cmd := exec.Command("go", "test", "-bench", ".", "./...")
 	cmd.Dir = "../"
 	cmd.Stdout = outFile
 

encoding/ascii.go

@@ -4,11 +4,19 @@ import "bytes"
 
 type ASCIICoder struct{}
 
-func (c *ASCIICoder) Encode(s string, buf *bytes.Buffer) error {
-	buf.WriteString(s)
+func (c *ASCIICoder) Encode(s *string, buf *bytes.Buffer) error {
+	// These should be ASCII but UTF8 is a superset of ASCII so hopefully this'll be fine
+	buf.WriteString(*s)
 	return nil
 }
 
 func (c *ASCIICoder) Decode(buf *bytes.Buffer) (string, error) {
 	return buf.String(), nil
 }
+
+func (c ASCIICoder) EncodesInto(s *string) int {
+	return len(*s)
+}
+func (c ASCIICoder) DecodesInto(buf *bytes.Buffer) int {
+	return buf.Len()
+}

encoding/ascii_test.go

@@ -11,7 +11,7 @@ func TestASCIIEncodeSimpleASCIIString(t *testing.T) {
 	input := "Hello, World!"
 
 	expected := []byte{72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33}
-	err := coder.Encode(input, &buf)
+	err := coder.Encode(&input, &buf)
 
 	if err != nil {
 		t.Errorf("Expected no error, but got %v", err)
@@ -46,7 +46,7 @@ func TestASCIIEncodeEmptyString(t *testing.T) {
 	input := ""
 
 	expected := []byte{}
-	err := coder.Encode(input, &buf)
+	err := coder.Encode(&input, &buf)
 
 	if err != nil {
 		t.Errorf("Expected no error, but got %v", err)

encoding/coder.go

@@ -3,6 +3,8 @@ package encoding
 import "bytes"
 
 type Coder interface {
-	Encode(s string, buf *bytes.Buffer) error
+	Encode(s *string, buf *bytes.Buffer) error
 	Decode(buf *bytes.Buffer) (string, error)
+	EncodesInto(s *string) int
+	DecodesInto(buf *bytes.Buffer) int
 }

encoding/gsm7.go

@@ -11,15 +11,15 @@ type GSM7Coder struct{}
 // Otherwise Encode will allocate memory as it sees fit
 // Which is fine but not optimal
 // Preallocate the buffer with the size of EncodesInto bytes
-func (c *GSM7Coder) Encode(s string, buf *bytes.Buffer) error {
+func (c *GSM7Coder) Encode(s *string, buf *bytes.Buffer) error {
 	// utf8 := *(*[]byte)(unsafe.Pointer(&s))
-	utf8 := []byte(s)
+	utf8 := []byte(*s)
 	var (
 		offset      int  = 1
 		bitshift    byte = 0
 		leap, shift bool
 	)
-	encodedSize := GSM7EncodesInto(&s)
+	encodedSize := c.EncodesInto(s)
 	cap := buf.Cap()
 	if cap < encodedSize {
 		buf.Grow(encodedSize - cap)
@@ -77,7 +77,7 @@ func (c *GSM7Coder) Decode(buf *bytes.Buffer) (string, error) {
 		bitshift byte = 0
 		leap     bool
 	)
-	outLength := GSM7DecodesInto(buf)
+	outLength := c.DecodesInto(buf)
 	lengthDiff := outLength - len(gsm7)
 	gsm7 = append(gsm7, make([]byte, lengthDiff)...)
 	start := len(gsm7) - 2
@@ -121,7 +121,7 @@ func InsertAt(data *[]byte, index int, value byte) {
 	(*data)[index] = value
 }
 
-func GSM7EncodesInto(s *string) int {
+func (c GSM7Coder) EncodesInto(s *string) int {
 	slen := len(*s)
 	enclen := slen * 7 / 8
 	if slen%8 != 0 {
@@ -129,7 +129,7 @@ func GSM7EncodesInto(s *string) int {
 	}
 	return enclen
 }
-func GSM7DecodesInto(buf *bytes.Buffer) int {
+func (c GSM7Coder) DecodesInto(buf *bytes.Buffer) int {
 	blen := buf.Len()
 	declen := blen * 8 / 7
 	return declen

encoding/gsm7_test.go

@@ -22,7 +22,7 @@ func TestGSM7EncodeSimpleASCIIString(t *testing.T) {
 	input := short8nString
 
 	expected := short8nStringEncodedBytes
-	err := coder.Encode(input, &buf)
+	err := coder.Encode(&input, &buf)
 
 	if err != nil {
 		t.Errorf("Expected no error, but got %v", err)
@@ -39,7 +39,7 @@ func TestGSM7EncodeComplexASCIIString(t *testing.T) {
 	input := longNot8nString
 
 	expected := longNot8nStringEncodedBytes
-	err := coder.Encode(input, &buf)
+	err := coder.Encode(&input, &buf)
 
 	if err != nil {
 		t.Errorf("Expected no error, but got %v", err)
@@ -56,7 +56,7 @@ func TestGSM7EncodeComplex8nASCIIString(t *testing.T) {
 	input := "Ducks are fucking great, they quacks, O quackers, what the fuck."
 
 	expected := long8nStringEncodedBytes
-	err := coder.Encode(input, &buf)
+	err := coder.Encode(&input, &buf)
 
 	if err != nil {
 		t.Errorf("Expected no error, but got %v", err)
@@ -70,11 +70,11 @@ func TestGSM7EncodeComplex8nASCIIString(t *testing.T) {
 func TestGSM7EncodeDoesNotAllocateMoreThanNecessary(t *testing.T) {
 	coder := &GSM7Coder{}
 	input := "Ducks are fucking great, they quacks, O quackers, what the fuck."
-	buf := bytes.NewBuffer(make([]byte, GSM7EncodesInto(&input)))
+	buf := bytes.NewBuffer(make([]byte, coder.EncodesInto(&input)))
 	buf.Reset()
 
 	expected := buf.Cap()
-	err := coder.Encode(input, buf)
+	err := coder.Encode(&input, buf)
 	actual := buf.Cap()
 
 	if err != nil {
@@ -93,7 +93,7 @@ func TestGSM7EncodeDoesAllocateWhenNecessary(t *testing.T) {
 	buf.Reset()
 
 	original := buf.Cap()
-	err := coder.Encode(input, &buf)
+	err := coder.Encode(&input, &buf)
 	modified := buf.Cap()
 
 	if err != nil {
@@ -111,7 +111,7 @@ func TestGSM7EncodeEmptyString(t *testing.T) {
 	input := ""
 
 	expected := []byte{}
-	err := coder.Encode(input, &buf)
+	err := coder.Encode(&input, &buf)
 
 	if err != nil {
 		t.Errorf("Expected no error, but got %v", err)
@@ -271,7 +271,7 @@ func TestDeletesLastValue(t *testing.T) {
 func TestGSM7EncodesIntoSmallString(t *testing.T) {
 	input := short8nString
 	expected := 7
-	actual := GSM7EncodesInto(&input)
+	actual := GSM7Coder{}.EncodesInto(&input)
 	if actual != expected {
 		t.Errorf("Expected %d, but got %d", expected, actual)
 	}
@@ -280,7 +280,7 @@ func TestGSM7EncodesIntoSmallString(t *testing.T) {
 func TestGSM7EncodesIntoLargerNot8nString(t *testing.T) {
 	input := longNot8nString
 	expected := 33
-	actual := GSM7EncodesInto(&input)
+	actual := GSM7Coder{}.EncodesInto(&input)
 	if actual != expected {
 		t.Errorf("Expected %d, but got %d", expected, actual)
 	}
@@ -289,7 +289,7 @@ func TestGSM7EncodesIntoLargerNot8nString(t *testing.T) {
 func TestGSM7EncodesIntoLarger8nString(t *testing.T) {
 	input := long8nString
 	expected := 56
-	actual := GSM7EncodesInto(&input)
+	actual := GSM7Coder{}.EncodesInto(&input)
 	if actual != expected {
 		t.Errorf("Expected %d, but got %d", expected, actual)
 	}
@@ -298,7 +298,7 @@ func TestGSM7EncodesIntoLarger8nString(t *testing.T) {
 func TestGSM7DecodesIntoSmallString(t *testing.T) {
 	input := short8nStringEncodedBytes
 	expected := 8
-	actual := GSM7DecodesInto(bytes.NewBuffer(input))
+	actual := GSM7Coder{}.DecodesInto(bytes.NewBuffer(input))
 	if actual != expected {
 		t.Errorf("Expected %d, but got %d", expected, actual)
 	}
@@ -307,7 +307,7 @@ func TestGSM7DecodesIntoSmallString(t *testing.T) {
 func TestGSM7DecodesIntoLargerNot8nString(t *testing.T) {
 	input := longNot8nStringEncodedBytes
 	expected := 37
-	actual := GSM7DecodesInto(bytes.NewBuffer(input))
+	actual := GSM7Coder{}.DecodesInto(bytes.NewBuffer(input))
 	if actual != expected {
 		t.Errorf("Expected %d, but got %d", expected, actual)
 	}
@@ -316,7 +316,7 @@ func TestGSM7DecodesIntoLargerNot8nString(t *testing.T) {
 func TestGSM7DecodesIntoLarger8nString(t *testing.T) {
 	input := long8nStringEncodedBytes
 	expected := 64
-	actual := GSM7DecodesInto(bytes.NewBuffer(input))
+	actual := GSM7Coder{}.DecodesInto(bytes.NewBuffer(input))
 	if actual != expected {
 		t.Errorf("Expected %d, but got %d", expected, actual)
 	}
@@ -330,7 +330,7 @@ func BenchmarkGSM7EncodeSimpleASCIIString(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		coder.Encode(input, &buf)
+		coder.Encode(&input, &buf)
 	}
 }
 
@@ -341,7 +341,7 @@ func BenchmarkGSM7EncodeComplexASCIIString(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		coder.Encode(input, &buf)
+		coder.Encode(&input, &buf)
 	}
 }
 
@@ -352,7 +352,7 @@ func BenchmarkGSM7EncodeComplex8nASCIIString(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		coder.Encode(input, &buf)
+		coder.Encode(&input, &buf)
 	}
 }
 
@@ -362,8 +362,8 @@ func BenchmarkGSM7EncodeComplex8nASCIIStringPrealloc(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		buf := bytes.NewBuffer(make([]byte, GSM7EncodesInto(&input)))
+		buf := bytes.NewBuffer(make([]byte, coder.EncodesInto(&input)))
 		buf.Reset()
-		coder.Encode(input, buf)
+		coder.Encode(&input, buf)
 	}
 }

encoding/ucs2.go

@@ -4,10 +4,16 @@ import "bytes"
 
 type UCS2Coder struct{}
 
-func (c *UCS2Coder) Encode(s string, buf *bytes.Buffer) {
+func (c *UCS2Coder) Encode(s *string, buf *bytes.Buffer) error {
+	panic("UCS2 not implemented yet")
+}
+func (c *UCS2Coder) Decode(buf *bytes.Buffer) (string, error) {
 	panic("UCS2 not implemented yet")
 }
 
-func (c *UCS2Coder) Decode(buf *bytes.Buffer) string {
-	panic("UCS2 not implemented yet")
+func (c UCS2Coder) EncodesInto(s *string) int {
+	return len(*s) * 2
+}
+func (c UCS2Coder) DecodesInto(buf *bytes.Buffer) int {
+	return buf.Len() / 2
 }

go.mod

@@ -2,7 +2,4 @@ module smpptester
 
 go 1.22.4
 
-require (
-	github.com/warthog618/sms v0.3.0
-	github.com/yuin/gopher-lua v1.1.1
-)
+require github.com/yuin/gopher-lua v1.1.1

go.sum

@@ -1,16 +1,2 @@
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
-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/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/warthog618/sms v0.3.0 h1:LYAb5ngmu2qjNExgji3B7xi2tIZ9+DsuE9pC5xs4wwc=
-github.com/warthog618/sms v0.3.0/go.mod h1:+bYZGeBxu003sxD5xhzsrIPBAjPBzTABsRTwSpd7ld4=
 github.com/yuin/gopher-lua v1.1.1 h1:kYKnWBjvbNP4XLT3+bPEwAXJx262OhaHDWDVOPjL46M=
 github.com/yuin/gopher-lua v1.1.1/go.mod h1:GBR0iDaNXjAgGg9zfCvksxSRnQx76gclCIb7kdAd1Pw=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

main.go

@@ -6,10 +6,12 @@ import (
 	"log"
 	"net"
 	"sync"
+
+	"smpptester/pdu"
 )
 
 func init() {
-	log.SetFlags(log.Lmicroseconds)
+	log.SetFlags(log.Lmicroseconds | log.Lshortfile)
 }
 
 // Function to create a submit_sm PDU
@@ -29,7 +31,7 @@ func createSubmitSMPDU() []byte {
 	validityPeriod := ""
 	registeredDelivery := byte(0x01)
 	replaceIfPresentFlag := byte(0x00)
-	dataCoding := byte(0x00)
+	dataCoding := byte(0x01)
 	smDefaultMsgID := byte(0x00)
 	shortMessage := "Hello, SMPP!"
 
@@ -37,7 +39,6 @@ func createSubmitSMPDU() []byte {
 	headerLength := 16
 	bodyLength := 1 + len(serviceType) + 1 + 1 + len(sourceAddr) + 1 + 1 + len(destinationAddr) + 1 + 1 + len(scheduleDeliveryTime) + 1 + len(validityPeriod) + 1 + 1 + 1 + 1 + 1 + len(shortMessage)
 	totalLength := headerLength + bodyLength
-	log.Printf("Total length: %d", totalLength)
 
 	// Create a buffer to hold the PDU
 	var buffer bytes.Buffer
@@ -136,7 +137,55 @@ func main() {
 	// 		go handleConnection(conn)
 	// 	}
 	// }()
+	submit := &pdu.SUBMIT_SM{
+		Header: &pdu.PDU_HEADER{
+			Command_length:  0,
+			Command_id:      4,
+			Command_status:  0,
+			Sequence_number: 1,
+		},
+		Service_type:           "hehe",
+		Source_addr_ton:        0x01,
+		Source_addr_npi:        0x01,
+		Source_addr:            "12345",
+		Dest_addr_ton:          0x01,
+		Dest_addr_npi:          0x01,
+		Destination_addr:       "67890",
+		Esm_class:              0x00,
+		Protocol_id:            0x00,
+		Priority_flag:          0x00,
+		Schedule_delivery_time: "",
+		Validity_period:        "",
+		Registered_delivery:    0x01,
+		Replace_if_present:     0x00,
+		Data_coding:            0x01,
+		Sm_default_msg_id:      0x00,
+		Short_message:          "Hello, SMPP!",
+	}
+	submit.UpdateSize()
+	buf := pdu.ByteBufferPool.Get(submit.Size())
+	defer pdu.ByteBufferPool.Put(buf)
+	submit.Encode(buf)
+	log.Println(buf.Bytes())
 	log.Println(createSubmitSMPDU())
+	// log.Println(pdu.Encode())
+	// serviceType := "CMT"
+	// sourceAddrTON := byte(0x01)
+	// sourceAddrNPI := byte(0x01)
+	// sourceAddr := "12345"
+	// destAddrTON := byte(0x01)
+	// destAddrNPI := byte(0x01)
+	// destinationAddr := "67890"
+	// esmClass := byte(0x00)
+	// protocolID := byte(0x00)
+	// priorityFlag := byte(0x00)
+	// scheduleDeliveryTime := ""
+	// validityPeriod := ""
+	// registeredDelivery := byte(0x01)
+	// replaceIfPresentFlag := byte(0x00)
+	// dataCoding := byte(0x01)
+	// smDefaultMsgID := byte(0x00)
+	// shortMessage := "Hello, SMPP!"
 
 	wg := &sync.WaitGroup{}
 	wg.Add(1)
@@ -150,7 +199,7 @@ func main() {
 	defer conn.Close()
 
 	go func() {
-		conn.Write(createSubmitSMPDU())
+		conn.Write(buf.Bytes())
 		data, err := conn.Read(make([]byte, 1024))
 		if err != nil {
 			log.Printf("Failed to read from connection: %+v", err)

pdu/bind.go

@@ -2,19 +2,19 @@ package pdu
 
 type (
 	BIND struct {
-		header            *PDU_HEADER
-		system_id         string
-		password          string
-		system_type       string
-		interface_version byte
-		addr_ton          byte
-		addr_npi          byte
-		address_range     string
+		Header            *PDU_HEADER
+		System_id         string
+		Password          string
+		System_type       string
+		Interface_version byte
+		Addr_ton          byte
+		Addr_npi          byte
+		Address_range     string
 	}
 	BIND_RESP struct {
-		header               *PDU_HEADER
-		system_id            string
-		sc_interface_version byte
+		Header               *PDU_HEADER
+		System_id            string
+		Sc_interface_version byte
 	}
 	BIND_RECVEIVER struct {
 		BIND
@@ -36,9 +36,9 @@ type (
 	}
 
 	UNBIND struct {
-		header *PDU_HEADER
+		Header *PDU_HEADER
 	}
 	UNBIND_RESP struct {
-		header *PDU_HEADER
+		Header *PDU_HEADER
 	}
 )

pdu/cancel.go

@@ -2,17 +2,17 @@ package pdu
 
 type (
 	CANCEL_SM struct {
-		header           *PDU_HEADER
-		service_type     string
-		message_id       string
-		source_addr_ton  byte
-		source_addr_npi  byte
-		source_addr      string
-		dest_addr_ton    byte
-		dest_addr_npi    byte
-		destination_addr string
+		Header           *PDU_HEADER
+		Service_type     string
+		Message_id       string
+		Source_addr_ton  byte
+		Source_addr_npi  byte
+		Source_addr      string
+		Dest_addr_ton    byte
+		Dest_addr_npi    byte
+		Destination_addr string
 	}
 	CANCEL_SM_RESP struct {
-		header *PDU_HEADER
+		Header *PDU_HEADER
 	}
 )

pdu/deliver.go

@@ -2,11 +2,11 @@ package pdu
 
 type (
 	DELIVER_SM struct {
-		header *PDU_HEADER
+		Header *PDU_HEADER
 		SUBMIT_SM
 	}
 	DELIVER_SM_RESP struct {
-		header *PDU_HEADER
+		Header *PDU_HEADER
 		SUBMIT_SM_RESP
 	}
 )

pdu/enquire.go

@@ -2,9 +2,9 @@ package pdu
 
 type (
 	ENQUIRE_LINK struct {
-		header *PDU_HEADER
+		Header *PDU_HEADER
 	}
 	ENQUIRE_LINK_RESP struct {
-		header *PDU_HEADER
+		Header *PDU_HEADER
 	}
 )

pdu/pdu.go

@@ -16,14 +16,14 @@ type (
 	}
 
 	PDU_HEADER struct {
-		command_length  uint32
-		command_id      uint32
-		command_status  uint32
-		sequence_number uint32
+		Command_length  uint32
+		Command_id      uint32
+		Command_status  uint32
+		Sequence_number uint32
 	}
 
 	GENERIC_NACK struct {
-		header *PDU_HEADER
+		Header *PDU_HEADER
 	}
 )
 
@@ -62,25 +62,25 @@ func (p *PDU_HEADER) Encode(buf *bytes.Buffer) error {
 	if buf == nil {
 		return fmt.Errorf("cannot encode into nil buffer")
 	}
-	binary.Write(buf, binary.BigEndian, p.command_length)
-	binary.Write(buf, binary.BigEndian, p.command_id)
-	binary.Write(buf, binary.BigEndian, p.command_status)
-	binary.Write(buf, binary.BigEndian, p.sequence_number)
+	binary.Write(buf, binary.BigEndian, p.Command_length)
+	binary.Write(buf, binary.BigEndian, p.Command_id)
+	binary.Write(buf, binary.BigEndian, p.Command_status)
+	binary.Write(buf, binary.BigEndian, p.Sequence_number)
 	return nil
 }
 func (p *PDU_HEADER) Decode(buf *bytes.Buffer) error {
 	if buf == nil {
 		return fmt.Errorf("cannot decode nil buffer")
 	}
-	binary.Read(buf, binary.BigEndian, &p.command_length)
-	binary.Read(buf, binary.BigEndian, &p.command_id)
-	binary.Read(buf, binary.BigEndian, &p.command_status)
-	binary.Read(buf, binary.BigEndian, &p.sequence_number)
+	binary.Read(buf, binary.BigEndian, &p.Command_length)
+	binary.Read(buf, binary.BigEndian, &p.Command_id)
+	binary.Read(buf, binary.BigEndian, &p.Command_status)
+	binary.Read(buf, binary.BigEndian, &p.Sequence_number)
 	return nil
 }
 func (p *PDU_HEADER) Size() int {
 	return 16
 }
 func (p *PDU_HEADER) UpdateSize() {
-	p.command_length = uint32(p.Size())
+	p.Command_length = uint32(p.Size())
 }

pdu/pdu_test.go

@@ -11,10 +11,10 @@ import (
 // region encode
 func TestEncodeReturnsByteSliceOfLength16(t *testing.T) {
 	p := &PDU_HEADER{
-		command_length:  1,
-		command_id:      1,
-		command_status:  1,
-		sequence_number: 1,
+		Command_length:  1,
+		Command_id:      1,
+		Command_status:  1,
+		Sequence_number: 1,
 	}
 	buf := bytes.NewBuffer(make([]byte, 16))
 	buf.Reset()
@@ -30,10 +30,10 @@ func TestEncodeReturnsByteSliceOfLength16(t *testing.T) {
 
 func TestEncodeHandlesZeroValues(t *testing.T) {
 	p := &PDU_HEADER{
-		command_length:  0,
-		command_id:      0,
-		command_status:  0,
-		sequence_number: 0,
+		Command_length:  0,
+		Command_id:      0,
+		Command_status:  0,
+		Sequence_number: 0,
 	}
 	buf := bytes.NewBuffer(make([]byte, 16))
 	buf.Reset()
@@ -53,10 +53,10 @@ func TestEncodeHandlesZeroValues(t *testing.T) {
 
 func TestEncodeEncodesProperly(t *testing.T) {
 	p := &PDU_HEADER{
-		command_length:  1,
-		command_id:      2,
-		command_status:  3,
-		sequence_number: 4,
+		Command_length:  1,
+		Command_id:      2,
+		Command_status:  3,
+		Sequence_number: 4,
 	}
 	buf := bytes.NewBuffer(make([]byte, 16))
 	buf.Reset()
@@ -77,10 +77,10 @@ func TestEncodeEncodesProperly(t *testing.T) {
 
 func TestEncodeEncodesProperlyComplex(t *testing.T) {
 	p := &PDU_HEADER{
-		command_length:  13426724,
-		command_id:      254352,
-		command_status:  35634264,
-		sequence_number: 476543523,
+		Command_length:  13426724,
+		Command_id:      254352,
+		Command_status:  35634264,
+		Sequence_number: 476543523,
 	}
 	buf := bytes.NewBuffer(make([]byte, 16))
 	buf.Reset()
@@ -101,10 +101,10 @@ func TestEncodeEncodesProperlyComplex(t *testing.T) {
 
 func TestEncodeIntoCorrectlyEncodesFields(t *testing.T) {
 	p := &PDU_HEADER{
-		command_length:  16,
-		command_id:      1,
-		command_status:  0,
-		sequence_number: 12345,
+		Command_length:  16,
+		Command_id:      1,
+		Command_status:  0,
+		Sequence_number: 12345,
 	}
 	buf := bytes.NewBuffer(make([]byte, 16))
 	buf.Reset()
@@ -115,26 +115,26 @@ func TestEncodeIntoCorrectlyEncodesFields(t *testing.T) {
 	}
 
 	innerbuf := buf.Bytes()
-	if binary.BigEndian.Uint32(innerbuf[0:4]) != p.command_length {
-		t.Errorf("Expected command_length %d, got %d", p.command_length, binary.BigEndian.Uint32(innerbuf[0:4]))
+	if binary.BigEndian.Uint32(innerbuf[0:4]) != p.Command_length {
+		t.Errorf("Expected command_length %d, got %d", p.Command_length, binary.BigEndian.Uint32(innerbuf[0:4]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[4:8]) != p.command_id {
-		t.Errorf("Expected command_id %d, got %d", p.command_id, binary.BigEndian.Uint32(innerbuf[4:8]))
+	if binary.BigEndian.Uint32(innerbuf[4:8]) != p.Command_id {
+		t.Errorf("Expected command_id %d, got %d", p.Command_id, binary.BigEndian.Uint32(innerbuf[4:8]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[8:12]) != p.command_status {
-		t.Errorf("Expected command_status %d, got %d", p.command_status, binary.BigEndian.Uint32(innerbuf[8:12]))
+	if binary.BigEndian.Uint32(innerbuf[8:12]) != p.Command_status {
+		t.Errorf("Expected command_status %d, got %d", p.Command_status, binary.BigEndian.Uint32(innerbuf[8:12]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[12:16]) != p.sequence_number {
-		t.Errorf("Expected sequence_number %d, got %d", p.sequence_number, binary.BigEndian.Uint32(innerbuf[12:16]))
+	if binary.BigEndian.Uint32(innerbuf[12:16]) != p.Sequence_number {
+		t.Errorf("Expected sequence_number %d, got %d", p.Sequence_number, binary.BigEndian.Uint32(innerbuf[12:16]))
 	}
 }
 
 func TestEncodeIntoHandlesLargerBuffer(t *testing.T) {
 	p := &PDU_HEADER{
-		command_length:  16,
-		command_id:      1,
-		command_status:  0,
-		sequence_number: 12345,
+		Command_length:  16,
+		Command_id:      1,
+		Command_status:  0,
+		Sequence_number: 12345,
 	}
 	buf := bytes.NewBuffer(make([]byte, 20)) // larger buffer size
 	buf.Reset()
@@ -145,26 +145,26 @@ func TestEncodeIntoHandlesLargerBuffer(t *testing.T) {
 	}
 
 	innerbuf := buf.Bytes()
-	if binary.BigEndian.Uint32(innerbuf[0:4]) != p.command_length {
-		t.Errorf("Expected command_length %d, got %d", p.command_length, binary.BigEndian.Uint32(innerbuf[0:4]))
+	if binary.BigEndian.Uint32(innerbuf[0:4]) != p.Command_length {
+		t.Errorf("Expected command_length %d, got %d", p.Command_length, binary.BigEndian.Uint32(innerbuf[0:4]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[4:8]) != p.command_id {
-		t.Errorf("Expected command_id %d, got %d", p.command_id, binary.BigEndian.Uint32(innerbuf[4:8]))
+	if binary.BigEndian.Uint32(innerbuf[4:8]) != p.Command_id {
+		t.Errorf("Expected command_id %d, got %d", p.Command_id, binary.BigEndian.Uint32(innerbuf[4:8]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[8:12]) != p.command_status {
-		t.Errorf("Expected command_status %d, got %d", p.command_status, binary.BigEndian.Uint32(innerbuf[8:12]))
+	if binary.BigEndian.Uint32(innerbuf[8:12]) != p.Command_status {
+		t.Errorf("Expected command_status %d, got %d", p.Command_status, binary.BigEndian.Uint32(innerbuf[8:12]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[12:16]) != p.sequence_number {
-		t.Errorf("Expected sequence_number %d, got %d", p.sequence_number, binary.BigEndian.Uint32(innerbuf[12:16]))
+	if binary.BigEndian.Uint32(innerbuf[12:16]) != p.Sequence_number {
+		t.Errorf("Expected sequence_number %d, got %d", p.Sequence_number, binary.BigEndian.Uint32(innerbuf[12:16]))
 	}
 }
 
 func TestEncodeIntoUsesBigEndianEncoding(t *testing.T) {
 	p := &PDU_HEADER{
-		command_length:  16,
-		command_id:      1,
-		command_status:  0,
-		sequence_number: 12345,
+		Command_length:  16,
+		Command_id:      1,
+		Command_status:  0,
+		Sequence_number: 12345,
 	}
 	buf := bytes.NewBuffer(make([]byte, 16))
 	buf.Reset()
@@ -175,26 +175,26 @@ func TestEncodeIntoUsesBigEndianEncoding(t *testing.T) {
 	}
 
 	innerbuf := buf.Bytes()
-	if binary.BigEndian.Uint32(innerbuf[0:4]) != p.command_length {
-		t.Errorf("Expected command_length %d, got %d", p.command_length, binary.BigEndian.Uint32(innerbuf[0:4]))
+	if binary.BigEndian.Uint32(innerbuf[0:4]) != p.Command_length {
+		t.Errorf("Expected command_length %d, got %d", p.Command_length, binary.BigEndian.Uint32(innerbuf[0:4]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[4:8]) != p.command_id {
-		t.Errorf("Expected command_id %d, got %d", p.command_id, binary.BigEndian.Uint32(innerbuf[4:8]))
+	if binary.BigEndian.Uint32(innerbuf[4:8]) != p.Command_id {
+		t.Errorf("Expected command_id %d, got %d", p.Command_id, binary.BigEndian.Uint32(innerbuf[4:8]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[8:12]) != p.command_status {
-		t.Errorf("Expected command_status %d, got %d", p.command_status, binary.BigEndian.Uint32(innerbuf[8:12]))
+	if binary.BigEndian.Uint32(innerbuf[8:12]) != p.Command_status {
+		t.Errorf("Expected command_status %d, got %d", p.Command_status, binary.BigEndian.Uint32(innerbuf[8:12]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[12:16]) != p.sequence_number {
-		t.Errorf("Expected sequence_number %d, got %d", p.sequence_number, binary.BigEndian.Uint32(innerbuf[12:16]))
+	if binary.BigEndian.Uint32(innerbuf[12:16]) != p.Sequence_number {
+		t.Errorf("Expected sequence_number %d, got %d", p.Sequence_number, binary.BigEndian.Uint32(innerbuf[12:16]))
 	}
 }
 
 func TestEncodeIntoConcurrencySafety(t *testing.T) {
 	p := &PDU_HEADER{
-		command_length:  16,
-		command_id:      1,
-		command_status:  0,
-		sequence_number: 12345,
+		Command_length:  16,
+		Command_id:      1,
+		Command_status:  0,
+		Sequence_number: 12345,
 	}
 	buf := bytes.NewBuffer(make([]byte, 16))
 	buf.Reset()
@@ -209,26 +209,26 @@ func TestEncodeIntoConcurrencySafety(t *testing.T) {
 	wg.Wait()
 
 	innerbuf := buf.Bytes()
-	if binary.BigEndian.Uint32(innerbuf[0:4]) != p.command_length {
-		t.Errorf("Expected command_length %d, got %d", p.command_length, binary.BigEndian.Uint32(innerbuf[0:4]))
+	if binary.BigEndian.Uint32(innerbuf[0:4]) != p.Command_length {
+		t.Errorf("Expected command_length %d, got %d", p.Command_length, binary.BigEndian.Uint32(innerbuf[0:4]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[4:8]) != p.command_id {
-		t.Errorf("Expected command_id %d, got %d", p.command_id, binary.BigEndian.Uint32(innerbuf[4:8]))
+	if binary.BigEndian.Uint32(innerbuf[4:8]) != p.Command_id {
+		t.Errorf("Expected command_id %d, got %d", p.Command_id, binary.BigEndian.Uint32(innerbuf[4:8]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[8:12]) != p.command_status {
-		t.Errorf("Expected command_status %d, got %d", p.command_status, binary.BigEndian.Uint32(innerbuf[8:12]))
+	if binary.BigEndian.Uint32(innerbuf[8:12]) != p.Command_status {
+		t.Errorf("Expected command_status %d, got %d", p.Command_status, binary.BigEndian.Uint32(innerbuf[8:12]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[12:16]) != p.sequence_number {
-		t.Errorf("Expected sequence_number %d, got %d", p.sequence_number, binary.BigEndian.Uint32(innerbuf[12:16]))
+	if binary.BigEndian.Uint32(innerbuf[12:16]) != p.Sequence_number {
+		t.Errorf("Expected sequence_number %d, got %d", p.Sequence_number, binary.BigEndian.Uint32(innerbuf[12:16]))
 	}
 }
 
 func TestEncodeIntoWithMaximumValues(t *testing.T) {
 	p := &PDU_HEADER{
-		command_length:  math.MaxUint32,
-		command_id:      math.MaxUint32,
-		command_status:  math.MaxUint32,
-		sequence_number: math.MaxUint32,
+		Command_length:  math.MaxUint32,
+		Command_id:      math.MaxUint32,
+		Command_status:  math.MaxUint32,
+		Sequence_number: math.MaxUint32,
 	}
 	buf := bytes.NewBuffer(make([]byte, 16))
 	buf.Reset()
@@ -239,26 +239,26 @@ func TestEncodeIntoWithMaximumValues(t *testing.T) {
 	}
 
 	innerbuf := buf.Bytes()
-	if binary.BigEndian.Uint32(innerbuf[0:4]) != p.command_length {
-		t.Errorf("Expected command_length %d, got %d", p.command_length, binary.BigEndian.Uint32(innerbuf[0:4]))
+	if binary.BigEndian.Uint32(innerbuf[0:4]) != p.Command_length {
+		t.Errorf("Expected command_length %d, got %d", p.Command_length, binary.BigEndian.Uint32(innerbuf[0:4]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[4:8]) != p.command_id {
-		t.Errorf("Expected command_id %d, got %d", p.command_id, binary.BigEndian.Uint32(innerbuf[4:8]))
+	if binary.BigEndian.Uint32(innerbuf[4:8]) != p.Command_id {
+		t.Errorf("Expected command_id %d, got %d", p.Command_id, binary.BigEndian.Uint32(innerbuf[4:8]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[8:12]) != p.command_status {
-		t.Errorf("Expected command_status %d, got %d", p.command_status, binary.BigEndian.Uint32(innerbuf[8:12]))
+	if binary.BigEndian.Uint32(innerbuf[8:12]) != p.Command_status {
+		t.Errorf("Expected command_status %d, got %d", p.Command_status, binary.BigEndian.Uint32(innerbuf[8:12]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[12:16]) != p.sequence_number {
-		t.Errorf("Expected sequence_number %d, got %d", p.sequence_number, binary.BigEndian.Uint32(innerbuf[12:16]))
+	if binary.BigEndian.Uint32(innerbuf[12:16]) != p.Sequence_number {
+		t.Errorf("Expected sequence_number %d, got %d", p.Sequence_number, binary.BigEndian.Uint32(innerbuf[12:16]))
 	}
 }
 
 func TestEncodeIntoWithBoundaryValues(t *testing.T) {
 	p := &PDU_HEADER{
-		command_length:  0,
-		command_id:      0,
-		command_status:  0,
-		sequence_number: 0,
+		Command_length:  0,
+		Command_id:      0,
+		Command_status:  0,
+		Sequence_number: 0,
 	}
 	buf := bytes.NewBuffer(make([]byte, 16))
 	buf.Reset()
@@ -269,17 +269,17 @@ func TestEncodeIntoWithBoundaryValues(t *testing.T) {
 	}
 
 	innerbuf := buf.Bytes()
-	if binary.BigEndian.Uint32(innerbuf[0:4]) != p.command_length {
-		t.Errorf("Expected command_length %d, got %d", p.command_length, binary.BigEndian.Uint32(innerbuf[0:4]))
+	if binary.BigEndian.Uint32(innerbuf[0:4]) != p.Command_length {
+		t.Errorf("Expected command_length %d, got %d", p.Command_length, binary.BigEndian.Uint32(innerbuf[0:4]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[4:8]) != p.command_id {
-		t.Errorf("Expected command_id %d, got %d", p.command_id, binary.BigEndian.Uint32(innerbuf[4:8]))
+	if binary.BigEndian.Uint32(innerbuf[4:8]) != p.Command_id {
+		t.Errorf("Expected command_id %d, got %d", p.Command_id, binary.BigEndian.Uint32(innerbuf[4:8]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[8:12]) != p.command_status {
-		t.Errorf("Expected command_status %d, got %d", p.command_status, binary.BigEndian.Uint32(innerbuf[8:12]))
+	if binary.BigEndian.Uint32(innerbuf[8:12]) != p.Command_status {
+		t.Errorf("Expected command_status %d, got %d", p.Command_status, binary.BigEndian.Uint32(innerbuf[8:12]))
 	}
-	if binary.BigEndian.Uint32(innerbuf[12:16]) != p.sequence_number {
-		t.Errorf("Expected sequence_number %d, got %d", p.sequence_number, binary.BigEndian.Uint32(innerbuf[12:16]))
+	if binary.BigEndian.Uint32(innerbuf[12:16]) != p.Sequence_number {
+		t.Errorf("Expected sequence_number %d, got %d", p.Sequence_number, binary.BigEndian.Uint32(innerbuf[12:16]))
 	}
 }
 
@@ -307,17 +307,17 @@ func TestDecodeParsesValidByteSlice(t *testing.T) {
 		t.Errorf("Expected no error, got %v", err)
 	}
 
-	if p.command_length != 16 {
-		t.Errorf("Expected command_length to be 16, got %d", p.command_length)
+	if p.Command_length != 16 {
+		t.Errorf("Expected command_length to be 16, got %d", p.Command_length)
 	}
-	if p.command_id != 1 {
-		t.Errorf("Expected command_id to be 1, got %d", p.command_id)
+	if p.Command_id != 1 {
+		t.Errorf("Expected command_id to be 1, got %d", p.Command_id)
 	}
-	if p.command_status != 2 {
-		t.Errorf("Expected command_status to be 2, got %d", p.command_status)
+	if p.Command_status != 2 {
+		t.Errorf("Expected command_status to be 2, got %d", p.Command_status)
 	}
-	if p.sequence_number != 3 {
-		t.Errorf("Expected sequence_number to be 3, got %d", p.sequence_number)
+	if p.Sequence_number != 3 {
+		t.Errorf("Expected sequence_number to be 3, got %d", p.Sequence_number)
 	}
 }
 
@@ -343,17 +343,17 @@ func TestDecodeHandlesNilDataInput(t *testing.T) {
 		t.Errorf("Expected error, got none")
 	}
 
-	if p.command_length != 0 {
-		t.Errorf("Expected command_length to be 0, got %d", p.command_length)
+	if p.Command_length != 0 {
+		t.Errorf("Expected command_length to be 0, got %d", p.Command_length)
 	}
-	if p.command_id != 0 {
-		t.Errorf("Expected command_id to be 0, got %d", p.command_id)
+	if p.Command_id != 0 {
+		t.Errorf("Expected command_id to be 0, got %d", p.Command_id)
 	}
-	if p.command_status != 0 {
-		t.Errorf("Expected command_status to be 0, got %d", p.command_status)
+	if p.Command_status != 0 {
+		t.Errorf("Expected command_status to be 0, got %d", p.Command_status)
 	}
-	if p.sequence_number != 0 {
-		t.Errorf("Expected sequence_number to be 0, got %d", p.sequence_number)
+	if p.Sequence_number != 0 {
+		t.Errorf("Expected sequence_number to be 0, got %d", p.Sequence_number)
 	}
 }
 
@@ -366,17 +366,17 @@ func TestDecodeHandlesEmptyByteSliceGracefully(t *testing.T) {
 		t.Errorf("Expected no error, got %v", err)
 	}
 
-	if p.command_length != 0 {
-		t.Errorf("Expected command_length to be 0, got %d", p.command_length)
+	if p.Command_length != 0 {
+		t.Errorf("Expected command_length to be 0, got %d", p.Command_length)
 	}
-	if p.command_id != 0 {
-		t.Errorf("Expected command_id to be 0, got %d", p.command_id)
+	if p.Command_id != 0 {
+		t.Errorf("Expected command_id to be 0, got %d", p.Command_id)
 	}
-	if p.command_status != 0 {
-		t.Errorf("Expected command_status to be 0, got %d", p.command_status)
+	if p.Command_status != 0 {
+		t.Errorf("Expected command_status to be 0, got %d", p.Command_status)
 	}
-	if p.sequence_number != 0 {
-		t.Errorf("Expected sequence_number to be 0, got %d", p.sequence_number)
+	if p.Sequence_number != 0 {
+		t.Errorf("Expected sequence_number to be 0, got %d", p.Sequence_number)
 	}
 }
 
@@ -408,11 +408,11 @@ func TestDecodeHandlesByteSlicesWithMaxUint32Values(t *testing.T) {
 		t.Errorf("Expected no error, got %v", err)
 	}
 
-	if p.command_length != math.MaxUint32 {
-		t.Errorf("Expected command_length to be %d, got %d", math.MaxUint32, p.command_length)
+	if p.Command_length != math.MaxUint32 {
+		t.Errorf("Expected command_length to be %d, got %d", math.MaxUint32, p.Command_length)
 	}
-	if p.command_id != math.MaxUint32 {
-		t.Errorf("Expected command_id to be %d, got %d", math.MaxUint32, p.command_id)
+	if p.Command_id != math.MaxUint32 {
+		t.Errorf("Expected command_id to be %d, got %d", math.MaxUint32, p.Command_id)
 	}
 }
 
@@ -425,11 +425,11 @@ func TestDecodeHandlesByteSlicesWithMinimumUint32Values(t *testing.T) {
 		t.Errorf("Expected no error, got %v", err)
 	}
 
-	if p.command_length != 0 {
-		t.Errorf("Expected command_length to be 0, got %d", p.command_length)
+	if p.Command_length != 0 {
+		t.Errorf("Expected command_length to be 0, got %d", p.Command_length)
 	}
-	if p.command_id != 0 {
-		t.Errorf("Expected command_id to be 0, got %d", p.command_id)
+	if p.Command_id != 0 {
+		t.Errorf("Expected command_id to be 0, got %d", p.Command_id)
 	}
 }
 
@@ -445,10 +445,10 @@ func TestSizeReturns16(t *testing.T) {
 // With buffer pool
 func BenchmarkEncodeWithBufferPool(b *testing.B) {
 	p := &PDU_HEADER{
-		command_length:  16,
-		command_id:      1,
-		command_status:  0,
-		sequence_number: 12345,
+		Command_length:  16,
+		Command_id:      1,
+		Command_status:  0,
+		Sequence_number: 12345,
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -461,10 +461,10 @@ func BenchmarkEncodeWithBufferPool(b *testing.B) {
 // Without buffer pool
 func BenchmarkEncodeWithoutBufferPool(b *testing.B) {
 	p := &PDU_HEADER{
-		command_length:  16,
-		command_id:      1,
-		command_status:  0,
-		sequence_number: 12345,
+		Command_length:  16,
+		Command_id:      1,
+		Command_status:  0,
+		Sequence_number: 12345,
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {

pdu/submit.go

@@ -2,35 +2,33 @@ package pdu
 
 import (
 	"bytes"
-	"encoding/ascii85"
 	"encoding/binary"
 	"fmt"
-	"log"
 
-	"github.com/warthog618/sms/encoding/gsm7"
+	"smpptester/encoding"
 )
 
 type (
 	SUBMIT_SM struct {
-		header                 *PDU_HEADER
-		service_type           string
-		source_addr_ton        byte
-		source_addr_npi        byte
-		source_addr            string
-		dest_addr_ton          byte
-		dest_addr_npi          byte
-		destination_addr       string
-		esm_class              byte
-		protocol_id            byte
-		priority_flag          byte
-		schedule_delivery_time string
-		validity_period        string
-		registered_delivery    byte
-		replace_if_present     byte
-		data_coding            byte
-		sm_default_msg_id      byte
-		sm_length              byte
-		short_message          string
+		Header                 *PDU_HEADER
+		Service_type           string
+		Source_addr_ton        byte
+		Source_addr_npi        byte
+		Source_addr            string
+		Dest_addr_ton          byte
+		Dest_addr_npi          byte
+		Destination_addr       string
+		Esm_class              byte
+		Protocol_id            byte
+		Priority_flag          byte
+		Schedule_delivery_time string
+		Validity_period        string
+		Registered_delivery    byte
+		Replace_if_present     byte
+		Data_coding            byte
+		Sm_default_msg_id      byte
+		Sm_length              byte
+		Short_message          string
 		// user_message_reference uint16
 		// source_port               uint16
 		// source_addr_subunit       byte
@@ -61,61 +59,50 @@ type (
 		// ussd_service_op           byte
 	}
 	SUBMIT_SM_RESP struct {
-		header     *PDU_HEADER
-		message_id string
+		Header     *PDU_HEADER
+		Message_id string
 	}
 	SUBMIT_MULTI      struct{}
 	SUBMIT_MULTI_RESP struct{}
 )
 
+// See https://www.codeproject.com/Tips/470755/Encoding-Decoding-7-bit-User-Data-for-SMS-PDU-PDU
+// Another great site: https://doubleblak.com/blogPost.php?k=7bitpdu
+
 func (p *SUBMIT_SM) Encode(buf *bytes.Buffer) error {
 	if buf == nil {
 		return fmt.Errorf("cannot encode into nil buffer")
 	}
-	// This won't do...
-	// TODO: Implement your own encoders and shit
-	// ASCII is easy
-	// UCS2 should also be fairly easy, use uint16 or something
-	// GSM7 will not be easy
-	// See https://www.codeproject.com/Tips/470755/Encoding-Decoding-7-bit-User-Data-for-SMS-PDU-PDU
-	// Another great site: https://doubleblak.com/blogPost.php?k=7bitpdu
-	asciiEncoder := ascii85.NewEncoder(buf)
-	// TODO: Implement encodings bsed on p.data_coding
-	messageEncoder := gsm7.NewEncoder()
+	messageEncoder := p.GetEncoder()
 
-	p.header.Encode(buf)
-	n, err := asciiEncoder.Write([]byte("OOO"))
+	p.Header.Encode(buf)
+	// These should be ASCII but UTF8 is a superset of ASCII so hopefully this'll be fine
+	buf.WriteString(p.Service_type)
+	buf.Write(NULL_ARR)
+	binary.Write(buf, binary.BigEndian, p.Source_addr_ton)
+	binary.Write(buf, binary.BigEndian, p.Source_addr_npi)
+	buf.WriteString(p.Source_addr)
+	buf.Write(NULL_ARR)
+	binary.Write(buf, binary.BigEndian, p.Dest_addr_ton)
+	binary.Write(buf, binary.BigEndian, p.Dest_addr_npi)
+	buf.WriteString(p.Destination_addr)
+	buf.Write(NULL_ARR)
+	binary.Write(buf, binary.BigEndian, p.Esm_class)
+	binary.Write(buf, binary.BigEndian, p.Protocol_id)
+	binary.Write(buf, binary.BigEndian, p.Priority_flag)
+	buf.WriteString(p.Schedule_delivery_time)
+	buf.Write(NULL_ARR)
+	buf.WriteString(p.Validity_period)
+	buf.Write(NULL_ARR)
+	binary.Write(buf, binary.BigEndian, p.Registered_delivery)
+	binary.Write(buf, binary.BigEndian, p.Replace_if_present)
+	binary.Write(buf, binary.BigEndian, p.Data_coding)
+	binary.Write(buf, binary.BigEndian, p.Sm_default_msg_id)
+	binary.Write(buf, binary.BigEndian, p.Sm_length)
+	err := messageEncoder.Encode(&p.Short_message, buf)
 	if err != nil {
 		return err
 	}
-	log.Println(n)
-	// asciiEncoder.Write([]byte(p.service_type))
-	buf.Write(NULL_ARR)
-	binary.Write(buf, binary.BigEndian, p.source_addr_ton)
-	binary.Write(buf, binary.BigEndian, p.source_addr_npi)
-	asciiEncoder.Write([]byte(p.source_addr))
-	buf.Write(NULL_ARR)
-	binary.Write(buf, binary.BigEndian, p.dest_addr_ton)
-	binary.Write(buf, binary.BigEndian, p.dest_addr_npi)
-	asciiEncoder.Write([]byte(p.destination_addr))
-	buf.Write(NULL_ARR)
-	binary.Write(buf, binary.BigEndian, p.esm_class)
-	binary.Write(buf, binary.BigEndian, p.protocol_id)
-	binary.Write(buf, binary.BigEndian, p.priority_flag)
-	asciiEncoder.Write([]byte(p.schedule_delivery_time))
-	buf.Write(NULL_ARR)
-	asciiEncoder.Write([]byte(p.validity_period))
-	buf.Write(NULL_ARR)
-	binary.Write(buf, binary.BigEndian, p.registered_delivery)
-	binary.Write(buf, binary.BigEndian, p.replace_if_present)
-	binary.Write(buf, binary.BigEndian, p.data_coding)
-	binary.Write(buf, binary.BigEndian, p.sm_default_msg_id)
-	binary.Write(buf, binary.BigEndian, p.sm_length)
-	encodedMsg, err := messageEncoder.Encode([]byte(p.short_message))
-	if err != nil {
-		return err
-	}
-	buf.Write(encodedMsg)
 	return nil
 }
 func (p *SUBMIT_SM) Decode(buf *bytes.Buffer) error {
@@ -126,38 +113,42 @@ func (p *SUBMIT_SM) Decode(buf *bytes.Buffer) error {
 }
 func (p *SUBMIT_SM) Size() int {
 	var size int
-	size += p.header.Size()
-	size += 1 + len(p.service_type)
+	size += p.Header.Size()
+	size += 1 + len(p.Service_type)
 	size += 1 // source_addr_ton
 	size += 1 // source_addr_npi
-	size += 1 + len(p.source_addr)
+	size += 1 + len(p.Source_addr)
 	size += 1 // dest_addr_ton
 	size += 1 // dest_addr_npi
-	size += 1 + len(p.destination_addr)
+	size += 1 + len(p.Destination_addr)
 	size += 1 // esm_class
 	size += 1 // protocol_id
 	size += 1 // priority_flag
-	size += 1 + len(p.schedule_delivery_time)
-	size += 1 + len(p.validity_period)
+	size += 1 + len(p.Schedule_delivery_time)
+	size += 1 + len(p.Validity_period)
 	size += 1 // registered_delivery
 	size += 1 // replace_if_present
 	size += 1 // data_coding
 	size += 1 // sm_default_msg_id
 	size += 1 // sm_length
-	// TODO: Handle encoding based on p.data_coding
-	switch p.data_coding {
-	case 0b00000000: // GSM7
-		size += (len(p.short_message)*7 + 8 - 1) / 8
-	case 0b00000001: // ASCII
-		size += len(p.short_message)
-	case 0b00000011: // LATIN1
-		size += len(p.short_message)
-	case 0b00001000: // UCS2
-		size += len(p.short_message) * 2
-	}
+	size += p.GetEncoder().EncodesInto(&p.Short_message)
 	return size
 }
 func (p *SUBMIT_SM) UpdateSize() {
-	p.header.command_length = uint32(p.Size())
-	p.sm_length = byte(len(p.short_message))
+	p.Header.Command_length = uint32(p.Size())
+	p.Sm_length = byte(p.GetEncoder().EncodesInto(&p.Short_message))
+}
+func (p *SUBMIT_SM) GetEncoder() encoding.Coder {
+	switch p.Data_coding {
+	case 0b00000000: // GSM7
+		return &encoding.GSM7Coder{}
+	case 0b00000001: // ASCII
+		return &encoding.ASCIICoder{}
+	// case 0b00000011: // LATIN1
+	// 	return &encoding.LATIN1Coder{}
+	case 0b00001000: // UCS2
+		return &encoding.UCS2Coder{}
+	default:
+		return &encoding.ASCIICoder{}
+	}
 }

pdu/submit_test.go

@@ -9,28 +9,28 @@ import (
 // See examples: https://www.openmarket.com/docs/Content/apis/v4smpp/mt-examples.htm
 func TestEncodeFunctionCorrectlyEncodesAllFields(t *testing.T) {
 	p := &SUBMIT_SM{
-		header: &PDU_HEADER{
-			command_length:  0,
-			command_id:      4,
-			command_status:  0,
-			sequence_number: 378019,
+		Header: &PDU_HEADER{
+			Command_length:  0,
+			Command_id:      4,
+			Command_status:  0,
+			Sequence_number: 378019,
 		},
-		service_type:           "OMV4",
-		source_addr_ton:        3,
-		source_addr_npi:        1,
-		source_addr:            "80362",
-		dest_addr_ton:          1,
-		dest_addr_npi:          1,
-		destination_addr:       "812345001000",
-		esm_class:              0,
-		protocol_id:            0,
-		priority_flag:          0,
-		schedule_delivery_time: "",
-		validity_period:        "180105120000004+",
-		registered_delivery:    1,
-		data_coding:            1, // The example uses 0 and claims to use GSM but the message is encoded as ASCII...
-		sm_default_msg_id:      0,
-		short_message:          "Reply Yes to opt in or No to opt out.",
+		Service_type:           "OMV4",
+		Source_addr_ton:        3,
+		Source_addr_npi:        1,
+		Source_addr:            "80362",
+		Dest_addr_ton:          1,
+		Dest_addr_npi:          1,
+		Destination_addr:       "812345001000",
+		Esm_class:              0,
+		Protocol_id:            0,
+		Priority_flag:          0,
+		Schedule_delivery_time: "",
+		Validity_period:        "180105120000004+",
+		Registered_delivery:    1,
+		Data_coding:            1, // The example uses 0 and claims to use GSM but the message is encoded as ASCII...
+		Sm_default_msg_id:      0,
+		Short_message:          "Reply Yes to opt in or No to opt out.",
 	}
 	p.UpdateSize()
 	buf := ByteBufferPool.Get(p.Size())
@@ -39,45 +39,81 @@ func TestEncodeFunctionCorrectlyEncodesAllFields(t *testing.T) {
 		t.Fatalf("expected no error, got %v", err)
 	}
 
-	expected := []byte{0,0,0,107,0,0,0,4,0,0,0,0,0,5,196,163,79,77,86,52,0,3,1,56,48,51,54,50,0,1,1,56,49,50,51,52,53,48,48,49,48,48,48,0,0,0,0,0,49,56,48,49,48,53,49,50,48,48,48,48,48,48,52,43,0,1,0,0,0,37,82,101,112,108,121,32,89,101,115,32,116,111,32,111,112,116,32,105,110,32,111,114,32,78,111,32,116,111,32,111,112,116,32,111,117,116,46}
+	expected := []byte{0, 0, 0, 107, 0, 0, 0, 4, 0, 0, 0, 0, 0, 5, 196, 163, 79, 77, 86, 52, 0, 3, 1, 56, 48, 51, 54, 50, 0, 1, 1, 56, 49, 50, 51, 52, 53, 48, 48, 49, 48, 48, 48, 0, 0, 0, 0, 0, 49, 56, 48, 49, 48, 53, 49, 50, 48, 48, 48, 48, 48, 48, 52, 43, 0, 1, 0, 1, 0, 37, 82, 101, 112, 108, 121, 32, 89, 101, 115, 32, 116, 111, 32, 111, 112, 116, 32, 105, 110, 32, 111, 114, 32, 78, 111, 32, 116, 111, 32, 111, 112, 116, 32, 111, 117, 116, 46}
 	if !bytes.Equal(buf.Bytes(), expected) {
 		t.Fatalf("expected %v, got %v", expected, buf.Bytes())
 	}
 }
 
-// func TestRealScenario(t *testing.T) {
-//
-// 	p.header.command_length = uint32(p.Size())
-// 	p.sm_length = byte(len(p.short_message))
-// 	buf := make([]byte, p.Size())
-// 	err := p.EncodeInto(&buf)
-// 	if err != nil {
-// 		t.Errorf("Expected no error, got %v", err)
-// 	}
-// 	if len(buf) != len(expected) {
-// 		t.Errorf("Expected byte slice of length %d, got %d", len(expected), len(buf))
-// 	}
-// 	for i, v := range buf {
-// 		if v != expected[i] {
-// 			t.Errorf("Expected byte slice with values %v, got %v", expected, buf)
-// 			break
-// 		}
-// 	}
-// }
+func TestEncodeFunctionCorrectlyEncodesAllFieldsGSM7Message(t *testing.T) {
+	p := &SUBMIT_SM{
+		Header: &PDU_HEADER{
+			Command_length:  0,
+			Command_id:      4,
+			Command_status:  0,
+			Sequence_number: 378019,
+		},
+		Service_type:           "OMV4",
+		Source_addr_ton:        3,
+		Source_addr_npi:        1,
+		Source_addr:            "80362",
+		Dest_addr_ton:          1,
+		Dest_addr_npi:          1,
+		Destination_addr:       "812345001000",
+		Esm_class:              0,
+		Protocol_id:            0,
+		Priority_flag:          0,
+		Schedule_delivery_time: "",
+		Validity_period:        "180105120000004+",
+		Registered_delivery:    1,
+		Data_coding:            0, // The example uses 0 and claims to use GSM but the message is encoded as ASCII...
+		Sm_default_msg_id:      0,
+		Short_message:          "Reply Yes to opt in or No to opt out.",
+	}
+	p.UpdateSize()
+	buf := ByteBufferPool.Get(p.Size())
+	err := p.Encode(buf)
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+
+	expected := []byte{0, 0, 0, 103, 0, 0, 0, 4, 0, 0, 0, 0, 0, 5, 196, 163, 79, 77, 86, 52, 0, 3, 1, 56, 48, 51, 54, 50, 0, 1, 1, 56, 49, 50, 51, 52, 53, 48, 48, 49, 48, 48, 48, 0, 0, 0, 0, 0, 49, 56, 48, 49, 48, 53, 49, 50, 48, 48, 48, 48, 48, 48, 52, 43, 0, 1, 0, 0, 0, 33, 210, 50, 156, 157, 7, 101, 203, 115, 16, 253, 13, 122, 195, 233, 160, 180, 27, 244, 150, 131, 156, 111, 16, 253, 13, 122, 195, 233, 160, 119, 157, 238, 2}
+	if !bytes.Equal(buf.Bytes(), expected) {
+		t.Fatalf("expected %v, got %v", expected, buf.Bytes())
+	}
+}
 
 // region decode
 
 // region size
 func TestCalculateSizeTypicalInstance(t *testing.T) {
 	p := &SUBMIT_SM{
-		service_type:           "test_service",
-		source_addr:            "12345",
-		destination_addr:       "67890",
-		schedule_delivery_time: "",
-		validity_period:        "",
-		short_message:          "Hello, World!",
+		Service_type:           "test_service",
+		Source_addr:            "12345",
+		Destination_addr:       "67890",
+		Schedule_delivery_time: "",
+		Validity_period:        "",
+		Short_message:          "Hello, World!",
+		Data_coding:            1,
 	}
-	expectedSize := 16 + len(p.service_type) + 1 + 1 + len(p.source_addr) + 1 + 1 + len(p.destination_addr) + 1 + 1 + 1 + len(p.schedule_delivery_time) + len(p.validity_period) + 1 + 1 + 1 + 1 + 1 + len(p.short_message)
+	expectedSize := 68
+	actualSize := p.Size()
+	if actualSize != expectedSize {
+		t.Errorf("Expected size %d, but got %d", expectedSize, actualSize)
+	}
+}
+
+func TestCalculateSizeTypicalGSM7Instance(t *testing.T) {
+	p := &SUBMIT_SM{
+		Service_type:           "test_service",
+		Source_addr:            "12345",
+		Destination_addr:       "67890",
+		Schedule_delivery_time: "",
+		Validity_period:        "",
+		Short_message:          "Hello, World!",
+		Data_coding:            0,
+	}
+	expectedSize := 67
 	actualSize := p.Size()
 	if actualSize != expectedSize {
 		t.Errorf("Expected size %d, but got %d", expectedSize, actualSize)
@@ -87,14 +123,15 @@ func TestCalculateSizeTypicalInstance(t *testing.T) {
 func TestCalculateSizeMaxLengths(t *testing.T) {
 	maxLen := 255
 	p := &SUBMIT_SM{
-		service_type:           string(make([]byte, maxLen)),
-		source_addr:            string(make([]byte, maxLen)),
-		destination_addr:       string(make([]byte, maxLen)),
-		schedule_delivery_time: string(make([]byte, maxLen)),
-		validity_period:        string(make([]byte, maxLen)),
-		short_message:          string(make([]byte, maxLen)),
+		Service_type:           string(make([]byte, maxLen)),
+		Source_addr:            string(make([]byte, maxLen)),
+		Destination_addr:       string(make([]byte, maxLen)),
+		Schedule_delivery_time: string(make([]byte, maxLen)),
+		Validity_period:        string(make([]byte, maxLen)),
+		Short_message:          string(make([]byte, maxLen)),
+		Data_coding:            1,
 	}
-	expectedSize := 16 + maxLen + 1 + 1 + maxLen + 1 + 1 + maxLen + 1 + 1 + 1 + maxLen + maxLen + 1 + 1 + 1 + 1 + 1 + maxLen
+	expectedSize := 1563
 	actualSize := p.Size()
 	if actualSize != expectedSize {
 		t.Errorf("Expected size %d, but got %d", expectedSize, actualSize)
@@ -103,14 +140,14 @@ func TestCalculateSizeMaxLengths(t *testing.T) {
 
 func TestHandlesEmptyStringsForAllStringFields(t *testing.T) {
 	p := &SUBMIT_SM{
-		service_type:           "",
-		source_addr:            "",
-		destination_addr:       "",
-		schedule_delivery_time: "",
-		validity_period:        "",
-		short_message:          "",
+		Service_type:           "",
+		Source_addr:            "",
+		Destination_addr:       "",
+		Schedule_delivery_time: "",
+		Validity_period:        "",
+		Short_message:          "",
 	}
-	expectedSize := 16 + len(p.service_type) + 1 + 1 + len(p.source_addr) + 1 + 1 + len(p.destination_addr) + 1 + 1 + 1 + len(p.schedule_delivery_time) + len(p.validity_period) + 1 + 1 + 1 + 1 + 1 + len(p.short_message)
+	expectedSize := 33
 	actualSize := p.Size()
 	if actualSize != expectedSize {
 		t.Errorf("Expected size %d, but got %d", expectedSize, actualSize)