@@ -6,7 +6,7 @@ rm -rf vendor/

 source 'hack/.vendor-helpers.sh'

 # the following lines are in sorted order, FYI

-clone git github.com/Azure/go-ansiterm 70b2c90b260171e829f1ebd7c17f600c11858dbe

+clone git github.com/Azure/go-ansiterm 388960b655244e76e24c75f48631564eaefade62

 clone git github.com/Microsoft/hcsshim v0.2.2

 clone git github.com/Microsoft/go-winio v0.3.0

 clone git github.com/Sirupsen/logrus v0.9.0 # logrus is a common dependency among multiple deps

@@ -136,14 +136,14 @@ func readInputEvents(fd uintptr, maxBytes int) ([]winterm.INPUT_RECORD, error) {

 // KeyEvent Translation Helpers

-var arrowKeyMapPrefix = map[winterm.WORD]string{

+var arrowKeyMapPrefix = map[uint16]string{

 	winterm.VK_UP:    "%s%sA",

 	winterm.VK_DOWN:  "%s%sB",

 	winterm.VK_RIGHT: "%s%sC",

 	winterm.VK_LEFT:  "%s%sD",

 }

-var keyMapPrefix = map[winterm.WORD]string{

+var keyMapPrefix = map[uint16]string{

 	winterm.VK_UP:     "\x1B[%sA",

 	winterm.VK_DOWN:   "\x1B[%sB",

 	winterm.VK_RIGHT:  "\x1B[%sC",

@@ -207,7 +207,7 @@ func keyToString(keyEvent *winterm.KEY_EVENT_RECORD, escapeSequence []byte) stri

 }

 // formatVirtualKey converts a virtual key (e.g., up arrow) into the appropriate ANSI string.

-func formatVirtualKey(key winterm.WORD, controlState winterm.DWORD, escapeSequence []byte) string {

+func formatVirtualKey(key uint16, controlState uint32, escapeSequence []byte) string {

 	shift, alt, control := getControlKeys(controlState)

 	modifier := getControlKeysModifier(shift, alt, control)

@@ -223,7 +223,7 @@ func formatVirtualKey(key winterm.WORD, controlState winterm.DWORD, escapeSequen

 }

 // getControlKeys extracts the shift, alt, and ctrl key states.

-func getControlKeys(controlState winterm.DWORD) (shift, alt, control bool) {

+func getControlKeys(controlState uint32) (shift, alt, control bool) {

 	shift = 0 != (controlState & winterm.SHIFT_PRESSED)

 	alt = 0 != (controlState & (winterm.LEFT_ALT_PRESSED | winterm.RIGHT_ALT_PRESSED))

 	control = 0 != (controlState & (winterm.LEFT_CTRL_PRESSED | winterm.RIGHT_CTRL_PRESSED))

@@ -124,32 +124,32 @@ func getByteRange(start byte, end byte) []byte {

 	return bytes

 }

-var ToGroundBytes = getToGroundBytes()

-var Executors = getExecuteBytes()

+var toGroundBytes = getToGroundBytes()

+var executors = getExecuteBytes()

 // SPACE		  20+A0 hex  Always and everywhere a blank space

 // Intermediate	  20-2F hex   !"#$%&'()*+,-./

-var Intermeds = getByteRange(0x20, 0x2F)

+var intermeds = getByteRange(0x20, 0x2F)

 // Parameters	  30-3F hex  0123456789:;<=>?

 // CSI Parameters 30-39, 3B hex 0123456789;

-var CsiParams = getByteRange(0x30, 0x3F)

+var csiParams = getByteRange(0x30, 0x3F)

-var CsiCollectables = append(getByteRange(0x30, 0x39), getByteRange(0x3B, 0x3F)...)

+var csiCollectables = append(getByteRange(0x30, 0x39), getByteRange(0x3B, 0x3F)...)

 // Uppercase	  40-5F hex  @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_

-var UpperCase = getByteRange(0x40, 0x5F)

+var upperCase = getByteRange(0x40, 0x5F)

 // Lowercase	  60-7E hex  `abcdefghijlkmnopqrstuvwxyz{|}~

-var LowerCase = getByteRange(0x60, 0x7E)

+var lowerCase = getByteRange(0x60, 0x7E)

 // Alphabetics	  40-7E hex  (all of upper and lower case)

-var Alphabetics = append(UpperCase, LowerCase...)

+var alphabetics = append(upperCase, lowerCase...)

-var Printables = getByteRange(0x20, 0x7F)

+var printables = getByteRange(0x20, 0x7F)

-var EscapeIntermediateToGroundBytes = getByteRange(0x30, 0x7E)

-var EscapeToGroundBytes = getEscapeToGroundBytes()

+var escapeIntermediateToGroundBytes = getByteRange(0x30, 0x7E)

+var escapeToGroundBytes = getEscapeToGroundBytes()

 // See http://www.vt100.net/emu/vt500_parser.png for description of the complex

 // byte ranges below

@@ -1,6 +1,6 @@

 package ansiterm

-type AnsiContext struct {

+type ansiContext struct {

 	currentChar byte

 	paramBuffer []byte

 	interBuffer []byte

@@ -1,41 +1,41 @@

 package ansiterm

-type CsiEntryState struct {

-	BaseState

+type csiEntryState struct {

+	baseState

 }

-func (csiState CsiEntryState) Handle(b byte) (s State, e error) {

+func (csiState csiEntryState) Handle(b byte) (s state, e error) {

 	logger.Infof("CsiEntry::Handle %#x", b)

-	nextState, err := csiState.BaseState.Handle(b)

+	nextState, err := csiState.baseState.Handle(b)

 	if nextState != nil || err != nil {

 		return nextState, err

 	}

 	switch {

-	case sliceContains(Alphabetics, b):

-		return csiState.parser.Ground, nil

-	case sliceContains(CsiCollectables, b):

-		return csiState.parser.CsiParam, nil

-	case sliceContains(Executors, b):

+	case sliceContains(alphabetics, b):

+		return csiState.parser.ground, nil

+	case sliceContains(csiCollectables, b):

+		return csiState.parser.csiParam, nil

+	case sliceContains(executors, b):

 		return csiState, csiState.parser.execute()

 	}

 	return csiState, nil

 }

-func (csiState CsiEntryState) Transition(s State) error {

+func (csiState csiEntryState) Transition(s state) error {

 	logger.Infof("CsiEntry::Transition %s --> %s", csiState.Name(), s.Name())

-	csiState.BaseState.Transition(s)

+	csiState.baseState.Transition(s)

 	switch s {

-	case csiState.parser.Ground:

+	case csiState.parser.ground:

 		return csiState.parser.csiDispatch()

-	case csiState.parser.CsiParam:

+	case csiState.parser.csiParam:

 		switch {

-		case sliceContains(CsiParams, csiState.parser.context.currentChar):

+		case sliceContains(csiParams, csiState.parser.context.currentChar):

 			csiState.parser.collectParam()

-		case sliceContains(Intermeds, csiState.parser.context.currentChar):

+		case sliceContains(intermeds, csiState.parser.context.currentChar):

 			csiState.parser.collectInter()

 		}

 	}

@@ -43,7 +43,7 @@ func (csiState CsiEntryState) Transition(s State) error {

 	return nil

 }

-func (csiState CsiEntryState) Enter() error {

+func (csiState csiEntryState) Enter() error {

 	csiState.parser.clear()

 	return nil

 }

@@ -1,36 +1,36 @@

 package ansiterm

-type CsiParamState struct {

-	BaseState

+type csiParamState struct {

+	baseState

 }

-func (csiState CsiParamState) Handle(b byte) (s State, e error) {

+func (csiState csiParamState) Handle(b byte) (s state, e error) {

 	logger.Infof("CsiParam::Handle %#x", b)

-	nextState, err := csiState.BaseState.Handle(b)

+	nextState, err := csiState.baseState.Handle(b)

 	if nextState != nil || err != nil {

 		return nextState, err

 	}

 	switch {

-	case sliceContains(Alphabetics, b):

-		return csiState.parser.Ground, nil

-	case sliceContains(CsiCollectables, b):

+	case sliceContains(alphabetics, b):

+		return csiState.parser.ground, nil

+	case sliceContains(csiCollectables, b):

 		csiState.parser.collectParam()

 		return csiState, nil

-	case sliceContains(Executors, b):

+	case sliceContains(executors, b):

 		return csiState, csiState.parser.execute()

 	}

 	return csiState, nil

 }

-func (csiState CsiParamState) Transition(s State) error {

+func (csiState csiParamState) Transition(s state) error {

 	logger.Infof("CsiParam::Transition %s --> %s", csiState.Name(), s.Name())

-	csiState.BaseState.Transition(s)

+	csiState.baseState.Transition(s)

 	switch s {

-	case csiState.parser.Ground:

+	case csiState.parser.ground:

 		return csiState.parser.csiDispatch()

 	}

@@ -1,34 +1,34 @@

 package ansiterm

-type EscapeIntermediateState struct {

-	BaseState

+type escapeIntermediateState struct {

+	baseState

 }

-func (escState EscapeIntermediateState) Handle(b byte) (s State, e error) {

-	logger.Infof("EscapeIntermediateState::Handle %#x", b)

-	nextState, err := escState.BaseState.Handle(b)

+func (escState escapeIntermediateState) Handle(b byte) (s state, e error) {

+	logger.Infof("escapeIntermediateState::Handle %#x", b)

+	nextState, err := escState.baseState.Handle(b)

 	if nextState != nil || err != nil {

 		return nextState, err

 	}

 	switch {

-	case sliceContains(Intermeds, b):

+	case sliceContains(intermeds, b):

 		return escState, escState.parser.collectInter()

-	case sliceContains(Executors, b):

+	case sliceContains(executors, b):

 		return escState, escState.parser.execute()

-	case sliceContains(EscapeIntermediateToGroundBytes, b):

-		return escState.parser.Ground, nil

+	case sliceContains(escapeIntermediateToGroundBytes, b):

+		return escState.parser.ground, nil

 	}

 	return escState, nil

 }

-func (escState EscapeIntermediateState) Transition(s State) error {

-	logger.Infof("EscapeIntermediateState::Transition %s --> %s", escState.Name(), s.Name())

-	escState.BaseState.Transition(s)

+func (escState escapeIntermediateState) Transition(s state) error {

+	logger.Infof("escapeIntermediateState::Transition %s --> %s", escState.Name(), s.Name())

+	escState.baseState.Transition(s)

 	switch s {

-	case escState.parser.Ground:

+	case escState.parser.ground:

 		return escState.parser.escDispatch()

 	}

@@ -1,47 +1,47 @@

 package ansiterm

-type EscapeState struct {

-	BaseState

+type escapeState struct {

+	baseState

 }

-func (escState EscapeState) Handle(b byte) (s State, e error) {

-	logger.Infof("EscapeState::Handle %#x", b)

-	nextState, err := escState.BaseState.Handle(b)

+func (escState escapeState) Handle(b byte) (s state, e error) {

+	logger.Infof("escapeState::Handle %#x", b)

+	nextState, err := escState.baseState.Handle(b)

 	if nextState != nil || err != nil {

 		return nextState, err

 	}

 	switch {

 	case b == ANSI_ESCAPE_SECONDARY:

-		return escState.parser.CsiEntry, nil

+		return escState.parser.csiEntry, nil

 	case b == ANSI_OSC_STRING_ENTRY:

-		return escState.parser.OscString, nil

-	case sliceContains(Executors, b):

+		return escState.parser.oscString, nil

+	case sliceContains(executors, b):

 		return escState, escState.parser.execute()

-	case sliceContains(EscapeToGroundBytes, b):

-		return escState.parser.Ground, nil

-	case sliceContains(Intermeds, b):

-		return escState.parser.EscapeIntermediate, nil

+	case sliceContains(escapeToGroundBytes, b):

+		return escState.parser.ground, nil

+	case sliceContains(intermeds, b):

+		return escState.parser.escapeIntermediate, nil

 	}

 	return escState, nil

 }

-func (escState EscapeState) Transition(s State) error {

+func (escState escapeState) Transition(s state) error {

 	logger.Infof("Escape::Transition %s --> %s", escState.Name(), s.Name())

-	escState.BaseState.Transition(s)

+	escState.baseState.Transition(s)

 	switch s {

-	case escState.parser.Ground:

+	case escState.parser.ground:

 		return escState.parser.escDispatch()

-	case escState.parser.EscapeIntermediate:

+	case escState.parser.escapeIntermediate:

 		return escState.parser.collectInter()

 	}

 	return nil

 }

-func (escState EscapeState) Enter() error {

+func (escState escapeState) Enter() error {

 	escState.parser.clear()

 	return nil

 }

@@ -1,22 +1,22 @@

 package ansiterm

-type GroundState struct {

-	BaseState

+type groundState struct {

+	baseState

 }

-func (gs GroundState) Handle(b byte) (s State, e error) {

+func (gs groundState) Handle(b byte) (s state, e error) {

 	gs.parser.context.currentChar = b

-	nextState, err := gs.BaseState.Handle(b)

+	nextState, err := gs.baseState.Handle(b)

 	if nextState != nil || err != nil {

 		return nextState, err

 	}

 	switch {

-	case sliceContains(Printables, b):

+	case sliceContains(printables, b):

 		return gs, gs.parser.print()

-	case sliceContains(Executors, b):

+	case sliceContains(executors, b):

 		return gs, gs.parser.execute()

 	}

@@ -1,19 +1,19 @@

 package ansiterm

-type OscStringState struct {

-	BaseState

+type oscStringState struct {

+	baseState

 }

-func (oscState OscStringState) Handle(b byte) (s State, e error) {

+func (oscState oscStringState) Handle(b byte) (s state, e error) {

 	logger.Infof("OscString::Handle %#x", b)

-	nextState, err := oscState.BaseState.Handle(b)

+	nextState, err := oscState.baseState.Handle(b)

 	if nextState != nil || err != nil {

 		return nextState, err

 	}

 	switch {

 	case isOscStringTerminator(b):

-		return oscState.parser.Ground, nil

+		return oscState.parser.ground, nil

 	}

 	return oscState, nil

@@ -2,7 +2,6 @@ package ansiterm

 import (

 	"errors"

-	"fmt"

 	"io/ioutil"

 	"os"

@@ -12,18 +11,18 @@ import (

 var logger *logrus.Logger

 type AnsiParser struct {

-	currState          State

+	currState          state

 	eventHandler       AnsiEventHandler

-	context            *AnsiContext

-	CsiEntry           State

-	CsiParam           State

-	DcsEntry           State

-	Escape             State

-	EscapeIntermediate State

-	Error              State

-	Ground             State

-	OscString          State

-	stateMap           []State

+	context            *ansiContext

+	csiEntry           state

+	csiParam           state

+	dcsEntry           state

+	escape             state

+	escapeIntermediate state

+	error              state

+	ground             state

+	oscString          state

+	stateMap           []state

 }

 func CreateParser(initialState string, evtHandler AnsiEventHandler) *AnsiParser {

@@ -41,27 +40,27 @@ func CreateParser(initialState string, evtHandler AnsiEventHandler) *AnsiParser

 	parser := &AnsiParser{

 		eventHandler: evtHandler,

-		context:      &AnsiContext{},

+		context:      &ansiContext{},

 	}

-	parser.CsiEntry = CsiEntryState{BaseState{name: "CsiEntry", parser: parser}}

-	parser.CsiParam = CsiParamState{BaseState{name: "CsiParam", parser: parser}}

-	parser.DcsEntry = DcsEntryState{BaseState{name: "DcsEntry", parser: parser}}

-	parser.Escape = EscapeState{BaseState{name: "Escape", parser: parser}}

-	parser.EscapeIntermediate = EscapeIntermediateState{BaseState{name: "EscapeIntermediate", parser: parser}}

-	parser.Error = ErrorState{BaseState{name: "Error", parser: parser}}

-	parser.Ground = GroundState{BaseState{name: "Ground", parser: parser}}

-	parser.OscString = OscStringState{BaseState{name: "OscString", parser: parser}}

-

-	parser.stateMap = []State{

-		parser.CsiEntry,

-		parser.CsiParam,

-		parser.DcsEntry,

-		parser.Escape,

-		parser.EscapeIntermediate,

-		parser.Error,

-		parser.Ground,

-		parser.OscString,

+	parser.csiEntry = csiEntryState{baseState{name: "CsiEntry", parser: parser}}

+	parser.csiParam = csiParamState{baseState{name: "CsiParam", parser: parser}}

+	parser.dcsEntry = dcsEntryState{baseState{name: "DcsEntry", parser: parser}}

+	parser.escape = escapeState{baseState{name: "Escape", parser: parser}}

+	parser.escapeIntermediate = escapeIntermediateState{baseState{name: "EscapeIntermediate", parser: parser}}

+	parser.error = errorState{baseState{name: "Error", parser: parser}}

+	parser.ground = groundState{baseState{name: "Ground", parser: parser}}

+	parser.oscString = oscStringState{baseState{name: "OscString", parser: parser}}

+

+	parser.stateMap = []state{

+		parser.csiEntry,

+		parser.csiParam,

+		parser.dcsEntry,

+		parser.escape,

+		parser.escapeIntermediate,

+		parser.error,

+		parser.ground,

+		parser.oscString,

 	}

 	parser.currState = getState(initialState, parser.stateMap)

@@ -70,7 +69,7 @@ func CreateParser(initialState string, evtHandler AnsiEventHandler) *AnsiParser

 	return parser

 }

-func getState(name string, states []State) State {

+func getState(name string, states []state) state {

 	for _, el := range states {

 		if el.Name() == name {

 			return el

@@ -99,7 +98,7 @@ func (ap *AnsiParser) handle(b byte) error {

 	if newState == nil {

 		logger.Warning("newState is nil")

-		return errors.New(fmt.Sprintf("New state of 'nil' is invalid."))

+		return errors.New("New state of 'nil' is invalid.")

 	}

 	if newState != ap.currState {

@@ -111,7 +110,7 @@ func (ap *AnsiParser) handle(b byte) error {

 	return nil

 }

-func (ap *AnsiParser) changeState(newState State) error {

+func (ap *AnsiParser) changeState(newState state) error {

 	logger.Infof("ChangeState %s --> %s", ap.currState.Name(), newState.Name())

 	// Exit old state

@@ -31,7 +31,7 @@ func parseParams(bytes []byte) ([]string, error) {

 	return params, nil

 }

-func parseCmd(context AnsiContext) (string, error) {

+func parseCmd(context ansiContext) (string, error) {

 	return string(context.currentChar), nil

 }

@@ -113,7 +113,7 @@ func (ap *AnsiParser) print() error {

 }

 func (ap *AnsiParser) clear() error {

-	ap.context = &AnsiContext{}

+	ap.context = &ansiContext{}

 	return nil

 }

deleted file mode 100644

@@ -1,114 +0,0 @@

-package ansiterm

-

-import (

-	"fmt"

-	"testing"

-)

-

-func getStateNames() []string {

-	parser, _ := createTestParser("Ground")

-

-	stateNames := []string{}

-	for _, state := range parser.stateMap {

-		stateNames = append(stateNames, state.Name())

-	}

-

-	return stateNames

-}

-

-func stateTransitionHelper(t *testing.T, start string, end string, bytes []byte) {

-	for _, b := range bytes {

-		bytes := []byte{byte(b)}

-		parser, _ := createTestParser(start)

-		parser.Parse(bytes)

-		validateState(t, parser.currState, end)

-	}

-}

-

-func anyToXHelper(t *testing.T, bytes []byte, expectedState string) {

-	for _, s := range getStateNames() {

-		stateTransitionHelper(t, s, expectedState, bytes)

-	}

-}

-

-func funcCallParamHelper(t *testing.T, bytes []byte, start string, expected string, expectedCalls []string) {

-	parser, evtHandler := createTestParser(start)

-	parser.Parse(bytes)

-	validateState(t, parser.currState, expected)

-	validateFuncCalls(t, evtHandler.FunctionCalls, expectedCalls)

-}

-

-func parseParamsHelper(t *testing.T, bytes []byte, expectedParams []string) {

-	params, err := parseParams(bytes)

-

-	if err != nil {

-		t.Errorf("Parameter parse error: %v", err)

-		return

-	}

-

-	if len(params) != len(expectedParams) {

-		t.Errorf("Parsed   parameters: %v", params)

-		t.Errorf("Expected parameters: %v", expectedParams)

-		t.Errorf("Parameter length failure: %d != %d", len(params), len(expectedParams))

-		return

-	}

-

-	for i, v := range expectedParams {

-		if v != params[i] {

-			t.Errorf("Parsed   parameters: %v", params)

-			t.Errorf("Expected parameters: %v", expectedParams)

-			t.Errorf("Parameter parse failure: %s != %s at position %d", v, params[i], i)

-		}

-	}

-}

-

-func cursorSingleParamHelper(t *testing.T, command byte, funcName string) {

-	funcCallParamHelper(t, []byte{command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([1])", funcName)})

-	funcCallParamHelper(t, []byte{'0', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([1])", funcName)})

-	funcCallParamHelper(t, []byte{'2', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([2])", funcName)})

-	funcCallParamHelper(t, []byte{'2', '3', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([23])", funcName)})

-	funcCallParamHelper(t, []byte{'2', ';', '3', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([2])", funcName)})

-	funcCallParamHelper(t, []byte{'2', ';', '3', ';', '4', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([2])", funcName)})

-}

-

-func cursorTwoParamHelper(t *testing.T, command byte, funcName string) {

-	funcCallParamHelper(t, []byte{command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([1 1])", funcName)})

-	funcCallParamHelper(t, []byte{'0', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([1 1])", funcName)})

-	funcCallParamHelper(t, []byte{'2', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([2 1])", funcName)})

-	funcCallParamHelper(t, []byte{'2', '3', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([23 1])", funcName)})

-	funcCallParamHelper(t, []byte{'2', ';', '3', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([2 3])", funcName)})

-	funcCallParamHelper(t, []byte{'2', ';', '3', ';', '4', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([2 3])", funcName)})

-}

-

-func eraseHelper(t *testing.T, command byte, funcName string) {

-	funcCallParamHelper(t, []byte{command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([0])", funcName)})

-	funcCallParamHelper(t, []byte{'0', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([0])", funcName)})

-	funcCallParamHelper(t, []byte{'1', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([1])", funcName)})

-	funcCallParamHelper(t, []byte{'2', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([2])", funcName)})

-	funcCallParamHelper(t, []byte{'3', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([3])", funcName)})

-	funcCallParamHelper(t, []byte{'4', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([0])", funcName)})

-	funcCallParamHelper(t, []byte{'1', ';', '2', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([1])", funcName)})

-}

-

-func scrollHelper(t *testing.T, command byte, funcName string) {

-	funcCallParamHelper(t, []byte{command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([1])", funcName)})

-	funcCallParamHelper(t, []byte{'0', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([1])", funcName)})

-	funcCallParamHelper(t, []byte{'1', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([1])", funcName)})

-	funcCallParamHelper(t, []byte{'5', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([5])", funcName)})

-	funcCallParamHelper(t, []byte{'4', ';', '6', command}, "CsiEntry", "Ground", []string{fmt.Sprintf("%s([4])", funcName)})

-}

-

-func clearOnStateChangeHelper(t *testing.T, start string, end string, bytes []byte) {

-	p, _ := createTestParser(start)

-	fillContext(p.context)

-	p.Parse(bytes)

-	validateState(t, p.currState, end)

-	validateEmptyContext(t, p.context)

-}

-

-func c0Helper(t *testing.T, bytes []byte, expectedState string, expectedCalls []string) {

-	parser, evtHandler := createTestParser("Ground")

-	parser.Parse(bytes)

-	validateState(t, parser.currState, expectedState)

-	validateFuncCalls(t, evtHandler.FunctionCalls, expectedCalls)

-}

deleted file mode 100644

@@ -1,66 +0,0 @@

-package ansiterm

-

-import (

-	"testing"

-)

-

-func createTestParser(s string) (*AnsiParser, *TestAnsiEventHandler) {

-	evtHandler := CreateTestAnsiEventHandler()

-	parser := CreateParser(s, evtHandler)

-

-	return parser, evtHandler

-}

-

-func validateState(t *testing.T, actualState State, expectedStateName string) {

-	actualName := "Nil"

-

-	if actualState != nil {

-		actualName = actualState.Name()

-	}

-

-	if actualName != expectedStateName {

-		t.Errorf("Invalid State: '%s' != '%s'", actualName, expectedStateName)

-	}

-}

-

-func validateFuncCalls(t *testing.T, actualCalls []string, expectedCalls []string) {

-	actualCount := len(actualCalls)

-	expectedCount := len(expectedCalls)

-

-	if actualCount != expectedCount {

-		t.Errorf("Actual   calls: %v", actualCalls)

-		t.Errorf("Expected calls: %v", expectedCalls)

-		t.Errorf("Call count error: %d != %d", actualCount, expectedCount)

-		return

-	}

-

-	for i, v := range actualCalls {

-		if v != expectedCalls[i] {

-			t.Errorf("Actual   calls: %v", actualCalls)

-			t.Errorf("Expected calls: %v", expectedCalls)

-			t.Errorf("Mismatched calls: %s != %s with lengths %d and %d", v, expectedCalls[i], len(v), len(expectedCalls[i]))

-		}

-	}

-}

-

-func fillContext(context *AnsiContext) {

-	context.currentChar = 'A'

-	context.paramBuffer = []byte{'C', 'D', 'E'}

-	context.interBuffer = []byte{'F', 'G', 'H'}

-}

-

-func validateEmptyContext(t *testing.T, context *AnsiContext) {

-	var expectedCurrChar byte = 0x0

-	if context.currentChar != expectedCurrChar {

-		t.Errorf("Currentchar mismatch '%#x' != '%#x'", context.currentChar, expectedCurrChar)

-	}

-

-	if len(context.paramBuffer) != 0 {

-		t.Errorf("Non-empty parameter buffer: %v", context.paramBuffer)

-	}

-

-	if len(context.paramBuffer) != 0 {

-		t.Errorf("Non-empty intermediate buffer: %v", context.interBuffer)

-	}

-

-}

@@ -1,52 +1,52 @@

 package ansiterm

-type StateId int

+type stateID int

-type State interface {

+type state interface {

 	Enter() error

 	Exit() error

-	Handle(byte) (State, error)

+	Handle(byte) (state, error)

 	Name() string

-	Transition(State) error

+	Transition(state) error

 }

-type BaseState struct {

+type baseState struct {

 	name   string

 	parser *AnsiParser

 }

-func (base BaseState) Enter() error {

+func (base baseState) Enter() error {

 	return nil

 }

-func (base BaseState) Exit() error {

+func (base baseState) Exit() error {

 	return nil

 }

-func (base BaseState) Handle(b byte) (s State, e error) {

+func (base baseState) Handle(b byte) (s state, e error) {

 	switch {

 	case b == CSI_ENTRY:

-		return base.parser.CsiEntry, nil

+		return base.parser.csiEntry, nil

 	case b == DCS_ENTRY:

-		return base.parser.DcsEntry, nil

+		return base.parser.dcsEntry, nil

 	case b == ANSI_ESCAPE_PRIMARY:

-		return base.parser.Escape, nil

+		return base.parser.escape, nil

 	case b == OSC_STRING:

-		return base.parser.OscString, nil

-	case sliceContains(ToGroundBytes, b):

-		return base.parser.Ground, nil

+		return base.parser.oscString, nil

+	case sliceContains(toGroundBytes, b):

+		return base.parser.ground, nil

 	}

 	return nil, nil

 }

-func (base BaseState) Name() string {

+func (base baseState) Name() string {

 	return base.name

 }

-func (base BaseState) Transition(s State) error {

-	if s == base.parser.Ground {

+func (base baseState) Transition(s state) error {

+	if s == base.parser.ground {

 		execBytes := []byte{0x18}

 		execBytes = append(execBytes, 0x1A)

 		execBytes = append(execBytes, getByteRange(0x80, 0x8F)...)

@@ -62,10 +62,10 @@ func (base BaseState) Transition(s State) error {

 	return nil

 }

-type DcsEntryState struct {

-	BaseState

+type dcsEntryState struct {

+	baseState

 }

-type ErrorState struct {

-	BaseState

+type errorState struct {

+	baseState

 }

deleted file mode 100644

@@ -1,173 +0,0 @@

-package ansiterm

-

-import (

-	"fmt"

-	"strconv"

-)

-

-type TestAnsiEventHandler struct {

-	FunctionCalls []string

-}

-

-func CreateTestAnsiEventHandler() *TestAnsiEventHandler {

-	evtHandler := TestAnsiEventHandler{}

-	evtHandler.FunctionCalls = make([]string, 0)

-	return &evtHandler

-}

-

-func (h *TestAnsiEventHandler) recordCall(call string, params []string) {

-	s := fmt.Sprintf("%s(%v)", call, params)

-	h.FunctionCalls = append(h.FunctionCalls, s)

-}

-

-func (h *TestAnsiEventHandler) Print(b byte) error {

-	h.recordCall("Print", []string{string(b)})

-	return nil

-}

-

-func (h *TestAnsiEventHandler) Execute(b byte) error {

-	h.recordCall("Execute", []string{string(b)})

-	return nil

-}

-

-func (h *TestAnsiEventHandler) CUU(param int) error {

-	h.recordCall("CUU", []string{strconv.Itoa(param)})

-	return nil

-}

-

-func (h *TestAnsiEventHandler) CUD(param int) error {

-	h.recordCall("CUD", []string{strconv.Itoa(param)})

-	return nil

-}

-

-func (h *TestAnsiEventHandler) CUF(param int) error {

-	h.recordCall("CUF", []string{strconv.Itoa(param)})

-	return nil

-}

-

-func (h *TestAnsiEventHandler) CUB(param int) error {

-	h.recordCall("CUB", []string{strconv.Itoa(param)})

-	return nil

-}

-

-func (h *TestAnsiEventHandler) CNL(param int) error {

-	h.recordCall("CNL", []string{strconv.Itoa(param)})

-	return nil

-}

-

-func (h *TestAnsiEventHandler) CPL(param int) error {

-	h.recordCall("CPL", []string{strconv.Itoa(param)})

-	return nil

-}

-

-func (h *TestAnsiEventHandler) CHA(param int) error {

-	h.recordCall("CHA", []string{strconv.Itoa(param)})

-	return nil

-}

-

-func (h *TestAnsiEventHandler) VPA(param int) error {

-	h.recordCall("VPA", []string{strconv.Itoa(param)})

-	return nil

-}

-

-func (h *TestAnsiEventHandler) CUP(x int, y int) error {

-	xS, yS := strconv.Itoa(x), strconv.Itoa(y)

-	h.recordCall("CUP", []string{xS, yS})

-	return nil

-}

-

-func (h *TestAnsiEventHandler) HVP(x int, y int) error {

-	xS, yS := strconv.Itoa(x), strconv.Itoa(y)

-	h.recordCall("HVP", []string{xS, yS})