mirror of
https://github.com/Mezeporta/Erupe.git
synced 2026-03-22 15:43:49 +01:00
707 lines
16 KiB
Go
707 lines
16 KiB
Go
package pascalstring
|
|
|
|
import (
|
|
"bytes"
|
|
"erupe-ce/common/byteframe"
|
|
"testing"
|
|
)
|
|
|
|
func TestUint8_NoTransform(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "Hello"
|
|
|
|
Uint8(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint8()
|
|
expectedLength := uint8(len(testString) + 1) // +1 for null terminator
|
|
|
|
if length != expectedLength {
|
|
t.Errorf("length = %d, want %d", length, expectedLength)
|
|
}
|
|
|
|
data := bf.ReadBytes(uint(length))
|
|
// Should be "Hello\x00"
|
|
expected := []byte("Hello\x00")
|
|
if !bytes.Equal(data, expected) {
|
|
t.Errorf("data = %v, want %v", data, expected)
|
|
}
|
|
}
|
|
|
|
func TestUint8_WithTransform(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
// ASCII string (no special characters)
|
|
testString := "Test"
|
|
|
|
Uint8(bf, testString, true)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint8()
|
|
|
|
if length == 0 {
|
|
t.Error("length should not be 0 for ASCII string")
|
|
}
|
|
|
|
data := bf.ReadBytes(uint(length))
|
|
// Should end with null terminator
|
|
if data[len(data)-1] != 0 {
|
|
t.Error("data should end with null terminator")
|
|
}
|
|
}
|
|
|
|
func TestUint8_EmptyString(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := ""
|
|
|
|
Uint8(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint8()
|
|
|
|
if length != 1 { // Just null terminator
|
|
t.Errorf("length = %d, want 1", length)
|
|
}
|
|
|
|
data := bf.ReadBytes(uint(length))
|
|
if data[0] != 0 {
|
|
t.Error("empty string should produce just null terminator")
|
|
}
|
|
}
|
|
|
|
func TestUint16_NoTransform(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "World"
|
|
|
|
Uint16(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint16()
|
|
expectedLength := uint16(len(testString) + 1)
|
|
|
|
if length != expectedLength {
|
|
t.Errorf("length = %d, want %d", length, expectedLength)
|
|
}
|
|
|
|
data := bf.ReadBytes(uint(length))
|
|
expected := []byte("World\x00")
|
|
if !bytes.Equal(data, expected) {
|
|
t.Errorf("data = %v, want %v", data, expected)
|
|
}
|
|
}
|
|
|
|
func TestUint16_WithTransform(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "Test"
|
|
|
|
Uint16(bf, testString, true)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint16()
|
|
|
|
if length == 0 {
|
|
t.Error("length should not be 0 for ASCII string")
|
|
}
|
|
|
|
data := bf.ReadBytes(uint(length))
|
|
if data[len(data)-1] != 0 {
|
|
t.Error("data should end with null terminator")
|
|
}
|
|
}
|
|
|
|
func TestUint16_EmptyString(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := ""
|
|
|
|
Uint16(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint16()
|
|
|
|
if length != 1 {
|
|
t.Errorf("length = %d, want 1", length)
|
|
}
|
|
}
|
|
|
|
func TestUint32_NoTransform(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "Testing"
|
|
|
|
Uint32(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint32()
|
|
expectedLength := uint32(len(testString) + 1)
|
|
|
|
if length != expectedLength {
|
|
t.Errorf("length = %d, want %d", length, expectedLength)
|
|
}
|
|
|
|
data := bf.ReadBytes(uint(length))
|
|
expected := []byte("Testing\x00")
|
|
if !bytes.Equal(data, expected) {
|
|
t.Errorf("data = %v, want %v", data, expected)
|
|
}
|
|
}
|
|
|
|
func TestUint32_WithTransform(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "Test"
|
|
|
|
Uint32(bf, testString, true)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint32()
|
|
|
|
if length == 0 {
|
|
t.Error("length should not be 0 for ASCII string")
|
|
}
|
|
|
|
data := bf.ReadBytes(uint(length))
|
|
if data[len(data)-1] != 0 {
|
|
t.Error("data should end with null terminator")
|
|
}
|
|
}
|
|
|
|
func TestUint32_EmptyString(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := ""
|
|
|
|
Uint32(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint32()
|
|
|
|
if length != 1 {
|
|
t.Errorf("length = %d, want 1", length)
|
|
}
|
|
}
|
|
|
|
func TestUint8_LongString(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "This is a longer test string with more characters"
|
|
|
|
Uint8(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint8()
|
|
expectedLength := uint8(len(testString) + 1)
|
|
|
|
if length != expectedLength {
|
|
t.Errorf("length = %d, want %d", length, expectedLength)
|
|
}
|
|
|
|
data := bf.ReadBytes(uint(length))
|
|
if !bytes.HasSuffix(data, []byte{0}) {
|
|
t.Error("data should end with null terminator")
|
|
}
|
|
if !bytes.HasPrefix(data, []byte("This is")) {
|
|
t.Error("data should start with expected string")
|
|
}
|
|
}
|
|
|
|
func TestUint16_LongString(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
// Create a string longer than 255 to test uint16
|
|
testString := ""
|
|
for i := 0; i < 300; i++ {
|
|
testString += "A"
|
|
}
|
|
|
|
Uint16(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint16()
|
|
expectedLength := uint16(len(testString) + 1)
|
|
|
|
if length != expectedLength {
|
|
t.Errorf("length = %d, want %d", length, expectedLength)
|
|
}
|
|
|
|
data := bf.ReadBytes(uint(length))
|
|
if !bytes.HasSuffix(data, []byte{0}) {
|
|
t.Error("data should end with null terminator")
|
|
}
|
|
}
|
|
|
|
func TestAllFunctions_NullTermination(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
writeFn func(*byteframe.ByteFrame, string, bool)
|
|
readSize func(*byteframe.ByteFrame) uint
|
|
}{
|
|
{
|
|
name: "Uint8",
|
|
writeFn: func(bf *byteframe.ByteFrame, s string, t bool) {
|
|
Uint8(bf, s, t)
|
|
},
|
|
readSize: func(bf *byteframe.ByteFrame) uint {
|
|
return uint(bf.ReadUint8())
|
|
},
|
|
},
|
|
{
|
|
name: "Uint16",
|
|
writeFn: func(bf *byteframe.ByteFrame, s string, t bool) {
|
|
Uint16(bf, s, t)
|
|
},
|
|
readSize: func(bf *byteframe.ByteFrame) uint {
|
|
return uint(bf.ReadUint16())
|
|
},
|
|
},
|
|
{
|
|
name: "Uint32",
|
|
writeFn: func(bf *byteframe.ByteFrame, s string, t bool) {
|
|
Uint32(bf, s, t)
|
|
},
|
|
readSize: func(bf *byteframe.ByteFrame) uint {
|
|
return uint(bf.ReadUint32())
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "Test"
|
|
|
|
tt.writeFn(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
size := tt.readSize(bf)
|
|
data := bf.ReadBytes(size)
|
|
|
|
// Verify null termination
|
|
if data[len(data)-1] != 0 {
|
|
t.Errorf("%s: data should end with null terminator", tt.name)
|
|
}
|
|
|
|
// Verify length includes null terminator
|
|
if size != uint(len(testString)+1) {
|
|
t.Errorf("%s: size = %d, want %d", tt.name, size, len(testString)+1)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTransform_JapaneseCharacters(t *testing.T) {
|
|
// Test with Japanese characters that should be transformed to Shift-JIS
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "テスト" // "Test" in Japanese katakana
|
|
|
|
Uint16(bf, testString, true)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint16()
|
|
|
|
if length == 0 {
|
|
t.Error("Transformed Japanese string should have non-zero length")
|
|
}
|
|
|
|
// The transformed Shift-JIS should be different length than UTF-8
|
|
// UTF-8: 9 bytes (3 chars * 3 bytes each), Shift-JIS: 6 bytes (3 chars * 2 bytes each) + 1 null
|
|
data := bf.ReadBytes(uint(length))
|
|
if data[len(data)-1] != 0 {
|
|
t.Error("Transformed string should end with null terminator")
|
|
}
|
|
}
|
|
|
|
func TestTransform_InvalidUTF8(t *testing.T) {
|
|
// This test verifies graceful handling of encoding errors
|
|
// When transformation fails, the functions should write length 0
|
|
|
|
bf := byteframe.NewByteFrame()
|
|
// Create a string with invalid UTF-8 sequence
|
|
// Note: Go strings are generally valid UTF-8, but we can test the error path
|
|
testString := "Valid ASCII"
|
|
|
|
Uint8(bf, testString, true)
|
|
// Should succeed for ASCII characters
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint8()
|
|
if length == 0 {
|
|
t.Error("ASCII string should transform successfully")
|
|
}
|
|
}
|
|
|
|
func BenchmarkUint8_NoTransform(b *testing.B) {
|
|
testString := "Hello, World!"
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
bf := byteframe.NewByteFrame()
|
|
Uint8(bf, testString, false)
|
|
}
|
|
}
|
|
|
|
func BenchmarkUint8_WithTransform(b *testing.B) {
|
|
testString := "Hello, World!"
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
bf := byteframe.NewByteFrame()
|
|
Uint8(bf, testString, true)
|
|
}
|
|
}
|
|
|
|
func BenchmarkUint16_NoTransform(b *testing.B) {
|
|
testString := "Hello, World!"
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
bf := byteframe.NewByteFrame()
|
|
Uint16(bf, testString, false)
|
|
}
|
|
}
|
|
|
|
func BenchmarkUint32_NoTransform(b *testing.B) {
|
|
testString := "Hello, World!"
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
bf := byteframe.NewByteFrame()
|
|
Uint32(bf, testString, false)
|
|
}
|
|
}
|
|
|
|
func BenchmarkUint16_Japanese(b *testing.B) {
|
|
testString := "テストメッセージ"
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
bf := byteframe.NewByteFrame()
|
|
Uint16(bf, testString, true)
|
|
}
|
|
}
|
|
|
|
// Edge case tests for additional coverage
|
|
|
|
func TestUint8_MaxLength(t *testing.T) {
|
|
// Uint8 length can hold max 255, but string + null = 254 chars max
|
|
// Test with string at the uint8 boundary
|
|
bf := byteframe.NewByteFrame()
|
|
testString := string(make([]byte, 254)) // 254 chars + 1 null = 255
|
|
|
|
Uint8(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint8()
|
|
|
|
// Length should be 255 (254 chars + null)
|
|
if length != 255 {
|
|
t.Errorf("length = %d, want 255", length)
|
|
}
|
|
}
|
|
|
|
func TestUint8_OverflowString(t *testing.T) {
|
|
// Test string that would overflow uint8 length (>255)
|
|
bf := byteframe.NewByteFrame()
|
|
testString := string(make([]byte, 300)) // Would need 301 for length+null, exceeds uint8
|
|
|
|
Uint8(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint8()
|
|
|
|
// Due to uint8 overflow, length will wrap around
|
|
// 301 % 256 = 45, but actual behavior depends on implementation
|
|
t.Logf("Overflow string produced length: %d", length)
|
|
// This test documents the current behavior (truncation via uint8 overflow)
|
|
}
|
|
|
|
func TestUint16_ExactBoundary(t *testing.T) {
|
|
// Test string that fits exactly in uint16 boundary
|
|
bf := byteframe.NewByteFrame()
|
|
testString := string(make([]byte, 1000))
|
|
|
|
Uint16(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint16()
|
|
expectedLength := uint16(1000 + 1)
|
|
|
|
if length != expectedLength {
|
|
t.Errorf("length = %d, want %d", length, expectedLength)
|
|
}
|
|
}
|
|
|
|
func TestUint32_LargeString(t *testing.T) {
|
|
// Test moderately large string with uint32
|
|
bf := byteframe.NewByteFrame()
|
|
testString := string(make([]byte, 10000))
|
|
|
|
Uint32(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint32()
|
|
expectedLength := uint32(10000 + 1)
|
|
|
|
if length != expectedLength {
|
|
t.Errorf("length = %d, want %d", length, expectedLength)
|
|
}
|
|
}
|
|
|
|
func TestTransform_MixedContent(t *testing.T) {
|
|
// Test string with mixed ASCII and Japanese content
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "Player1: テスト"
|
|
|
|
Uint16(bf, testString, true)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint16()
|
|
|
|
if length == 0 {
|
|
t.Error("Mixed content string should transform successfully")
|
|
}
|
|
|
|
// Should have null terminator
|
|
data := bf.ReadBytes(uint(length))
|
|
if data[len(data)-1] != 0 {
|
|
t.Error("Transformed string should end with null terminator")
|
|
}
|
|
}
|
|
|
|
func TestTransform_SpecialSymbols(t *testing.T) {
|
|
// Test Japanese symbols that exist in Shift-JIS
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "★☆●○"
|
|
|
|
Uint16(bf, testString, true)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint16()
|
|
|
|
// Some symbols may not transform, check length is valid
|
|
t.Logf("Special symbols produced length: %d", length)
|
|
// If length is 0, the transform failed which is expected for some symbols
|
|
}
|
|
|
|
func TestTransform_NumbersAndSymbols(t *testing.T) {
|
|
// ASCII numbers and basic symbols should always work
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "12345!@#$%"
|
|
|
|
Uint16(bf, testString, true)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint16()
|
|
|
|
if length == 0 {
|
|
t.Error("ASCII numbers and symbols should transform successfully")
|
|
}
|
|
}
|
|
|
|
func TestUint8_SingleCharacter(t *testing.T) {
|
|
// Edge case: single character
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "A"
|
|
|
|
Uint8(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint8()
|
|
|
|
// Length should be 2 (1 char + null)
|
|
if length != 2 {
|
|
t.Errorf("length = %d, want 2", length)
|
|
}
|
|
|
|
data := bf.ReadBytes(uint(length))
|
|
if data[0] != 'A' || data[1] != 0 {
|
|
t.Errorf("data = %v, want [A, 0]", data)
|
|
}
|
|
}
|
|
|
|
func TestUint16_SingleCharacter(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "B"
|
|
|
|
Uint16(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint16()
|
|
|
|
if length != 2 {
|
|
t.Errorf("length = %d, want 2", length)
|
|
}
|
|
|
|
data := bf.ReadBytes(uint(length))
|
|
if data[0] != 'B' || data[1] != 0 {
|
|
t.Errorf("data = %v, want [B, 0]", data)
|
|
}
|
|
}
|
|
|
|
func TestUint32_SingleCharacter(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "C"
|
|
|
|
Uint32(bf, testString, false)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint32()
|
|
|
|
if length != 2 {
|
|
t.Errorf("length = %d, want 2", length)
|
|
}
|
|
|
|
data := bf.ReadBytes(uint(length))
|
|
if data[0] != 'C' || data[1] != 0 {
|
|
t.Errorf("data = %v, want [C, 0]", data)
|
|
}
|
|
}
|
|
|
|
func TestTransform_OnlySpaces(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := " " // Three spaces
|
|
|
|
Uint8(bf, testString, true)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint8()
|
|
|
|
// Spaces should transform fine
|
|
if length != 4 { // 3 spaces + null
|
|
t.Errorf("length = %d, want 4", length)
|
|
}
|
|
}
|
|
|
|
func TestTransform_Hiragana(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "あいうえお"
|
|
|
|
Uint16(bf, testString, true)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint16()
|
|
|
|
if length == 0 {
|
|
t.Error("Hiragana should transform to Shift-JIS successfully")
|
|
}
|
|
|
|
// Hiragana in Shift-JIS is 2 bytes per character
|
|
// 5 characters * 2 bytes + 1 null = 11 bytes
|
|
data := bf.ReadBytes(uint(length))
|
|
if data[len(data)-1] != 0 {
|
|
t.Error("Transformed string should end with null terminator")
|
|
}
|
|
}
|
|
|
|
func TestTransform_Katakana(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := "アイウエオ"
|
|
|
|
Uint16(bf, testString, true)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint16()
|
|
|
|
if length == 0 {
|
|
t.Error("Katakana should transform to Shift-JIS successfully")
|
|
}
|
|
|
|
data := bf.ReadBytes(uint(length))
|
|
if data[len(data)-1] != 0 {
|
|
t.Error("Transformed string should end with null terminator")
|
|
}
|
|
}
|
|
|
|
func TestMultipleWrites(t *testing.T) {
|
|
// Test writing multiple strings to same buffer
|
|
bf := byteframe.NewByteFrame()
|
|
|
|
Uint8(bf, "First", false)
|
|
Uint8(bf, "Second", false)
|
|
Uint8(bf, "Third", false)
|
|
|
|
bf.Seek(0, 0)
|
|
|
|
// Read first string
|
|
len1 := bf.ReadUint8()
|
|
data1 := bf.ReadBytes(uint(len1))
|
|
|
|
// Read second string
|
|
len2 := bf.ReadUint8()
|
|
data2 := bf.ReadBytes(uint(len2))
|
|
|
|
// Read third string
|
|
len3 := bf.ReadUint8()
|
|
data3 := bf.ReadBytes(uint(len3))
|
|
|
|
// Verify each string
|
|
if string(data1[:len(data1)-1]) != "First" {
|
|
t.Errorf("First string = %s, want First", string(data1[:len(data1)-1]))
|
|
}
|
|
if string(data2[:len(data2)-1]) != "Second" {
|
|
t.Errorf("Second string = %s, want Second", string(data2[:len(data2)-1]))
|
|
}
|
|
if string(data3[:len(data3)-1]) != "Third" {
|
|
t.Errorf("Third string = %s, want Third", string(data3[:len(data3)-1]))
|
|
}
|
|
}
|
|
|
|
func TestTransform_EmptyStringWithTransform(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
testString := ""
|
|
|
|
Uint8(bf, testString, true) // Transform enabled but string is empty
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint8()
|
|
|
|
// Empty string with transform should still produce length 1 (just null)
|
|
if length != 1 {
|
|
t.Errorf("Empty string with transform: length = %d, want 1", length)
|
|
}
|
|
}
|
|
|
|
func TestTransform_UnsupportedCharacters(t *testing.T) {
|
|
// Test characters that cannot be encoded in Shift-JIS
|
|
// Emoji and some Unicode characters are not supported
|
|
testStrings := []string{
|
|
"\U0001F600", // Emoji (grinning face) - not in Shift-JIS
|
|
"🎮", // Game controller emoji
|
|
"\U0001F4A9", // Pile of poo emoji
|
|
"中文测试", // Simplified Chinese (some chars not in Shift-JIS)
|
|
"العربية", // Arabic
|
|
"עברית", // Hebrew
|
|
"ไทย", // Thai
|
|
"한글", // Korean
|
|
}
|
|
|
|
for _, testString := range testStrings {
|
|
t.Run(testString, func(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
Uint8(bf, testString, true)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint8()
|
|
|
|
// These strings may fail to transform or transform partially
|
|
// Document the current behavior
|
|
t.Logf("String %q with transform produced length: %d", testString, length)
|
|
|
|
// If length is 0, the transform failed completely (error path)
|
|
// If length > 0, some or all characters were transformed
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTransform_Uint16_UnsupportedCharacters(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
// Use a string with characters not in Shift-JIS
|
|
testString := "🎮"
|
|
|
|
Uint16(bf, testString, true)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint16()
|
|
t.Logf("Uint16 transform of emoji produced length: %d", length)
|
|
}
|
|
|
|
func TestTransform_Uint32_UnsupportedCharacters(t *testing.T) {
|
|
bf := byteframe.NewByteFrame()
|
|
// Use a string with characters not in Shift-JIS
|
|
testString := "🎮"
|
|
|
|
Uint32(bf, testString, true)
|
|
|
|
bf.Seek(0, 0)
|
|
length := bf.ReadUint32()
|
|
t.Logf("Uint32 transform of emoji produced length: %d", length)
|
|
}
|