File: state_linux_test.go

package info (click to toggle)
runc 1.0.0~rc9+dfsg1-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, sid
  • size: 1,996 kB
  • sloc: sh: 1,422; ansic: 1,008; makefile: 116
file content (116 lines) | stat: -rw-r--r-- 2,327 bytes parent folder | download | duplicates (5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
// +build linux

package libcontainer

import (
	"reflect"
	"testing"
)

var states = map[containerState]Status{
	&createdState{}:          Created,
	&runningState{}:          Running,
	&restoredState{}:         Running,
	&pausedState{}:           Paused,
	&stoppedState{}:          Stopped,
	&loadedState{s: Running}: Running,
}

func TestStateStatus(t *testing.T) {
	for s, status := range states {
		if s.status() != status {
			t.Fatalf("state returned %s but expected %s", s.status(), status)
		}
	}
}

func isStateTransitionError(err error) bool {
	_, ok := err.(*stateTransitionError)
	return ok
}

func testTransitions(t *testing.T, initialState containerState, valid []containerState) {
	validMap := map[reflect.Type]interface{}{}
	for _, validState := range valid {
		validMap[reflect.TypeOf(validState)] = nil
		t.Run(validState.status().String(), func(t *testing.T) {
			if err := initialState.transition(validState); err != nil {
				t.Fatal(err)
			}
		})
	}
	for state := range states {
		if _, ok := validMap[reflect.TypeOf(state)]; ok {
			continue
		}
		t.Run(state.status().String(), func(t *testing.T) {
			err := initialState.transition(state)
			if err == nil {
				t.Fatal("transition should fail")
			}
			if !isStateTransitionError(err) {
				t.Fatal("expected stateTransitionError")
			}
		})
	}
}

func TestStoppedStateTransition(t *testing.T) {
	testTransitions(
		t,
		&stoppedState{c: &linuxContainer{}},
		[]containerState{
			&stoppedState{},
			&runningState{},
			&restoredState{},
		},
	)
}

func TestPausedStateTransition(t *testing.T) {
	testTransitions(
		t,
		&pausedState{c: &linuxContainer{}},
		[]containerState{
			&pausedState{},
			&runningState{},
			&stoppedState{},
		},
	)
}

func TestRestoredStateTransition(t *testing.T) {
	testTransitions(
		t,
		&restoredState{c: &linuxContainer{}},
		[]containerState{
			&stoppedState{},
			&runningState{},
		},
	)
}

func TestRunningStateTransition(t *testing.T) {
	testTransitions(
		t,
		&runningState{c: &linuxContainer{}},
		[]containerState{
			&stoppedState{},
			&pausedState{},
			&runningState{},
		},
	)
}

func TestCreatedStateTransition(t *testing.T) {
	testTransitions(
		t,
		&createdState{c: &linuxContainer{}},
		[]containerState{
			&stoppedState{},
			&pausedState{},
			&runningState{},
			&createdState{},
		},
	)
}