github.com/mitchellh/packer@v1.3.2/common/bootcommand/pc_xt_driver_test.go (about)

     1  package bootcommand
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  func Test_chunkScanCodes(t *testing.T) {
    12  
    13  	var chunktests = []struct {
    14  		size int
    15  		in   [][]string
    16  		out  [][]string
    17  	}{
    18  		{
    19  			3,
    20  			[][]string{
    21  				{"a", "b"},
    22  				{"c"},
    23  				{"d"},
    24  				{"e", "f"},
    25  				{"g", "h"},
    26  				{"i", "j"},
    27  				{"k"},
    28  				{"l", "m"},
    29  			},
    30  			[][]string{
    31  				{"a", "b", "c"},
    32  				{"d", "e", "f"},
    33  				{"g", "h"},
    34  				{"i", "j", "k"},
    35  				{"l", "m"},
    36  			},
    37  		},
    38  		{
    39  			-1,
    40  			[][]string{
    41  				{"a", "b"},
    42  				{"c"},
    43  				{"d"},
    44  				{"e", "f"},
    45  				{"g", "h"},
    46  				{"i", "j"},
    47  				{"k"},
    48  				{"l", "m"},
    49  			},
    50  			[][]string{
    51  				{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
    52  			},
    53  		},
    54  	}
    55  
    56  	for _, tt := range chunktests {
    57  		out, err := chunkScanCodes(tt.in, tt.size)
    58  		assert.NoError(t, err)
    59  		assert.Equalf(t, tt.out, out, "expecting chunks of %d.", tt.size)
    60  	}
    61  }
    62  
    63  func Test_chunkScanCodeError(t *testing.T) {
    64  	// can't go from wider to thinner
    65  	in := [][]string{
    66  		{"a", "b", "c"},
    67  		{"d", "e", "f"},
    68  		{"g", "h"},
    69  	}
    70  
    71  	_, err := chunkScanCodes(in, 2)
    72  	assert.Error(t, err)
    73  }
    74  
    75  func Test_pcxtSpecialOnOff(t *testing.T) {
    76  	in := "<rightShift><rightshiftoff><RIGHTSHIFTON>"
    77  	expected := []string{"36", "b6", "b6", "36"}
    78  	var codes []string
    79  	sendCodes := func(c []string) error {
    80  		codes = c
    81  		return nil
    82  	}
    83  	d := NewPCXTDriver(sendCodes, -1, time.Duration(0))
    84  	seq, err := GenerateExpressionSequence(in)
    85  	assert.NoError(t, err)
    86  	err = seq.Do(context.Background(), d)
    87  	assert.NoError(t, err)
    88  	assert.Equal(t, expected, codes)
    89  }
    90  
    91  func Test_pcxtSpecial(t *testing.T) {
    92  	in := "<left>"
    93  	expected := []string{"e0", "4b", "e0", "cb"}
    94  	var codes []string
    95  	sendCodes := func(c []string) error {
    96  		codes = c
    97  		return nil
    98  	}
    99  	d := NewPCXTDriver(sendCodes, -1, time.Duration(0))
   100  	seq, err := GenerateExpressionSequence(in)
   101  	assert.NoError(t, err)
   102  	err = seq.Do(context.Background(), d)
   103  	assert.NoError(t, err)
   104  	assert.Equal(t, expected, codes)
   105  }
   106  
   107  func Test_flushes(t *testing.T) {
   108  	in := "abc123<wait>098"
   109  	expected := [][]string{
   110  		{"1e", "9e", "30", "b0", "2e", "ae", "02", "82", "03", "83", "04", "84"},
   111  		{"0b", "8b", "0a", "8a", "09", "89"},
   112  	}
   113  	var actual [][]string
   114  	sendCodes := func(c []string) error {
   115  		actual = append(actual, c)
   116  		return nil
   117  	}
   118  	d := NewPCXTDriver(sendCodes, -1, time.Duration(0))
   119  	seq, err := GenerateExpressionSequence(in)
   120  	assert.NoError(t, err)
   121  	err = seq.Do(context.Background(), d)
   122  	assert.NoError(t, err)
   123  	assert.Equal(t, expected, actual)
   124  }
   125  
   126  func Test_KeyIntervalNotGiven(t *testing.T) {
   127  	d := NewPCXTDriver(nil, -1, time.Duration(0))
   128  	assert.Equal(t, d.interval, time.Duration(100)*time.Millisecond)
   129  }
   130  
   131  func Test_KeyIntervalGiven(t *testing.T) {
   132  	d := NewPCXTDriver(nil, -1, time.Duration(5000)*time.Millisecond)
   133  	assert.Equal(t, d.interval, time.Duration(5000)*time.Millisecond)
   134  }