Function TestCheckTemporalRecursion

analysis/temporal_test.go:24–119

(t *testing.T)

)

func TestCheckTemporalRecursion(t *testing.T) {
	tests := []struct {
		name            string
		program         string
		wantWarnings    int
		wantSeverity    WarningSeverity
		wantMsgContains string
	}{
		{
			name: "no temporal predicates",
			program: `
				foo(X) :- bar(X).
				bar(1).
			`,
			wantWarnings: 0,
		},
		{
			name: "non-recursive temporal predicate",
			program: `
				Decl active(X) temporal bound [/name].
				Decl base_active(X) bound [/name].
				active(X) @[_, _] :- base_active(X).
				base_active(/alice).
			`,
			wantWarnings: 0,
		},
		{
			name: "self-recursive temporal predicate",
			program: `
				Decl derived(X) temporal bound [/name].
				Decl some_condition(X) bound [/name].
				derived(X) @[_, _] :- derived(X) @[_,_], some_condition(X).
				some_condition(/alice).
			`,
			wantWarnings:    1,
			wantSeverity:    SeverityWarning,
			wantMsgContains: "self-recursive",
		},
		{
			name: "mutual recursion with temporal",
			program: `
				Decl foo(X) temporal bound [/name].
				Decl bar(X) temporal bound [/name].
				foo(X) @[_, _] :- bar(X) @[_,_].
				bar(X) @[_, _] :- foo(X) @[_,_].
				bar(/alice) @[_, _].
			`,
			wantWarnings:    1,
			wantSeverity:    SeverityCritical,
			wantMsgContains: "mutual recursion",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			unit, err := parse.Unit(strings.NewReader(tt.program))
			if err != nil {
				t.Fatalf("parse error: %v", err)