Skip to content

Commit 212721c

Browse files
JanDeDobbeleerJanDeDobbeleer
committed
fix(battery): better state mapping
relates to #644
1 parent 92a2f74 commit 212721c

File tree

4 files changed

+160
-188
lines changed

4 files changed

+160
-188
lines changed

‎.vscode/launch.json‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
"request": "launch",
88
"mode": "debug",
99
"program": "${workspaceRoot}/src",
10-
"args": ["--config=${workspaceRoot}/themes/jandedobbeleer.omp.json"]
10+
"args": ["--config=/Users/jan/.jandedobbeleer.omp.json"]
1111
},
1212
{
1313
"name": "Launch tests",

‎src/properties_test.go‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,8 @@ import (
77
)
88

99
const (
10-
expected = "expected"
10+
expected = "expected"
11+
expectedColor = "#768954"
1112
)
1213

1314
func TestGetString(t *testing.T) {

‎src/segment_battery.go‎

Lines changed: 16 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -99,14 +99,23 @@ func (b *batt) enabledWhileError(err error) bool {
9999
return true
100100
}
101101

102-
func (b *batt) mapMostLogicalState(currentState battery.State, state battery.State) battery.State {
103-
if currentState == battery.Unknown {
104-
return state
105-
}
106-
if currentState == battery.Empty|battery.Full && state == battery.Charging|battery.Discharging {
107-
return state
102+
func (b *batt) mapMostLogicalState(currentState, newState battery.State) battery.State {
103+
switch currentState {
104+
case battery.Discharging:
105+
return battery.Discharging
106+
case battery.Empty:
107+
return newState
108+
case battery.Charging:
109+
if newState == battery.Discharging {
110+
return battery.Discharging
111+
}
112+
return battery.Charging
113+
case battery.Unknown:
114+
return newState
115+
case battery.Full:
116+
return newState
108117
}
109-
return battery.Charging
118+
return newState
110119
}
111120

112121
func (b *batt) string() string {

‎src/segment_battery_test.go‎

Lines changed: 141 additions & 179 deletions
Original file line numberDiff line numberDiff line change
@@ -9,199 +9,139 @@ import (
99
)
1010

1111
const (
12-
expectedColor = "#768954"
12+
chargingColor = "#123456"
13+
dischargingColor = "#765432"
14+
chargedColor = "#248644"
1315
)
1416

15-
func setupBatteryTests(state battery.State, batteryLevel float64, props *properties) *batt {
16-
env := &MockedEnvironment{}
17-
bt := &battery.Battery{
18-
State: state,
19-
Full: 100,
20-
Current: batteryLevel,
21-
}
22-
batteries := []*battery.Battery{
23-
bt,
24-
}
25-
env.On("getBatteryInfo", nil).Return(batteries, nil)
26-
b := &batt{
27-
props: props,
28-
env: env,
29-
}
30-
b.enabled()
31-
return b
32-
}
33-
34-
func TestBatteryCharging(t *testing.T) {
35-
props := &properties{
36-
values: map[Property]interface{}{
37-
ChargingIcon: "charging ",
38-
},
39-
}
40-
b := setupBatteryTests(battery.Charging, 80, props)
41-
assert.Equal(t, "charging 80", b.string())
42-
}
43-
44-
func TestBatteryCharged(t *testing.T) {
45-
props := &properties{
46-
values: map[Property]interface{}{
47-
ChargedIcon: "charged ",
48-
},
49-
}
50-
b := setupBatteryTests(battery.Full, 100, props)
51-
assert.Equal(t, "charged 100", b.string())
52-
}
53-
54-
func TestBatteryDischarging(t *testing.T) {
55-
props := &properties{
56-
values: map[Property]interface{}{
57-
DischargingIcon: "going down ",
17+
func TestBatterySegmentSingle(t *testing.T) {
18+
cases := []struct {
19+
Case string
20+
BatteryState battery.State
21+
BatteryLevel float64
22+
ExpectedString string
23+
ExpectedEnabled bool
24+
ExpectedColor string
25+
ColorBackground bool
26+
DisplayError bool
27+
Error error
28+
DisableCharging bool
29+
}{
30+
{Case: "80% charging", BatteryState: battery.Charging, BatteryLevel: 80, ExpectedString: "charging 80", ExpectedEnabled: true},
31+
{Case: "battery full", BatteryState: battery.Full, BatteryLevel: 100, ExpectedString: "charged 100", ExpectedEnabled: true},
32+
{Case: "70% discharging", BatteryState: battery.Discharging, BatteryLevel: 70, ExpectedString: "going down 70", ExpectedEnabled: true},
33+
{
34+
Case: "discharging background color",
35+
BatteryState: battery.Discharging,
36+
BatteryLevel: 70,
37+
ExpectedString: "going down 70",
38+
ExpectedEnabled: true,
39+
ColorBackground: true,
40+
ExpectedColor: dischargingColor,
5841
},
59-
}
60-
b := setupBatteryTests(battery.Discharging, 70, props)
61-
assert.Equal(t, "going down 70", b.string())
62-
}
63-
64-
func TestBatteryBackgroundColor(t *testing.T) {
65-
expected := expectedColor
66-
props := &properties{
67-
background: "#111111",
68-
values: map[Property]interface{}{
69-
DischargingIcon: "going down ",
70-
ColorBackground: true,
71-
DischargingColor: expected,
42+
{
43+
Case: "charging background color",
44+
BatteryState: battery.Charging,
45+
BatteryLevel: 70,
46+
ExpectedString: "charging 70",
47+
ExpectedEnabled: true,
48+
ColorBackground: true,
49+
ExpectedColor: chargingColor,
7250
},
73-
}
74-
b := setupBatteryTests(battery.Discharging, 70, props)
75-
b.string()
76-
assert.Equal(t, expected, props.background)
77-
}
78-
79-
func TestBatteryBackgroundColorInvalid(t *testing.T) {
80-
expected := expectedColor
81-
props := &properties{
82-
background: expected,
83-
values: map[Property]interface{}{
84-
DischargingIcon: "going down ",
85-
ColorBackground: true,
86-
DischargingColor: "derp",
51+
{
52+
Case: "charged background color",
53+
BatteryState: battery.Full,
54+
BatteryLevel: 70,
55+
ExpectedString: "charged 70",
56+
ExpectedEnabled: true,
57+
ColorBackground: true,
58+
ExpectedColor: chargedColor,
8759
},
88-
}
89-
b := setupBatteryTests(battery.Discharging, 70, props)
90-
b.string()
91-
assert.Equal(t, expected, props.background)
92-
}
93-
94-
func TestBatteryForegroundColor(t *testing.T) {
95-
expected := expectedColor
96-
props := &properties{
97-
foreground: "#111111",
98-
values: map[Property]interface{}{
99-
DischargingIcon: "going down ",
100-
ColorBackground: false,
101-
DischargingColor: expected,
60+
{
61+
Case: "discharging foreground color",
62+
BatteryState: battery.Discharging,
63+
BatteryLevel: 70,
64+
ExpectedString: "going down 70",
65+
ExpectedEnabled: true,
66+
ExpectedColor: dischargingColor,
10267
},
103-
}
104-
b := setupBatteryTests(battery.Discharging, 70, props)
105-
b.string()
106-
assert.Equal(t, expected, props.foreground)
107-
}
108-
109-
func TestBatteryForegroundColorInvalid(t *testing.T) {
110-
expected := expectedColor
111-
props := &properties{
112-
foreground: expected,
113-
values: map[Property]interface{}{
114-
DischargingIcon: "going down ",
115-
ColorBackground: false,
116-
DischargingColor: "derp",
68+
{
69+
Case: "charging foreground color",
70+
BatteryState: battery.Charging,
71+
BatteryLevel: 70,
72+
ExpectedString: "charging 70",
73+
ExpectedEnabled: true,
74+
ExpectedColor: chargingColor,
11775
},
118-
}
119-
b := setupBatteryTests(battery.Discharging, 70, props)
120-
b.string()
121-
assert.Equal(t, expected, props.foreground)
122-
}
123-
124-
func TestBatteryError(t *testing.T) {
125-
env := &MockedEnvironment{}
126-
err := errors.New("oh snap")
127-
batteries := []*battery.Battery{}
128-
env.On("getBatteryInfo", nil).Return(batteries, err)
129-
b := &batt{
130-
props: &properties{
131-
values: map[Property]interface{}{
132-
DisplayError: true,
133-
},
76+
{
77+
Case: "charged foreground color",
78+
BatteryState: battery.Full,
79+
BatteryLevel: 70,
80+
ExpectedString: "charged 70",
81+
ExpectedEnabled: true,
82+
ExpectedColor: chargedColor,
83+
},
84+
{Case: "battery error", DisplayError: true, Error: errors.New("oh snap"), ExpectedString: "oh snap", ExpectedEnabled: true},
85+
{Case: "battery error disabled", Error: errors.New("oh snap")},
86+
{Case: "no batteries", DisplayError: true, Error: &noBatteryError{}},
87+
{Case: "display charging disabled: charging", BatteryState: battery.Charging, DisableCharging: true},
88+
{Case: "display charging disabled: charged", BatteryState: battery.Full, DisableCharging: true},
89+
{
90+
Case: "display charging disabled: discharging",
91+
BatteryState: battery.Discharging,
92+
BatteryLevel: 70,
93+
ExpectedString: "going down 70",
94+
ExpectedEnabled: true,
95+
DisableCharging: true,
13496
},
135-
env: env,
13697
}
137-
assert.True(t, b.enabled())
138-
assert.Equal(t, "oh snap", b.string())
139-
}
14098

141-
func TestBatteryErrorHidden(t *testing.T) {
142-
env := &MockedEnvironment{}
143-
err := errors.New("oh snap")
144-
batteries := []*battery.Battery{}
145-
env.On("getBatteryInfo", nil).Return(batteries, err)
146-
b := &batt{
147-
props: &properties{
148-
values: map[Property]interface{}{
149-
DisplayError: false,
99+
for _, tc := range cases {
100+
env := &MockedEnvironment{}
101+
batteries := []*battery.Battery{
102+
{
103+
Full: 100,
104+
State: tc.BatteryState,
105+
Current: tc.BatteryLevel,
150106
},
151-
},
152-
env: env,
153-
}
154-
assert.False(t, b.enabled())
155-
}
156-
157-
func TestBatteryNoBattery(t *testing.T) {
158-
env := &MockedEnvironment{}
159-
err := &noBatteryError{}
160-
batteries := []*battery.Battery{}
161-
env.On("getBatteryInfo", nil).Return(batteries, err)
162-
b := &batt{
163-
props: &properties{
107+
}
108+
props := &properties{
109+
background: "#111111",
110+
foreground: "#ffffff",
164111
values: map[Property]interface{}{
165-
DisplayError: true,
112+
ChargingIcon: "charging ",
113+
ChargedIcon: "charged ",
114+
DischargingIcon: "going down ",
115+
DischargingColor: dischargingColor,
116+
ChargedColor: chargedColor,
117+
ChargingColor: chargingColor,
118+
ColorBackground: tc.ColorBackground,
119+
DisplayError: tc.DisplayError,
166120
},
167-
},
168-
env: env,
169-
}
170-
assert.False(t, b.enabled())
171-
}
172-
173-
func TestBatteryDischargingAndDisplayChargingDisabled(t *testing.T) {
174-
props := &properties{
175-
values: map[Property]interface{}{
176-
DischargingIcon: "going down ",
177-
DisplayCharging: false,
178-
},
179-
}
180-
b := setupBatteryTests(battery.Discharging, 70, props)
181-
assert.Equal(t, true, b.enabled())
182-
assert.Equal(t, "going down 70", b.string())
183-
}
184-
185-
func TestBatteryChargingAndDisplayChargingDisabled(t *testing.T) {
186-
props := &properties{
187-
values: map[Property]interface{}{
188-
ChargingIcon: "charging ",
189-
DisplayCharging: false,
190-
},
191-
}
192-
b := setupBatteryTests(battery.Charging, 80, props)
193-
assert.Equal(t, false, b.enabled())
194-
}
195-
196-
func TestBatteryChargedAndDisplayChargingDisabled(t *testing.T) {
197-
props := &properties{
198-
values: map[Property]interface{}{
199-
ChargedIcon: "charged ",
200-
DisplayCharging: false,
201-
},
121+
}
122+
if tc.DisableCharging {
123+
props.values[DisplayCharging] = false
124+
}
125+
env.On("getBatteryInfo", nil).Return(batteries, tc.Error)
126+
b := &batt{
127+
props: props,
128+
env: env,
129+
}
130+
enabled := b.enabled()
131+
assert.Equal(t, tc.ExpectedEnabled, enabled, tc.Case)
132+
if !enabled {
133+
continue
134+
}
135+
assert.Equal(t, tc.ExpectedString, b.string(), tc.Case)
136+
if len(tc.ExpectedColor) == 0 {
137+
continue
138+
}
139+
actualColor := b.props.foreground
140+
if tc.ColorBackground {
141+
actualColor = b.props.background
142+
}
143+
assert.Equal(t, tc.ExpectedColor, actualColor, tc.Case)
202144
}
203-
b := setupBatteryTests(battery.Full, 100, props)
204-
assert.Equal(t, false, b.enabled())
205145
}
206146

207147
func TestGetBatteryColors(t *testing.T) {
@@ -273,3 +213,25 @@ func TestGetBatteryColors(t *testing.T) {
273213
assert.Equal(t, tc.ExpectedColor, color, tc.Case)
274214
}
275215
}
216+
217+
func TestMapBatteriesState(t *testing.T) {
218+
cases := []struct {
219+
Case string
220+
ExpectedState battery.State
221+
CurrentState battery.State
222+
NewState battery.State
223+
}{
224+
{Case: "charging > charged", ExpectedState: battery.Charging, CurrentState: battery.Full, NewState: battery.Charging},
225+
{Case: "charging < discharging", ExpectedState: battery.Discharging, CurrentState: battery.Discharging, NewState: battery.Charging},
226+
{Case: "charging == charging", ExpectedState: battery.Charging, CurrentState: battery.Charging, NewState: battery.Charging},
227+
{Case: "discharging > charged", ExpectedState: battery.Discharging, CurrentState: battery.Full, NewState: battery.Discharging},
228+
{Case: "discharging > unknown", ExpectedState: battery.Discharging, CurrentState: battery.Unknown, NewState: battery.Discharging},
229+
{Case: "discharging > full", ExpectedState: battery.Discharging, CurrentState: battery.Full, NewState: battery.Discharging},
230+
{Case: "discharging > charging 2", ExpectedState: battery.Discharging, CurrentState: battery.Charging, NewState: battery.Discharging},
231+
{Case: "discharging > empty", ExpectedState: battery.Discharging, CurrentState: battery.Empty, NewState: battery.Discharging},
232+
}
233+
for _, tc := range cases {
234+
batt := &batt{}
235+
assert.Equal(t, tc.ExpectedState, batt.mapMostLogicalState(tc.CurrentState, tc.NewState), tc.Case)
236+
}
237+
}

0 commit comments

Comments
 (0)