Function TestParseTemporalRule

parse/temporal_test.go:165–220

(t *testing.T)

}

func TestParseTemporalRule(t *testing.T) {
	tests := []struct {
		name     string
		str      string
		wantHead ast.Atom
		wantTime *ast.Interval
		wantErr  bool
	}{
		{
			name:     "rule without temporal annotation",
			str:      "foo(X) :- bar(X).",
			wantHead: ast.NewAtom("foo", ast.Variable{Symbol: "X"}),
			wantTime: nil,
			wantErr:  false,
		},
		{
			name:     "rule with temporal annotation on head",
			str:      "active(X)@[T, T] :- login(X).",
			wantHead: ast.NewAtom("active", ast.Variable{Symbol: "X"}),
			wantTime: func() *ast.Interval {
				bound := ast.NewVariableBound(ast.Variable{Symbol: "T"})
				i := ast.NewInterval(bound, bound)
				return &i
			}(),
			wantErr: false,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			clause, err := Clause(test.str)
			if (err != nil) != test.wantErr {
				t.Fatalf("Clause(%q) error = %v, wantErr = %v", test.str, err, test.wantErr)
			}
			if err != nil {
				return
			}

			if !clause.Head.Equals(test.wantHead) {
				t.Errorf("Clause(%q).Head = %v, want %v", test.str, clause.Head, test.wantHead)
			}

			if test.wantTime == nil {
				if clause.HeadTime != nil {
					t.Errorf("Clause(%q).HeadTime = %v, want nil", test.str, clause.HeadTime)
				}
			} else {
				if clause.HeadTime == nil {
					t.Errorf("Clause(%q).HeadTime = nil, want %v", test.str, test.wantTime)
				} else if !clause.HeadTime.Equals(*test.wantTime) {
					t.Errorf("Clause(%q).HeadTime = %v, want %v", test.str, clause.HeadTime, test.wantTime)
				}
			}
		})
	}
}

func TestParseTimestamp(t *testing.T) {