utf support for string

lib/common/mapping.go

@@ -7,43 +7,12 @@ import (
 
 type Mapping []byte
 
-func (mapping Mapping) Values() [][2][]byte {
+//65537
-	return make([][2][]byte, 0)
+
+func (mapping Mapping) Values() [][2]String {
+	return make([][2]String, 0)
 }
 
-func ValuesToMapping(values [][2][]byte) Mapping {
+func ValuesToMapping(values [][2]String) Mapping {
 	return Mapping{}
 }
-
-//func (mapping Mapping) ToMap() map[string]string {
-//	gomap := make(map[string]string)
-//	kv_store := string(mapping[2:])
-//	pairs := strings.Split(kv_store, ";")
-//	for _, pair := range pairs {
-//		values := strings.Split(pair, "=")
-//		if len(values) != 2 {
-//			continue
-//		}
-//		gomap[values[0]] = values[1]
-//	}
-//	return gomap
-//}
-
-//func MappingFromMap(gomap map[string]string) Mapping {
-//	kv_store := make([]byte, 0)
-//	for k, v := range gomap {
-//		key_bytes := []byte(k)
-//		key_bytes = append(key_bytes, 0x3d)
-//		value_bytes := []byte(v)
-//		value_bytes = append(value_bytes, 0x3b)
-//		kv_store = append(kv_store, key_bytes...)
-//		kv_store = append(kv_store, value_bytes...)
-//	}
-//	kv_size := uint16(len(kv_store))
-//	var size [2]byte
-//	binary.BigEndian.PutUint16(size[:], kv_size)
-//	mapping := Mapping{}
-//	mapping = append(mapping, size[:]...)
-//	mapping = append(mapping, kv_store...)
-//	return mapping
-//}

lib/common/mapping_test.go

@@ -1 +1,38 @@
 package common
+
+import (
+	"testing"
+)
+
+func TestValuesReturnsCorrectValues(t *testing.T) {
+	//	bytes := []byte{}
+
+}
+
+func TextValuesReportsMappingTooBig() {
+
+}
+
+func TestValuesReportsStringErrorsWhenStringZeroLen(t *testing.T) {
+
+}
+
+func TestValuesReportsStringErrorsWhenStringExtraData(t *testing.T) {
+
+}
+
+func TestValuesReportsStringErrorsWhenStringMissingData(t *testing.T) {
+
+}
+
+func TestValuesReportsStringErrorsWhenStringLengthNoData(t *testing.T) {
+
+}
+
+func TestValuesToMappingCreatesCorrectFormat(t *testing.T) {
+
+}
+
+func TestValuesToMappingReportsStringTooLongError(t *testing.T) {
+
+}

lib/common/string.go

@@ -4,14 +4,14 @@ import (
 	"errors"
 )
 
-type String []byte
+type String []rune
 
 func (str String) Length() (int, error) {
 	if len(str) == 0 {
 		// log
 		return 0, errors.New("error parsing string: zero length")
 	}
-	length := Integer([]byte{str[0]})
+	length := Integer([]byte{byte(str[0])})
 	inferred_len := length + 1
 	str_len := len(str)
 	if inferred_len > str_len {
@@ -24,12 +24,12 @@ func (str String) Length() (int, error) {
 	return length, nil
 }
 
-func (str String) Data() ([]byte, error) {
+func (str String) Data() ([]rune, error) {
 	length, err := str.Length()
 	if err != nil {
 		switch err.Error() {
 		case "error parsing string: zero length":
-			return make([]byte, 0), err
+			return make([]rune, 0), err
 		case "string parsing warning: string data is shorter than specified by length":
 			return str[1:], err
 		case "string parsing warning: string contains data beyond length":
@@ -44,28 +44,28 @@ func (str String) GoString() (string, error) {
 	return string(content), err
 }
 
-func ToI2PString(data []byte) (String, error) {
+func ToI2PString(data []rune) (String, error) {
 	data_len := len(data)
 	if data_len >= 256 {
-		return make([]byte, 0), errors.New("cannot store that much data in I2P string")
+		return make([]rune, 0), errors.New("cannot store that much data in I2P string")
 	}
-	i2p_string := []byte{byte(data_len)}
+	i2p_string := []rune{rune(data_len)}
 	i2p_string = append(i2p_string, data...)
 	return String(i2p_string), nil
 }
 
-func ReadString(data []byte) (String, []byte, error) {
+func ReadString(data []rune) (String, []rune, error) {
 	str := String(data)
 	length, err := String(data).Length()
 	if err != nil {
 		switch err.Error() {
 		case "error parsing string: zero length":
-			return String{}, make([]byte, 0), err
+			return String{}, make([]rune, 0), err
 		case "string parsing warning: string data is shorter than specified by length":
-			return str, make([]byte, 0), err
+			return str, make([]rune, 0), err
 		case "string parsing warning: string contains data beyond length":
 			return String(str[:length+1]), str[length+1:], err
 		}
 	}
-	return str, make([]byte, 0), nil
+	return str, make([]rune, 0), nil
 }

lib/common/string_test.go

@@ -3,7 +3,7 @@ package common
 import "testing"
 
 func TestStringReportsCorrectLength(t *testing.T) {
-	str_len, err := String([]byte{0x02, 0x00, 0x00}).Length()
+	str_len, err := String([]rune{0x02, 0x00, 0x00}).Length()
 	if str_len != 2 {
 		t.Fatal("string.Length() did not report correct length")
 	}
@@ -13,7 +13,7 @@ func TestStringReportsCorrectLength(t *testing.T) {
 }
 
 func TestStringReportsLengthZeroError(t *testing.T) {
-	str_len, err := String(make([]byte, 0)).Length()
+	str_len, err := String(make([]rune, 0)).Length()
 	if str_len != 0 {
 		t.Fatal("string.Length() reported non-zero length on empty slice")
 	}
@@ -23,7 +23,7 @@ func TestStringReportsLengthZeroError(t *testing.T) {
 }
 
 func TestStringReportsExtraDataError(t *testing.T) {
-	str_len, err := String([]byte{0x01, 0x00, 0x00}).Length()
+	str_len, err := String([]rune{0x01, 0x00, 0x00}).Length()
 	if str_len != 1 {
 		t.Fatal("string.Length() reported wrong size when extra data present")
 	}
@@ -33,9 +33,9 @@ func TestStringReportsExtraDataError(t *testing.T) {
 }
 
 func TestStringDataReportsLengthZeroError(t *testing.T) {
-	str_len, err := String([]byte{0x01}).Length()
+	str_len, err := String([]rune{0x01}).Length()
 	if str_len != 1 {
-		t.Fatal("string.Length() reported wring length with missing data", str_len)
+		t.Fatal("string.Length() reported wrong length with missing data", str_len)
 	}
 	if err == nil || err.Error() != "string parsing warning: string data is shorter than specified by length" {
 		t.Fatal("string.Length() reported wrong error when data was missing", err)
@@ -43,7 +43,7 @@ func TestStringDataReportsLengthZeroError(t *testing.T) {
 }
 
 func TestStringDataReportsExtraDataError(t *testing.T) {
-	data, err := String([]byte{0x01, 0x00, 0x01}).Data()
+	data, err := String([]rune{0x01, 0x00, 0x01}).Data()
 	data_len := len(data)
 	if data_len != 1 {
 		t.Fatal("string.Data() returned wrong size data for length with extra data:", data_len)
@@ -54,7 +54,7 @@ func TestStringDataReportsExtraDataError(t *testing.T) {
 }
 
 func TestStringDataEmptyWhenZeroLength(t *testing.T) {
-	data, err := String(make([]byte, 0)).Data()
+	data, err := String(make([]rune, 0)).Data()
 	data_len := len(data)
 	if data_len != 0 {
 		t.Fatal("string.Data() returned data when none was present:", data_len)
@@ -65,7 +65,7 @@ func TestStringDataEmptyWhenZeroLength(t *testing.T) {
 }
 
 func TestStringDataErrorWhenNonZeroLengthOnly(t *testing.T) {
-	data, err := String([]byte{0x01}).Data()
+	data, err := String([]rune{0x01}).Data()
 	data_len := len(data)
 	if data_len != 0 {
 		t.Fatal("string.Data() returned data when only length was present:", data_len)
@@ -76,7 +76,7 @@ func TestStringDataErrorWhenNonZeroLengthOnly(t *testing.T) {
 }
 
 func TestToI2PStringFormatsCorrectly(t *testing.T) {
-	i2p_string, err := ToI2PString([]byte{0x22, 0x33})
+	i2p_string, err := ToI2PString([]rune{0x22, 0x33})
 	if err != nil {
 		t.Fatal("ToI2PString() returned error on valid data:", err)
 	}
@@ -89,22 +89,22 @@ func TestToI2PStringFormatsCorrectly(t *testing.T) {
 }
 
 func TestToI2PStringReportsOverflows(t *testing.T) {
-	i2p_string, err := ToI2PString(make([]byte, 256))
+	i2p_string, err := ToI2PString(make([]rune, 256))
 	if len(i2p_string) != 0 {
 		t.Fatal("ToI2PString() returned data when overflowed")
 	}
 	if err == nil || err.Error() != "cannot store that much data in I2P string" {
 		t.Fatal("ToI2pString() did not report overflow")
 	}
-	_, err = ToI2PString(make([]byte, 255))
+	_, err = ToI2PString(make([]rune, 255))
 	if err != nil {
 		t.Fatal("ToI2PString() reported error with acceptable size:", err)
 	}
 }
 
 func TestReadStringReadsLength(t *testing.T) {
-	bytes := []byte{0x01, 0x04, 0x06}
+	runes := []rune{0x01, 0x04, 0x06}
-	str, remainder, err := ReadString(bytes)
+	str, remainder, err := ReadString(runes)
 	if err == nil || err.Error() != "string parsing warning: string contains data beyond length" {
 		t.Fatal("ReadString(t *testing.T) returned incorrect error,", err)
 	}
@@ -123,16 +123,16 @@ func TestReadStringReadsLength(t *testing.T) {
 }
 
 func TestReadStringErrWhenEmptySlice(t *testing.T) {
-	bytes := make([]byte, 0)
+	runes := make([]rune, 0)
-	_, _, err := ReadString(bytes)
+	_, _, err := ReadString(runes)
 	if err != nil && err.Error() != "error parsing string: zero length" {
 		t.Fatal("ReadString(t *testing.T) did not report empty slice error", err)
 	}
 }
 
 func TestReadStringErrWhenDataTooShort(t *testing.T) {
-	bytes := []byte{0x03, 0x01}
+	runes := []rune{0x03, 0x01}
-	str, remainder, err := ReadString(bytes)
+	str, remainder, err := ReadString(runes)
 	if err != nil && err.Error() != "string parsing warning: string data is shorter than specified by length" {
 		t.Fatal("ReadString(t *testing.T) did not report string too long", err)
 	}