Getting go test working again.

convert is an optimized version (uses less memory, thanks to
string.Builder).

door/convert.go

@@ -1,5 +1,7 @@
 package door
 
+import "strings"
+
 // I used iconv in door++, but it was horrible.  It doesn't translate
 // control codes to Unicode.
 
@@ -8,324 +10,326 @@ package door
 // This does everything but: \x07, \x08, \x0a and \x0d.
 // 0x07, 0x08, 0x09, 0x0a, 0x0c, 0x0d, 0x1b (ANSI spec)
 func CP437_to_Unicode(cp437 string) string {
-	var result string
+	// var result string
+	var result strings.Builder
+	result.Grow(len(cp437))
 
 	for _, char := range []byte(cp437) {
 		// for _, char := range []rune(cp437) {
 		switch int(char) {
 		case 0x01:
-			result += "\u263A"
+			result.WriteRune('\u263A')
 		case 0x02:
-			result += "\u263B"
+			result.WriteRune('\u263B')
 		case 0x03:
-			result += "\u2665"
+			result.WriteRune('\u2665')
 		case 0x04:
-			result += "\u2666"
+			result.WriteRune('\u2666')
 		case 0x05:
-			result += "\u2663"
+			result.WriteRune('\u2663')
 		case 0x06:
-			result += "\u2660"
+			result.WriteRune('\u2660')
 		case 0x09:
-			result += "\u25CB"
+			result.WriteRune('\u25CB')
 		case 0x0b:
-			result += "\u2642"
+			result.WriteRune('\u2642')
 		case 0x0c:
-			result += "\u2640"
+			result.WriteRune('\u2640')
 		case 0x0e:
-			result += "\u266B"
+			result.WriteRune('\u266B')
 		case 0x0f:
-			result += "\u263C"
+			result.WriteRune('\u263C')
 		case 0x10:
-			result += "\u25BA"
+			result.WriteRune('\u25BA')
 		case 0x11:
-			result += "\u25C4"
+			result.WriteRune('\u25C4')
 		case 0x12:
-			result += "\u2195"
+			result.WriteRune('\u2195')
 		case 0x13:
-			result += "\u203C"
+			result.WriteRune('\u203C')
 		case 0x14:
-			result += "\xc2\xb6"
+			result.Write([]byte{0xc2, 0xb6})
 		case 0x15:
-			result += "\xc2\xa7"
+			result.Write([]byte{0xc2, 0xa7})
 		case 0x16:
-			result += "\u25AC"
+			result.WriteRune('\u25AC')
 		case 0x17:
-			result += "\u21A8"
+			result.WriteRune('\u21A8')
 		case 0x18:
-			result += "\u2191"
+			result.WriteRune('\u2191')
 		case 0x19:
-			result += "\u2193"
+			result.WriteRune('\u2193')
 		case 0x1a:
-			result += "\u2192"
+			result.WriteRune('\u2192')
 		case 0x1c:
-			result += "\u221F"
+			result.WriteRune('\u221F')
 		case 0x1d:
-			result += "\u2194"
+			result.WriteRune('\u2194')
 		case 0x1e:
-			result += "\u25B2"
+			result.WriteRune('\u25B2')
 		case 0x1f:
-			result += "\u25BC"
+			result.WriteRune('\u25BC')
 		case 0x7f:
-			result += "\u2302"
+			result.WriteRune('\u2302')
 		case 0x80:
-			result += "\xc3\x87"
+			result.Write([]byte{0xc3, 0x87})
 		case 0x81:
-			result += "\xc3\xbc"
+			result.Write([]byte{0xc3, 0xbc})
 		case 0x82:
-			result += "\xc3\xa9"
+			result.Write([]byte{0xc3, 0xa9})
 		case 0x83:
-			result += "\xc3\xa2"
+			result.Write([]byte{0xc3, 0xa2})
 		case 0x84:
-			result += "\xc3\xa4"
+			result.Write([]byte{0xc3, 0xa4})
 		case 0x85:
-			result += "\xc3\xa0"
+			result.Write([]byte{0xc3, 0xa0})
 		case 0x86:
-			result += "\xc3\xa5"
+			result.Write([]byte{0xc3, 0xa5})
 		case 0x87:
-			result += "\xc3\xa7"
+			result.Write([]byte{0xc3, 0xa7})
 		case 0x88:
-			result += "\xc3\xaa"
+			result.Write([]byte{0xc3, 0xaa})
 		case 0x89:
-			result += "\xc3\xab"
+			result.Write([]byte{0xc3, 0xab})
 		case 0x8a:
-			result += "\xc3\xa8"
+			result.Write([]byte{0xc3, 0xa8})
 		case 0x8b:
-			result += "\xc3\xaf"
+			result.Write([]byte{0xc3, 0xaf})
 		case 0x8c:
-			result += "\xc3\xae"
+			result.Write([]byte{0xc3, 0xae})
 		case 0x8d:
-			result += "\xc3\xac"
+			result.Write([]byte{0xc3, 0xac})
 		case 0x8e:
-			result += "\xc3\x84"
+			result.Write([]byte{0xc3, 0x84})
 		case 0x8f:
-			result += "\xc3\x85"
+			result.Write([]byte{0xc3, 0x85})
 		case 0x90:
-			result += "\xc3\x89"
+			result.Write([]byte{0xc3, 0x89})
 		case 0x91:
-			result += "\xc3\xa6"
+			result.Write([]byte{0xc3, 0xa6})
 		case 0x92:
-			result += "\xc3\x86"
+			result.Write([]byte{0xc3, 0x86})
 		case 0x93:
-			result += "\xc3\xb4"
+			result.Write([]byte{0xc3, 0xb4})
 		case 0x94:
-			result += "\xc3\xb6"
+			result.Write([]byte{0xc3, 0xb6})
 		case 0x95:
-			result += "\xc3\xb2"
+			result.Write([]byte{0xc3, 0xb2})
 		case 0x96:
-			result += "\xc3\xbb"
+			result.Write([]byte{0xc3, 0xbb})
 		case 0x97:
-			result += "\xc3\xb9"
+			result.Write([]byte{0xc3, 0xb9})
 		case 0x98:
-			result += "\xc3\xbf"
+			result.Write([]byte{0xc3, 0xbf})
 		case 0x99:
-			result += "\xc3\x96"
+			result.Write([]byte{0xc3, 0x96})
 		case 0x9a:
-			result += "\xc3\x9c"
+			result.Write([]byte{0xc3, 0x9c})
 		case 0x9b:
-			result += "\xc2\xa2"
+			result.Write([]byte{0xc2, 0xa2})
 		case 0x9c:
-			result += "\xc2\xa3"
+			result.Write([]byte{0xc2, 0xa3})
 		case 0x9d:
-			result += "\xc2\xa5"
+			result.Write([]byte{0xc2, 0xa5})
 		case 0x9e:
-			result += "\u20A7"
+			result.WriteRune('\u20A7')
 		case 0x9f:
-			result += "\u0192"
+			result.WriteRune('\u0192')
 		case 0xa0:
-			result += "\xc3\xa1"
+			result.Write([]byte{0xc3, 0xa1})
 		case 0xa1:
-			result += "\xc3\xad"
+			result.Write([]byte{0xc3, 0xad})
 		case 0xa2:
-			result += "\xc3\xb3"
+			result.Write([]byte{0xc3, 0xb3})
 		case 0xa3:
-			result += "\xc3\xba"
+			result.Write([]byte{0xc3, 0xba})
 		case 0xa4:
-			result += "\xc3\xb1"
+			result.Write([]byte{0xc3, 0xb1})
 		case 0xa5:
-			result += "\xc3\x91"
+			result.Write([]byte{0xc3, 0x91})
 		case 0xa6:
-			result += "\xc2\xaa"
+			result.Write([]byte{0xc2, 0xaa})
 		case 0xa7:
-			result += "\xc2\xba"
+			result.Write([]byte{0xc2, 0xba})
 		case 0xa8:
-			result += "\xc2\xbf"
+			result.Write([]byte{0xc2, 0xbf})
 		case 0xa9:
-			result += "\u2310"
+			result.WriteRune('\u2310')
 		case 0xaa:
-			result += "\xc2\xac"
+			result.Write([]byte{0xc2, 0xac})
 		case 0xab:
-			result += "\xc2\xbd"
+			result.Write([]byte{0xc2, 0xbd})
 		case 0xac:
-			result += "\xc2\xbc"
+			result.Write([]byte{0xc2, 0xbc})
 		case 0xad:
-			result += "\xc2\xa1"
+			result.Write([]byte{0xc2, 0xa1})
 		case 0xae:
-			result += "\xc2\xab"
+			result.Write([]byte{0xc2, 0xab})
 		case 0xaf:
-			result += "\xc2\xbb"
+			result.Write([]byte{0xc2, 0xbb})
 		case 0xb0:
-			result += "\u2591"
+			result.WriteRune('\u2591')
 		case 0xb1:
-			result += "\u2592"
+			result.WriteRune('\u2592')
 		case 0xb2:
-			result += "\u2593"
+			result.WriteRune('\u2593')
 		case 0xb3:
-			result += "\u2502"
+			result.WriteRune('\u2502')
 		case 0xb4:
-			result += "\u2524"
+			result.WriteRune('\u2524')
 		case 0xb5:
-			result += "\u2561"
+			result.WriteRune('\u2561')
 		case 0xb6:
-			result += "\u2562"
+			result.WriteRune('\u2562')
 		case 0xb7:
-			result += "\u2556"
+			result.WriteRune('\u2556')
 		case 0xb8:
-			result += "\u2555"
+			result.WriteRune('\u2555')
 		case 0xb9:
-			result += "\u2563"
+			result.WriteRune('\u2563')
 		case 0xba:
-			result += "\u2551"
+			result.WriteRune('\u2551')
 		case 0xbb:
-			result += "\u2557"
+			result.WriteRune('\u2557')
 		case 0xbc:
-			result += "\u255D"
+			result.WriteRune('\u255D')
 		case 0xbd:
-			result += "\u255C"
+			result.WriteRune('\u255C')
 		case 0xbe:
-			result += "\u255B"
+			result.WriteRune('\u255B')
 		case 0xbf:
-			result += "\u2510"
+			result.WriteRune('\u2510')
 		case 0xc0:
-			result += "\u2514"
+			result.WriteRune('\u2514')
 		case 0xc1:
-			result += "\u2534"
+			result.WriteRune('\u2534')
 		case 0xc2:
-			result += "\u252C"
+			result.WriteRune('\u252C')
 		case 0xc3:
-			result += "\u251C"
+			result.WriteRune('\u251C')
 		case 0xc4:
-			result += "\u2500"
+			result.WriteRune('\u2500')
 		case 0xc5:
-			result += "\u253C"
+			result.WriteRune('\u253C')
 		case 0xc6:
-			result += "\u255E"
+			result.WriteRune('\u255E')
 		case 0xc7:
-			result += "\u255F"
+			result.WriteRune('\u255F')
 		case 0xc8:
-			result += "\u255A"
+			result.WriteRune('\u255A')
 		case 0xc9:
-			result += "\u2554"
+			result.WriteRune('\u2554')
 		case 0xca:
-			result += "\u2569"
+			result.WriteRune('\u2569')
 		case 0xcb:
-			result += "\u2566"
+			result.WriteRune('\u2566')
 		case 0xcc:
-			result += "\u2560"
+			result.WriteRune('\u2560')
 		case 0xcd:
-			result += "\u2550"
+			result.WriteRune('\u2550')
 		case 0xce:
-			result += "\u256C"
+			result.WriteRune('\u256C')
 		case 0xcf:
-			result += "\u2567"
+			result.WriteRune('\u2567')
 		case 0xd0:
-			result += "\u2568"
+			result.WriteRune('\u2568')
 		case 0xd1:
-			result += "\u2564"
+			result.WriteRune('\u2564')
 		case 0xd2:
-			result += "\u2565"
+			result.WriteRune('\u2565')
 		case 0xd3:
-			result += "\u2559"
+			result.WriteRune('\u2559')
 		case 0xd4:
-			result += "\u2558"
+			result.WriteRune('\u2558')
 		case 0xd5:
-			result += "\u2552"
+			result.WriteRune('\u2552')
 		case 0xd6:
-			result += "\u2553"
+			result.WriteRune('\u2553')
 		case 0xd7:
-			result += "\u256B"
+			result.WriteRune('\u256B')
 		case 0xd8:
-			result += "\u256A"
+			result.WriteRune('\u256A')
 		case 0xd9:
-			result += "\u2518"
+			result.WriteRune('\u2518')
 		case 0xda:
-			result += "\u250C"
+			result.WriteRune('\u250C')
 		case 0xdb:
-			result += "\u2588"
+			result.WriteRune('\u2588')
 		case 0xdc:
-			result += "\u2584"
+			result.WriteRune('\u2584')
 		case 0xdd:
-			result += "\u258C"
+			result.WriteRune('\u258C')
 		case 0xde:
-			result += "\u2590"
+			result.WriteRune('\u2590')
 		case 0xdf:
-			result += "\u2580"
+			result.WriteRune('\u2580')
 		case 0xe0:
-			result += "\u03B1"
+			result.WriteRune('\u03B1')
 		case 0xe1:
-			result += "\xc3\x9f"
+			result.Write([]byte{0xc3, 0x9f})
 		case 0xe2:
-			result += "\u0393"
+			result.WriteRune('\u0393')
 		case 0xe3:
-			result += "\u03C0"
+			result.WriteRune('\u03C0')
 		case 0xe4:
-			result += "\u03A3"
+			result.WriteRune('\u03A3')
 		case 0xe5:
-			result += "\u03C3"
+			result.WriteRune('\u03C3')
 		case 0xe6:
-			result += "\xc2\xb5"
+			result.Write([]byte{0xc2, 0xb5})
 		case 0xe7:
-			result += "\u03C4"
+			result.WriteRune('\u03C4')
 		case 0xe8:
-			result += "\u03A6"
+			result.WriteRune('\u03A6')
 		case 0xe9:
-			result += "\u0398"
+			result.WriteRune('\u0398')
 		case 0xea:
-			result += "\u03A9"
+			result.WriteRune('\u03A9')
 		case 0xeb:
-			result += "\u03B4"
+			result.WriteRune('\u03B4')
 		case 0xec:
-			result += "\u221E"
+			result.WriteRune('\u221E')
 		case 0xed:
-			result += "\u03C6"
+			result.WriteRune('\u03C6')
 		case 0xee:
-			result += "\u03B5"
+			result.WriteRune('\u03B5')
 		case 0xef:
-			result += "\u2229"
+			result.WriteRune('\u2229')
 		case 0xf0:
-			result += "\u2261"
+			result.WriteRune('\u2261')
 		case 0xf1:
-			result += "\xc2\xb1"
+			result.Write([]byte{0xc2, 0xb1})
 		case 0xf2:
-			result += "\u2265"
+			result.WriteRune('\u2265')
 		case 0xf3:
-			result += "\u2264"
+			result.WriteRune('\u2264')
 		case 0xf4:
-			result += "\u2320"
+			result.WriteRune('\u2320')
 		case 0xf5:
-			result += "\u2321"
+			result.WriteRune('\u2321')
 		case 0xf6:
-			result += "\xc3\xb7"
+			result.Write([]byte{0xc3, 0xb7})
 		case 0xf7:
-			result += "\u2248"
+			result.WriteRune('\u2248')
 		case 0xf8:
-			result += "\xc2\xb0"
+			result.Write([]byte{0xc2, 0xb0})
 		case 0xf9:
-			result += "\u2219"
+			result.WriteRune('\u2219')
 		case 0xfa:
-			result += "\xc2\xb7"
+			result.Write([]byte{0xc2, 0xb7})
 		case 0xfb:
-			result += "\u221A"
+			result.WriteRune('\u221A')
 		case 0xfc:
-			result += "\u207F"
+			result.WriteRune('\u207F')
 		case 0xfd:
-			result += "\xc2\xb2"
+			result.Write([]byte{0xc2, 0xb2})
 		case 0xfe:
-			result += "\u25A0"
+			result.WriteRune('\u25A0')
 		case 0xff:
-			result += "\xc2\xa0"
+			result.Write([]byte{0xc2, 0xa0})
 		default:
-			result += string(char)
+			result.WriteByte(byte(char))
 		}
 	}
-	return result
+	return result.String()
 }

door/door.go

@@ -104,8 +104,10 @@ type Door struct {
 	WriterClosed   bool        // Writer closed
 	writerChannel  chan string // Writing to the User
 	writerMutex    sync.RWMutex
-	// closeChannel   chan struct{} // Closing
-	wg sync.WaitGroup
+	LastMouse      []Mouse     // Store Mouse information
+	LastCursor     []CursorPos // Store Cursor pos information
+	mcMutex        sync.Mutex  // Lock for LastMouse, LastCursor
+	wg             sync.WaitGroup
 }
 
 func (d *Door) SafeWriterClose() {
@@ -147,30 +149,6 @@ func (d *Door) ClearMouseCursor() {
 	d.LastCursor = make([]CursorPos, 0, 3)
 }
 
-func (d *Door) AddMouse(mouse Mouse) {
-	d.mcMutex.Lock()
-	defer d.mcMutex.Unlock()
-	d.LastMouse = append(d.LastMouse, mouse)
-}
-func (d *Door) GetMouse() (Mouse, bool) {
-	d.mcMutex.Lock()
-	defer d.mcMutex.Unlock()
-	return ArrayDelete(&d.LastMouse, 0)
-}
-
-func (d *Door) GetCursorPos() (CursorPos, bool) {
-	d.mcMutex.Lock()
-	defer d.mcMutex.Unlock()
-	return ArrayDelete(&d.LastCursor, 0)
-}
-
-func (d *Door) ClearMouseCursor() {
-	d.mcMutex.Lock()
-	defer d.mcMutex.Unlock()
-	d.LastMouse = make([]Mouse, 0, 2)
-	d.LastCursor = make([]CursorPos, 0, 3)
-}
-
 // Return the amount of time left as time.Duration
 func (d *Door) TimeLeft() time.Duration {
 	return time.Until(d.TimeOut)