tools/femu-control/main_test.go - fuchsia - Git at Google

 // Copyright 2020 The Fuchsia 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 main

 import (
 	"context"
 	"encoding/base64"
 	"flag"
 	"fmt"
 	"math/rand"
 	"os"
 	"path"
 	"reflect"
 	"strings"
 	"testing"
 	"time"

 	fg "go.fuchsia.dev/fuchsia/tools/femu-control/femu-grpc"
 )

 type keyEvent struct {
 	evType string
 	keySeq []string
 }

 type fakeFemuGrpcClient struct {
 	keyEvents []keyEvent
 }

 func (f *fakeFemuGrpcClient) StreamScreen(opts fg.StreamScreenOpts) (fg.Frames, error) {
 	numFrames := opts.NumFrames
 	if numFrames == 0 || numFrames > 10 {
 		numFrames = 10
 	}

 	frames := fg.Frames{}
 	frames.Width = 1
 	frames.Height = 1

 	const png1x1Base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQYV2PwUSn4DwADgAHgUix5GgAAAABJRU5ErkJggg=="
 	pngBytes, _ := base64.StdEncoding.DecodeString(png1x1Base64)
 	for i := uint(0); i < numFrames; i++ {
 		frames.Images = append(frames.Images, pngBytes)
 	}

 	return frames, nil
 }

 func (f *fakeFemuGrpcClient) StreamAudio(opts fg.StreamAudioOpts) (fg.AudioPayload, error) {
 	audio := fg.AudioPayload{}

 	byteSize := uint(opts.Duration.Milliseconds()) * opts.Format.SamplingRate / 1000 * opts.Format.BitsPerSample / 8
 	if opts.Format.Channels == "STEREO" {
 		byteSize = byteSize * 2
 	}

 	audio.Bytes = make([]byte, byteSize)
 	audio.LengthMs = uint(opts.Duration.Milliseconds())
 	return audio, nil
 }

 func (f *fakeFemuGrpcClient) KeyDown(seq []string) error {
 	f.keyEvents = append(f.keyEvents, keyEvent{
 		evType: "DOWN",
 		keySeq: seq,
 	})
 	return nil
 }

 func (f *fakeFemuGrpcClient) KeyUp(seq []string) error {
 	f.keyEvents = append(f.keyEvents, keyEvent{
 		evType: "UP",
 		keySeq: seq,
 	})
 	return nil
 }

 func (f *fakeFemuGrpcClient) KeyPress(seq []string) error {
 	f.keyEvents = append(f.keyEvents, keyEvent{
 		evType: "PRESS",
 		keySeq: seq,
 	})
 	return nil
 }

 func TestStreamScreen(t *testing.T) {
 	client := fakeFemuGrpcClient{}
 	ctx := context.WithValue(context.Background(), "client", &client)

 	var seededRand *rand.Rand = rand.New(
 		rand.NewSource(time.Now().UnixNano()))
 	tmpDir := fmt.Sprintf("/tmp/femu%v", seededRand.Int())

 	testCases := []struct {
 		name           string
 		flags          string
 		expectedStatus string
 		expectedError  string
 		setup          func()
 		cleanup        func()
 	}{
 		{
 			name:           "num-frames and duration both missing",
 			flags:          fmt.Sprintf("-out %v/screen%%.png", tmpDir),
 			expectedStatus: "usage error",
 			expectedError:  "-num-frames and -duration cannot be both zero",
 		},
 		{
 			name:           "path is not directory",
 			flags:          fmt.Sprintf("-duration 1s -out %v/file/screen%%.png", tmpDir),
 			expectedStatus: "usage error",
 			expectedError:  fmt.Sprintf("path %v/file/ invalid: stat %v/file/: not a directory", tmpDir, tmpDir),
 			setup: func() {
 				os.MkdirAll(tmpDir, 0755)
 				os.Create(path.Join(tmpDir, "file"))
 			},
 			cleanup: func() {
 				os.Remove(path.Join(tmpDir, "file"))
 			},
 		},
 		{
 			name:           "filename not containing extension",
 			flags:          fmt.Sprintf("-duration 1s -out %v/screen%%", tmpDir),
 			expectedStatus: "usage error",
 			expectedError:  "filename 'screen%' doesn't contain any extension!",
 		},
 		{
 			name:           "filename not containing %",
 			flags:          fmt.Sprintf("-duration 1s -out %v/screen.jpg", tmpDir),
 			expectedStatus: "success",
 		},
 		{
 			name:           "unsupported extension",
 			flags:          fmt.Sprintf("-duration 1s -out %v/screen%%.wav", tmpDir),
 			expectedStatus: "usage error",
 			expectedError:  "filename 'screen%.wav' has unsupported extension: .wav. supported extensions are jpeg, jpg, gif, and png.",
 		},
 		{
 			name:           "valid usage: jpg",
 			flags:          fmt.Sprintf("-duration 1s -out %v/screen%%.jpg", tmpDir),
 			expectedStatus: "success",
 			cleanup:        func() { os.RemoveAll(tmpDir) },
 		},
 		{
 			name:           "valid usage: png",
 			flags:          fmt.Sprintf("-duration 1s -out %v/screen%%.png", tmpDir),
 			expectedStatus: "success",
 			cleanup:        func() { os.RemoveAll(tmpDir) },
 		},
 		{
 			name:           "valid usage: gif",
 			flags:          fmt.Sprintf("-duration 1s -out %v/screen.gif", tmpDir),
 			expectedStatus: "success",
 			cleanup:        func() { os.RemoveAll(tmpDir) },
 		},
 	}

 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			if tc.setup != nil {
 				tc.setup()
 			}
 			if tc.cleanup != nil {
 				defer tc.cleanup()
 			}

 			cmd := recordScreenCmd{}

 			f := flag.NewFlagSet("", flag.ContinueOnError)
 			cmd.SetFlags(f)

 			err := f.Parse(strings.Split(tc.flags, " "))
 			if err != nil {
 				t.Errorf("parse flags failed: %v", err)
 				return
 			}

 			err = cmd.ValidateArgs()
 			switch {
 			case err == nil && tc.expectedStatus == "usage error":
 				t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
 			case err != nil && tc.expectedStatus == "usage error" && tc.expectedError != err.Error():
 				t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
 				return
 			case err != nil && tc.expectedStatus != "usage error":
 				t.Errorf("expected: %v actual (usage error): %v", tc.expectedStatus, err)
 				return
 			case err != nil:
 				return
 			}

 			err = cmd.run(ctx)
 			if tc.expectedStatus == "failure" {
 				if err == nil || err.Error() != tc.expectedError {
 					t.Errorf("expected: %v actual: %v", tc.expectedError, err)
 				}
 			}

 			if tc.expectedStatus == "success" {
 				if err != nil {
 					t.Errorf("expected: success actual: %v", err)
 				}
 			}
 		})
 	}
 }

 func TestStreamAudio(t *testing.T) {
 	client := fakeFemuGrpcClient{}
 	ctx := context.WithValue(context.Background(), "client", &client)

 	var seededRand *rand.Rand = rand.New(
 		rand.NewSource(time.Now().UnixNano()))
 	tmpDir := fmt.Sprintf("/tmp/femu%v", seededRand.Int())

 	testCases := []struct {
 		name           string
 		flags          string
 		expectedStatus string
 		expectedError  string
 		setup          func()
 		cleanup        func()
 	}{
 		{
 			name:           "-duration missing",
 			flags:          fmt.Sprintf("-out %v/audio.wav", tmpDir),
 			expectedStatus: "usage error",
 			expectedError:  "-duration cannot be zero",
 		},
 		{
 			name:           "path is not directory",
 			flags:          fmt.Sprintf("-duration 1s -out %v/file/audio.wav", tmpDir),
 			expectedStatus: "usage error",
 			expectedError:  fmt.Sprintf("path %v/file/ invalid: stat %v/file/: not a directory", tmpDir, tmpDir),
 			setup: func() {
 				os.MkdirAll(tmpDir, 0755)
 				os.Create(path.Join(tmpDir, "file"))
 			},
 			cleanup: func() {
 				os.Remove(path.Join(tmpDir, "file"))
 			},
 		},
 		{
 			name:           "invalid args: channels",
 			flags:          fmt.Sprintf("-duration 1s -out %v/audio.wav -channels SURROUND", tmpDir),
 			expectedStatus: "usage error",
 			expectedError:  "unsupported channel format: SURROUND",
 		},
 		{
 			name:           "invalid args: bit depth",
 			flags:          fmt.Sprintf("-duration 1s -out %v/audio.wav -bit-depth 32", tmpDir),
 			expectedStatus: "usage error",
 			expectedError:  "unsupported number of bits per sample: 32",
 		},
 		{
 			name:           "invalid args: sampling rate",
 			flags:          fmt.Sprintf("-duration 1s -out %v/audio.wav -sampling-rate 0", tmpDir),
 			expectedStatus: "usage error",
 			expectedError:  "invalid sampling rate: 0",
 		},
 		{
 			name:           "valid usage",
 			flags:          fmt.Sprintf("-duration 1s -out %v/screen.wav", tmpDir),
 			expectedStatus: "success",
 			cleanup:        func() { os.RemoveAll(tmpDir) },
 		},
 	}

 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			if tc.setup != nil {
 				tc.setup()
 			}
 			if tc.cleanup != nil {
 				defer tc.cleanup()
 			}

 			cmd := recordAudioCmd{}

 			f := flag.NewFlagSet("", flag.ContinueOnError)
 			cmd.SetFlags(f)

 			err := f.Parse(strings.Split(tc.flags, " "))
 			if err != nil {
 				t.Errorf("parse flags failed: %v", err)
 				return
 			}

 			err = cmd.ValidateArgs()
 			switch {
 			case err == nil && tc.expectedStatus == "usage error":
 				t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
 			case err != nil && tc.expectedStatus == "usage error" && tc.expectedError != err.Error():
 				t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
 				return
 			case err != nil && tc.expectedStatus != "usage error":
 				t.Errorf("expected: %v actual (usage error): %v", tc.expectedStatus, err)
 				return
 			case err != nil:
 				return
 			}

 			err = cmd.run(ctx)
 			if tc.expectedStatus == "failure" {
 				if err == nil || err.Error() != tc.expectedError {
 					t.Errorf("expected: %v actual: %v", tc.expectedError, err)
 				}
 			}

 			if tc.expectedStatus == "success" {
 				if err != nil {
 					t.Errorf("expected: success actual: %v", err)
 				}
 			}
 		})
 	}
 }

 func TestKeyboard(t *testing.T) {
 	client := fakeFemuGrpcClient{}
 	ctx := context.WithValue(context.Background(), "client", &client)

 	testCases := []struct {
 		name           string
 		flags          string
 		expectedStatus string
 		expectedError  string
 		setup          func()
 		cleanup        func()
 	}{
 		{
 			name:           "invalid type",
 			flags:          "-event OTHER Ctrl+Alt+A",
 			expectedStatus: "usage error",
 			expectedError:  "unknown event type: OTHER",
 		},
 		{
 			name:           "key sequence missing",
 			flags:          "-event PRESS",
 			expectedStatus: "usage error",
 			expectedError:  "key sequence missing",
 		},
 		{
 			name:           "key down",
 			flags:          "-event DOWN Control+Alt+A",
 			expectedStatus: "success",
 			expectedError:  "",
 			cleanup: func() {
 				if len(client.keyEvents) == 0 {
 					t.Fatalf("client.keyEvents is empty")
 				}
 				event := client.keyEvents[len(client.keyEvents)-1]
 				if event.evType != "DOWN" {
 					t.Errorf("incorrect event.evType: expected: %v actual: %v", "DOWN", event.evType)
 				}

 				expectedKeySeq := []string{"Control", "Alt", "A"}
 				if !reflect.DeepEqual(event.keySeq, expectedKeySeq) {
 					t.Errorf("incorrect event.keySeq: expected: %v actual: %v", expectedKeySeq, event.keySeq)
 				}
 			},
 		},
 		{
 			name:           "key up",
 			flags:          "-event UP Alt+Shift+3",
 			expectedStatus: "success",
 			expectedError:  "",
 			cleanup: func() {
 				if len(client.keyEvents) == 0 {
 					t.Fatalf("client.keyEvents is empty")
 				}
 				event := client.keyEvents[len(client.keyEvents)-1]
 				if event.evType != "UP" {
 					t.Errorf("incorrect event.evType: expected: %v actual: %v", "UP", event.evType)
 				}

 				expectedKeySeq := []string{"Alt", "Shift", "3"}
 				if !reflect.DeepEqual(event.keySeq, expectedKeySeq) {
 					t.Errorf("incorrect event.keySeq: expected: %v actual: %v", expectedKeySeq, event.keySeq)
 				}
 			},
 		},
 		{
 			name:           "key press",
 			flags:          "-event PRESS Meta+Z",
 			expectedStatus: "success",
 			expectedError:  "",
 			cleanup: func() {
 				if len(client.keyEvents) == 0 {
 					t.Fatalf("client.keyEvents is empty")
 				}
 				event := client.keyEvents[len(client.keyEvents)-1]
 				if event.evType != "PRESS" {
 					t.Errorf("incorrect event.evType: expected: %v actual: %v", "PRESS", event.evType)
 				}

 				expectedKeySeq := []string{"Meta", "Z"}
 				if !reflect.DeepEqual(event.keySeq, expectedKeySeq) {
 					t.Errorf("incorrect event.keySeq: expected: %v actual: %v", expectedKeySeq, event.keySeq)
 				}
 			},
 		},
 	}

 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			if tc.setup != nil {
 				tc.setup()
 			}
 			if tc.cleanup != nil {
 				defer tc.cleanup()
 			}

 			cmd := keyboardCmd{}

 			f := flag.NewFlagSet("", flag.ContinueOnError)
 			cmd.SetFlags(f)

 			err := f.Parse(strings.Split(tc.flags, " "))
 			if err != nil {
 				t.Errorf("parse flags failed: %v", err)
 				return
 			}
 			if f.Arg(0) != "" {
 				cmd.keySequence = strings.Split(f.Arg(0), "+")
 			}

 			err = cmd.ValidateArgs()
 			switch {
 			case err == nil && tc.expectedStatus == "usage error":
 				t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
 			case err != nil && tc.expectedStatus == "usage error" && tc.expectedError != err.Error():
 				t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
 				return
 			case err != nil && tc.expectedStatus != "usage error":
 				t.Errorf("expected: %v actual (usage error): %v", tc.expectedStatus, err)
 				return
 			case err != nil:
 				return
 			}

 			err = cmd.run(ctx)
 			if tc.expectedStatus == "failure" {
 				if err == nil || err.Error() != tc.expectedError {
 					t.Errorf("expected: %v actual: %v", tc.expectedError, err)
 				}
 			}

 			if tc.expectedStatus == "success" {
 				if err != nil {
 					t.Errorf("expected: success actual: %v", err)
 				}
 			}
 		})
 	}
 }
	// Copyright 2020 The Fuchsia 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 main

	import (
	"context"
	"encoding/base64"
	"flag"
	"fmt"
	"math/rand"
	"os"
	"path"
	"reflect"
	"strings"
	"testing"
	"time"

	fg "go.fuchsia.dev/fuchsia/tools/femu-control/femu-grpc"
	)

	type keyEvent struct {
	evType string
	keySeq []string
	}

	type fakeFemuGrpcClient struct {
	keyEvents []keyEvent
	}

	func (f *fakeFemuGrpcClient) StreamScreen(opts fg.StreamScreenOpts) (fg.Frames, error) {
	numFrames := opts.NumFrames
	if numFrames == 0 \|\| numFrames > 10 {
	numFrames = 10
	}

	frames := fg.Frames{}
	frames.Width = 1
	frames.Height = 1

	const png1x1Base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQYV2PwUSn4DwADgAHgUix5GgAAAABJRU5ErkJggg=="
	pngBytes, _ := base64.StdEncoding.DecodeString(png1x1Base64)
	for i := uint(0); i < numFrames; i++ {
	frames.Images = append(frames.Images, pngBytes)
	}

	return frames, nil
	}

	func (f *fakeFemuGrpcClient) StreamAudio(opts fg.StreamAudioOpts) (fg.AudioPayload, error) {
	audio := fg.AudioPayload{}

	byteSize := uint(opts.Duration.Milliseconds()) * opts.Format.SamplingRate / 1000 * opts.Format.BitsPerSample / 8
	if opts.Format.Channels == "STEREO" {
	byteSize = byteSize * 2
	}

	audio.Bytes = make([]byte, byteSize)
	audio.LengthMs = uint(opts.Duration.Milliseconds())
	return audio, nil
	}

	func (f *fakeFemuGrpcClient) KeyDown(seq []string) error {
	f.keyEvents = append(f.keyEvents, keyEvent{
	evType: "DOWN",
	keySeq: seq,
	})
	return nil
	}

	func (f *fakeFemuGrpcClient) KeyUp(seq []string) error {
	f.keyEvents = append(f.keyEvents, keyEvent{
	evType: "UP",
	keySeq: seq,
	})
	return nil
	}

	func (f *fakeFemuGrpcClient) KeyPress(seq []string) error {
	f.keyEvents = append(f.keyEvents, keyEvent{
	evType: "PRESS",
	keySeq: seq,
	})
	return nil
	}

	func TestStreamScreen(t *testing.T) {
	client := fakeFemuGrpcClient{}
	ctx := context.WithValue(context.Background(), "client", &client)

	var seededRand *rand.Rand = rand.New(
	rand.NewSource(time.Now().UnixNano()))
	tmpDir := fmt.Sprintf("/tmp/femu%v", seededRand.Int())

	testCases := []struct {
	name string
	flags string
	expectedStatus string
	expectedError string
	setup func()
	cleanup func()
	}{
	{
	name: "num-frames and duration both missing",
	flags: fmt.Sprintf("-out %v/screen%%.png", tmpDir),
	expectedStatus: "usage error",
	expectedError: "-num-frames and -duration cannot be both zero",
	},
	{
	name: "path is not directory",
	flags: fmt.Sprintf("-duration 1s -out %v/file/screen%%.png", tmpDir),
	expectedStatus: "usage error",
	expectedError: fmt.Sprintf("path %v/file/ invalid: stat %v/file/: not a directory", tmpDir, tmpDir),
	setup: func() {
	os.MkdirAll(tmpDir, 0755)
	os.Create(path.Join(tmpDir, "file"))
	},
	cleanup: func() {
	os.Remove(path.Join(tmpDir, "file"))
	},
	},
	{
	name: "filename not containing extension",
	flags: fmt.Sprintf("-duration 1s -out %v/screen%%", tmpDir),
	expectedStatus: "usage error",
	expectedError: "filename 'screen%' doesn't contain any extension!",
	},
	{
	name: "filename not containing %",
	flags: fmt.Sprintf("-duration 1s -out %v/screen.jpg", tmpDir),
	expectedStatus: "success",
	},
	{
	name: "unsupported extension",
	flags: fmt.Sprintf("-duration 1s -out %v/screen%%.wav", tmpDir),
	expectedStatus: "usage error",
	expectedError: "filename 'screen%.wav' has unsupported extension: .wav. supported extensions are jpeg, jpg, gif, and png.",
	},
	{
	name: "valid usage: jpg",
	flags: fmt.Sprintf("-duration 1s -out %v/screen%%.jpg", tmpDir),
	expectedStatus: "success",
	cleanup: func() { os.RemoveAll(tmpDir) },
	},
	{
	name: "valid usage: png",
	flags: fmt.Sprintf("-duration 1s -out %v/screen%%.png", tmpDir),
	expectedStatus: "success",
	cleanup: func() { os.RemoveAll(tmpDir) },
	},
	{
	name: "valid usage: gif",
	flags: fmt.Sprintf("-duration 1s -out %v/screen.gif", tmpDir),
	expectedStatus: "success",
	cleanup: func() { os.RemoveAll(tmpDir) },
	},
	}

	for _, tc := range testCases {
	t.Run(tc.name, func(t *testing.T) {
	if tc.setup != nil {
	tc.setup()
	}
	if tc.cleanup != nil {
	defer tc.cleanup()
	}

	cmd := recordScreenCmd{}

	f := flag.NewFlagSet("", flag.ContinueOnError)
	cmd.SetFlags(f)

	err := f.Parse(strings.Split(tc.flags, " "))
	if err != nil {
	t.Errorf("parse flags failed: %v", err)
	return
	}

	err = cmd.ValidateArgs()
	switch {
	case err == nil && tc.expectedStatus == "usage error":
	t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
	case err != nil && tc.expectedStatus == "usage error" && tc.expectedError != err.Error():
	t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
	return
	case err != nil && tc.expectedStatus != "usage error":
	t.Errorf("expected: %v actual (usage error): %v", tc.expectedStatus, err)
	return
	case err != nil:
	return
	}

	err = cmd.run(ctx)
	if tc.expectedStatus == "failure" {
	if err == nil \|\| err.Error() != tc.expectedError {
	t.Errorf("expected: %v actual: %v", tc.expectedError, err)
	}
	}

	if tc.expectedStatus == "success" {
	if err != nil {
	t.Errorf("expected: success actual: %v", err)
	}
	}
	})
	}
	}

	func TestStreamAudio(t *testing.T) {
	client := fakeFemuGrpcClient{}
	ctx := context.WithValue(context.Background(), "client", &client)

	var seededRand *rand.Rand = rand.New(
	rand.NewSource(time.Now().UnixNano()))
	tmpDir := fmt.Sprintf("/tmp/femu%v", seededRand.Int())

	testCases := []struct {
	name string
	flags string
	expectedStatus string
	expectedError string
	setup func()
	cleanup func()
	}{
	{
	name: "-duration missing",
	flags: fmt.Sprintf("-out %v/audio.wav", tmpDir),
	expectedStatus: "usage error",
	expectedError: "-duration cannot be zero",
	},
	{
	name: "path is not directory",
	flags: fmt.Sprintf("-duration 1s -out %v/file/audio.wav", tmpDir),
	expectedStatus: "usage error",
	expectedError: fmt.Sprintf("path %v/file/ invalid: stat %v/file/: not a directory", tmpDir, tmpDir),
	setup: func() {
	os.MkdirAll(tmpDir, 0755)
	os.Create(path.Join(tmpDir, "file"))
	},
	cleanup: func() {
	os.Remove(path.Join(tmpDir, "file"))
	},
	},
	{
	name: "invalid args: channels",
	flags: fmt.Sprintf("-duration 1s -out %v/audio.wav -channels SURROUND", tmpDir),
	expectedStatus: "usage error",
	expectedError: "unsupported channel format: SURROUND",
	},
	{
	name: "invalid args: bit depth",
	flags: fmt.Sprintf("-duration 1s -out %v/audio.wav -bit-depth 32", tmpDir),
	expectedStatus: "usage error",
	expectedError: "unsupported number of bits per sample: 32",
	},
	{
	name: "invalid args: sampling rate",
	flags: fmt.Sprintf("-duration 1s -out %v/audio.wav -sampling-rate 0", tmpDir),
	expectedStatus: "usage error",
	expectedError: "invalid sampling rate: 0",
	},
	{
	name: "valid usage",
	flags: fmt.Sprintf("-duration 1s -out %v/screen.wav", tmpDir),
	expectedStatus: "success",
	cleanup: func() { os.RemoveAll(tmpDir) },
	},
	}

	for _, tc := range testCases {
	t.Run(tc.name, func(t *testing.T) {
	if tc.setup != nil {
	tc.setup()
	}
	if tc.cleanup != nil {
	defer tc.cleanup()
	}

	cmd := recordAudioCmd{}

	f := flag.NewFlagSet("", flag.ContinueOnError)
	cmd.SetFlags(f)

	err := f.Parse(strings.Split(tc.flags, " "))
	if err != nil {
	t.Errorf("parse flags failed: %v", err)
	return
	}

	err = cmd.ValidateArgs()
	switch {
	case err == nil && tc.expectedStatus == "usage error":
	t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
	case err != nil && tc.expectedStatus == "usage error" && tc.expectedError != err.Error():
	t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
	return
	case err != nil && tc.expectedStatus != "usage error":
	t.Errorf("expected: %v actual (usage error): %v", tc.expectedStatus, err)
	return
	case err != nil:
	return
	}

	err = cmd.run(ctx)
	if tc.expectedStatus == "failure" {
	if err == nil \|\| err.Error() != tc.expectedError {
	t.Errorf("expected: %v actual: %v", tc.expectedError, err)
	}
	}

	if tc.expectedStatus == "success" {
	if err != nil {
	t.Errorf("expected: success actual: %v", err)
	}
	}
	})
	}
	}

	func TestKeyboard(t *testing.T) {
	client := fakeFemuGrpcClient{}
	ctx := context.WithValue(context.Background(), "client", &client)

	testCases := []struct {
	name string
	flags string
	expectedStatus string
	expectedError string
	setup func()
	cleanup func()
	}{
	{
	name: "invalid type",
	flags: "-event OTHER Ctrl+Alt+A",
	expectedStatus: "usage error",
	expectedError: "unknown event type: OTHER",
	},
	{
	name: "key sequence missing",
	flags: "-event PRESS",
	expectedStatus: "usage error",
	expectedError: "key sequence missing",
	},
	{
	name: "key down",
	flags: "-event DOWN Control+Alt+A",
	expectedStatus: "success",
	expectedError: "",
	cleanup: func() {
	if len(client.keyEvents) == 0 {
	t.Fatalf("client.keyEvents is empty")
	}
	event := client.keyEvents[len(client.keyEvents)-1]
	if event.evType != "DOWN" {
	t.Errorf("incorrect event.evType: expected: %v actual: %v", "DOWN", event.evType)
	}

	expectedKeySeq := []string{"Control", "Alt", "A"}
	if !reflect.DeepEqual(event.keySeq, expectedKeySeq) {
	t.Errorf("incorrect event.keySeq: expected: %v actual: %v", expectedKeySeq, event.keySeq)
	}
	},
	},
	{
	name: "key up",
	flags: "-event UP Alt+Shift+3",
	expectedStatus: "success",
	expectedError: "",
	cleanup: func() {
	if len(client.keyEvents) == 0 {
	t.Fatalf("client.keyEvents is empty")
	}
	event := client.keyEvents[len(client.keyEvents)-1]
	if event.evType != "UP" {
	t.Errorf("incorrect event.evType: expected: %v actual: %v", "UP", event.evType)
	}

	expectedKeySeq := []string{"Alt", "Shift", "3"}
	if !reflect.DeepEqual(event.keySeq, expectedKeySeq) {
	t.Errorf("incorrect event.keySeq: expected: %v actual: %v", expectedKeySeq, event.keySeq)
	}
	},
	},
	{
	name: "key press",
	flags: "-event PRESS Meta+Z",
	expectedStatus: "success",
	expectedError: "",
	cleanup: func() {
	if len(client.keyEvents) == 0 {
	t.Fatalf("client.keyEvents is empty")
	}
	event := client.keyEvents[len(client.keyEvents)-1]
	if event.evType != "PRESS" {
	t.Errorf("incorrect event.evType: expected: %v actual: %v", "PRESS", event.evType)
	}

	expectedKeySeq := []string{"Meta", "Z"}
	if !reflect.DeepEqual(event.keySeq, expectedKeySeq) {
	t.Errorf("incorrect event.keySeq: expected: %v actual: %v", expectedKeySeq, event.keySeq)
	}
	},
	},
	}

	for _, tc := range testCases {
	t.Run(tc.name, func(t *testing.T) {
	if tc.setup != nil {
	tc.setup()
	}
	if tc.cleanup != nil {
	defer tc.cleanup()
	}

	cmd := keyboardCmd{}

	f := flag.NewFlagSet("", flag.ContinueOnError)
	cmd.SetFlags(f)

	err := f.Parse(strings.Split(tc.flags, " "))
	if err != nil {
	t.Errorf("parse flags failed: %v", err)
	return
	}
	if f.Arg(0) != "" {
	cmd.keySequence = strings.Split(f.Arg(0), "+")
	}

	err = cmd.ValidateArgs()
	switch {
	case err == nil && tc.expectedStatus == "usage error":
	t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
	case err != nil && tc.expectedStatus == "usage error" && tc.expectedError != err.Error():
	t.Errorf("(usage error) expected: %v actual: %v", tc.expectedError, err)
	return
	case err != nil && tc.expectedStatus != "usage error":
	t.Errorf("expected: %v actual (usage error): %v", tc.expectedStatus, err)
	return
	case err != nil:
	return
	}

	err = cmd.run(ctx)
	if tc.expectedStatus == "failure" {
	if err == nil \|\| err.Error() != tc.expectedError {
	t.Errorf("expected: %v actual: %v", tc.expectedError, err)
	}
	}

	if tc.expectedStatus == "success" {
	if err != nil {
	t.Errorf("expected: success actual: %v", err)
	}
	}
	})
	}
	}