Function TestStratificationPositive

analysis/stratification_test.go:51–126

(t *testing.T)

}

func TestStratificationPositive(t *testing.T) {
	tests := []struct {
		name            string
		program         func() (*ProgramInfo, error)
		wantStrataOrder map[int][]ast.PredicateSym
	}{
		{
			name: "Ignore built-in predicates",
			program: func() (*ProgramInfo, error) {
				return analyze([]ast.Clause{
					clause("foo(X) :- :list:member(X, [/a])."),
				})
			},
			wantStrataOrder: map[int][]ast.PredicateSym{
				0: {{"foo", 1}},
			},
		},
		{
			name: "Cycles are ok as long as they are positive",
			program: func() (*ProgramInfo, error) {
				return analyze([]ast.Clause{
					clause("num(/one)."),
					clause("num(/two)."),
					clause("num(/three)."),
					clause("succ(/one, /two)."),
					clause("succ(/two, /three)."),
					clause("odd(/one)."),
					clause("odd(X) :- num(X), succ(Y,X), even(Y)."),
					clause("even(X) :- num(X), succ(X,Y), odd(X)."),
					clause("count(Z) :- odd(X) |> do fn:group_by(), let Z = fn:count()."),
				})
			},
			wantStrataOrder: map[int][]ast.PredicateSym{
				0: {{"even", 1}, {"odd", 1}},
				1: {{"count", 1}},
			},
		},
		{
			name: "The result is ordered by dependencies",
			program: func() (*ProgramInfo, error) {
				return analyze([]ast.Clause{
					clause("num(/one)."),
					clause("a(X) :- num(X), b(X)."),
					clause("b(X) :- num(X), c(X)."),
					clause("c(X) :- num(X), d(X), b(X)."),
					clause("d(X) :- num(X)."),
				})
			},
			wantStrataOrder: map[int][]ast.PredicateSym{
				0: {{"d", 1}},
				1: {{"b", 1}, {"c", 1}},
				2: {{"a", 1}},
			},
		},
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			program, err := test.program()