| Server IP : 91.108.119.154 / Your IP : 216.73.216.254 Web Server : LiteSpeed System : Linux id-dci-web1986.main-hosting.eu 5.14.0-611.26.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Jan 29 05:24:47 EST 2026 x86_64 User : u686484674 ( 686484674) PHP Version : 8.0.30 Disable Function : system, exec, shell_exec, passthru, mysql_list_dbs, ini_alter, dl, symlink, link, chgrp, leak, popen, apache_child_terminate, virtual, mb_send_mail MySQL : OFF | cURL : ON | WGET : ON | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /opt/golang/1.22.0/src/syscall/ |
Upload File : |
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package syscall_test
import (
"fmt"
"slices"
"syscall"
"testing"
"unicode/utf16"
"unicode/utf8"
"unsafe"
)
var wtf8tests = []struct {
str string
wstr []uint16
}{
{
str: "\x00",
wstr: []uint16{0x00},
},
{
str: "\x5C",
wstr: []uint16{0x5C},
},
{
str: "\x7F",
wstr: []uint16{0x7F},
},
// 2-byte
{
str: "\xC2\x80",
wstr: []uint16{0x80},
},
{
str: "\xD7\x8A",
wstr: []uint16{0x05CA},
},
{
str: "\xDF\xBF",
wstr: []uint16{0x07FF},
},
// 3-byte
{
str: "\xE0\xA0\x80",
wstr: []uint16{0x0800},
},
{
str: "\xE2\xB0\xBC",
wstr: []uint16{0x2C3C},
},
{
str: "\xEF\xBF\xBF",
wstr: []uint16{0xFFFF},
},
// unmatched surrogate halves
// high surrogates: 0xD800 to 0xDBFF
{
str: "\xED\xA0\x80",
wstr: []uint16{0xD800},
},
{
// "High surrogate followed by another high surrogate"
str: "\xED\xA0\x80\xED\xA0\x80",
wstr: []uint16{0xD800, 0xD800},
},
{
// "High surrogate followed by a symbol that is not a surrogate"
str: string([]byte{0xED, 0xA0, 0x80, 0xA}),
wstr: []uint16{0xD800, 0xA},
},
{
// "Unmatched high surrogate, followed by a surrogate pair, followed by an unmatched high surrogate"
str: string([]byte{0xED, 0xA0, 0x80, 0xF0, 0x9D, 0x8C, 0x86, 0xED, 0xA0, 0x80}),
wstr: []uint16{0xD800, 0xD834, 0xDF06, 0xD800},
},
{
str: "\xED\xA6\xAF",
wstr: []uint16{0xD9AF},
},
{
str: "\xED\xAF\xBF",
wstr: []uint16{0xDBFF},
},
// low surrogates: 0xDC00 to 0xDFFF
{
str: "\xED\xB0\x80",
wstr: []uint16{0xDC00},
},
{
// "Low surrogate followed by another low surrogate"
str: "\xED\xB0\x80\xED\xB0\x80",
wstr: []uint16{0xDC00, 0xDC00},
},
{
// "Low surrogate followed by a symbol that is not a surrogate"
str: string([]byte{0xED, 0xB0, 0x80, 0xA}),
wstr: []uint16{0xDC00, 0xA},
},
{
// "Unmatched low surrogate, followed by a surrogate pair, followed by an unmatched low surrogate"
str: string([]byte{0xED, 0xB0, 0x80, 0xF0, 0x9D, 0x8C, 0x86, 0xED, 0xB0, 0x80}),
wstr: []uint16{0xDC00, 0xD834, 0xDF06, 0xDC00},
},
{
str: "\xED\xBB\xAE",
wstr: []uint16{0xDEEE},
},
{
str: "\xED\xBF\xBF",
wstr: []uint16{0xDFFF},
},
// 4-byte
{
str: "\xF0\x90\x80\x80",
wstr: []uint16{0xD800, 0xDC00},
},
{
str: "\xF0\x9D\x8C\x86",
wstr: []uint16{0xD834, 0xDF06},
},
{
str: "\xF4\x8F\xBF\xBF",
wstr: []uint16{0xDBFF, 0xDFFF},
},
}
func TestWTF16Rountrip(t *testing.T) {
for _, tt := range wtf8tests {
t.Run(fmt.Sprintf("%X", tt.str), func(t *testing.T) {
got := syscall.EncodeWTF16(tt.str, nil)
got2 := string(syscall.DecodeWTF16(got, nil))
if got2 != tt.str {
t.Errorf("got:\n%s\nwant:\n%s", got2, tt.str)
}
})
}
}
func TestWTF16Golden(t *testing.T) {
for _, tt := range wtf8tests {
t.Run(fmt.Sprintf("%X", tt.str), func(t *testing.T) {
got := syscall.EncodeWTF16(tt.str, nil)
if !slices.Equal(got, tt.wstr) {
t.Errorf("got:\n%v\nwant:\n%v", got, tt.wstr)
}
})
}
}
func FuzzEncodeWTF16(f *testing.F) {
for _, tt := range wtf8tests {
f.Add(tt.str)
}
f.Fuzz(func(t *testing.T, b string) {
// test that there are no panics
got := syscall.EncodeWTF16(b, nil)
syscall.DecodeWTF16(got, nil)
if utf8.ValidString(b) {
// if the input is a valid UTF-8 string, then
// test that syscall.EncodeWTF16 behaves as
// utf16.Encode
want := utf16.Encode([]rune(b))
if !slices.Equal(got, want) {
t.Errorf("got:\n%v\nwant:\n%v", got, want)
}
}
})
}
func FuzzDecodeWTF16(f *testing.F) {
for _, tt := range wtf8tests {
b := unsafe.Slice((*uint8)(unsafe.Pointer(unsafe.SliceData(tt.wstr))), len(tt.wstr)*2)
f.Add(b)
}
f.Fuzz(func(t *testing.T, b []byte) {
u16 := unsafe.Slice((*uint16)(unsafe.Pointer(unsafe.SliceData(b))), len(b)/2)
got := syscall.DecodeWTF16(u16, nil)
if utf8.Valid(got) {
// if the input is a valid UTF-8 string, then
// test that syscall.DecodeWTF16 behaves as
// utf16.Decode
want := utf16.Decode(u16)
if string(got) != string(want) {
t.Errorf("got:\n%s\nwant:\n%s", string(got), string(want))
}
}
// WTF-8 should always roundtrip
got2 := syscall.EncodeWTF16(string(got), nil)
if !slices.Equal(got2, u16) {
t.Errorf("got:\n%v\nwant:\n%v", got2, u16)
}
})
}