chore: record continuous maintain loop records

loop.go

@@ -44,16 +44,30 @@ func (r *MaintainLoopRecorder) AddRecord() {
 	r.LastMaintainLoopTimes = append(r.LastMaintainLoopTimes, time.Now())
 }
 
-// GetRecordsIn returns the number of records in the last duration.
+// GetRecordsIn returns the number of continuous records in the last duration.
 func (r *MaintainLoopRecorder) GetRecordsIn(last time.Duration) int {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
+	// Find continuous records from the end of the list.
+	// Continuous records are defined as the time difference between
+	// two adjacent records is less than loopInterval+1 second.
 	count := 0
-	for _, t := range r.LastMaintainLoopTimes {
-		if time.Since(t) <= last {
-			count++
+	for i := len(r.LastMaintainLoopTimes) - 1; i >= 0; i-- {
+		record := r.LastMaintainLoopTimes[i]
+		if time.Since(record) > last {
+			break
 		}
+
+		theRecordAfter := record
+		if i+1 < len(r.LastMaintainLoopTimes) {
+			theRecordAfter = r.LastMaintainLoopTimes[i+1]
+		}
+
+		if theRecordAfter.Sub(record) >= loopInterval+time.Second {
+			break
+		}
+		count++
 	}
 
 	return count
@@ -185,7 +199,7 @@ func maintainLoopInner() bool {
 				"maintainLoopCount":         maintainLoopCount,
 				"expectedMaintainLoopCount": expectedMaintainLoopCount,
 				"minMaintainLoopCount":      minMaintainLoopCount,
-			}).Infof("Battery charge is below lower limit, but too many missed maintain loops are missed. Rapid sleep/wake?")
+			}).Infof("Battery charge is below lower limit, but too many missed maintain loops are missed. Will wait until maintain loops are stable")
 			return true
 		}
 

loop_test.go

@@ -0,0 +1,71 @@
+package main
+
+import (
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestMaintainLoopRecorder_GetRecordsIn(t *testing.T) {
+	type fields struct {
+		MaxRecordCount        int
+		LastMaintainLoopTimes []time.Time
+		mu                    *sync.Mutex
+	}
+	type args struct {
+		last time.Duration
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   int
+	}{
+		{
+			name: "test noncontinuous records",
+			fields: fields{
+				MaxRecordCount: 10,
+				LastMaintainLoopTimes: []time.Time{
+					time.Now().Add(-time.Second * 31).Add(-10 * time.Millisecond),
+					time.Now().Add(-time.Second * 20).Add(-10 * time.Millisecond),
+					time.Now().Add(-time.Second * 10).Add(-10 * time.Millisecond),
+				},
+				mu: &sync.Mutex{},
+			},
+			args: args{
+				last: time.Second * 40,
+			},
+			want: 2,
+		},
+		{
+			name: "test continuous records",
+			fields: fields{
+				MaxRecordCount: 10,
+				LastMaintainLoopTimes: []time.Time{
+					time.Now().Add(-time.Second * 60).Add(-10 * time.Millisecond),
+					time.Now().Add(-time.Second * 30).Add(-10 * time.Millisecond),
+					time.Now().Add(-time.Second * 20).Add(-10 * time.Millisecond),
+					time.Now().Add(-time.Second * 10).Add(-10 * time.Millisecond),
+				},
+				mu: &sync.Mutex{},
+			},
+			args: args{
+				last: time.Second * 50,
+			},
+			want: 3,
+		},
+	}
+	for _, tt := range tests {
+		loopInterval = time.Second * 10
+		t.Run(tt.name, func(t *testing.T) {
+			r := &MaintainLoopRecorder{
+				MaxRecordCount:        tt.fields.MaxRecordCount,
+				LastMaintainLoopTimes: tt.fields.LastMaintainLoopTimes,
+				mu:                    tt.fields.mu,
+			}
+			if got := r.GetRecordsIn(tt.args.last); got != tt.want {
+				t.Errorf("GetRecordsIn() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}