factbase 0.15.0 → 0.15.1

data/test/factbase/cached/test_cached_query.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require 'loog'
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase'
-require_relative '../../../lib/factbase/logged'
-require_relative '../../../lib/factbase/cached/cached_factbase'
-require_relative '../../../lib/factbase/indexed/indexed_factbase'
-require_relative '../../../lib/factbase/sync/sync_factbase'
-
-# Query test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestCachedQuery < Factbase::Test
-  def test_queries_many_times
-    fb = Factbase::CachedFactbase.new(Factbase.new)
-    total = 5
-    total.times { fb.insert }
-    total.times do
-      assert_equal(5, fb.query('(always)').each.to_a.size)
-    end
-  end
-
-  def test_negates_correctly
-    fb = Factbase::CachedFactbase.new(Factbase.new)
-    fb.insert.foo = 42
-    3.times do
-      assert_equal(1, fb.query('(always)').each.to_a.size)
-      assert_equal(0, fb.query('(not (always))').each.to_a.size)
-    end
-  end
-
-  def test_aggregates_too
-    fb = Factbase::IndexedFactbase.new(Factbase::CachedFactbase.new(Factbase.new))
-    10_000.times do |i|
-      f = fb.insert
-      f.foo = i
-      f.hello = 1
-    end
-    3.times do
-      q = fb.query('(eq foo (agg (exists hello) (min foo)))')
-      assert_equal(1, q.each.to_a.size)
-    end
-  end
-
-  def test_joins_too
-    fb = Factbase::IndexedFactbase.new(Factbase::CachedFactbase.new(Factbase.new))
-    total = 10
-    total.times do |i|
-      f = fb.insert
-      f.foo = i
-      f.hello = 1
-    end
-    3.times do
-      assert_equal(total, fb.query('(join "bar<=foo" (eq foo (agg (exists hello) (min foo))))').each.to_a.size)
-    end
-  end
-
-  def test_works_with_logging
-    fb = Factbase::CachedFactbase.new(Factbase::Logged.new(Factbase.new, Loog::NULL))
-    total = 10
-    total.times do |i|
-      f = fb.insert
-      f.foo = i
-      f.hello = 1
-    end
-    3.times do
-      [
-        '(exists foo)',
-        '(and (gt foo -99) (exists hello))',
-        '(and (lt hello 1000.44) (exists foo) (not (exists bar)))'
-      ].each do |q|
-        assert_equal(total, fb.query(q).each.to_a.size)
-      end
-    end
-  end
-
-  def test_caches_while_being_decorated
-    fb = Factbase::SyncFactbase.new(Factbase::CachedFactbase.new(Factbase.new))
-    10_000.times do |i|
-      f = fb.insert
-      f.foo = i
-      f.hello = 1
-    end
-    3.times do
-      assert_equal(1, fb.query('(eq foo (agg (exists hello) (min foo)))').each.to_a.size)
-    end
-  end
-
-  def test_deletes_too
-    fb = Factbase::CachedFactbase.new(Factbase.new)
-    fb.insert.foo = 1
-    fb.query('(eq foo 1)').delete!
-    assert_equal(0, fb.query('(always)').each.to_a.size)
-  end
-end

data/test/factbase/indexed/test_indexed_fact.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase'
-require_relative '../../../lib/factbase/fact'
-require_relative '../../../lib/factbase/indexed/indexed_fact'
-
-# Fact test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestIndexedFact < Factbase::Test
-  def test_updates_origin
-    origin = Factbase::Fact.new({})
-    fact = Factbase::IndexedFact.new(origin, {})
-    fact.foo = 42
-    refute_nil(origin['foo'])
-    assert_equal(42, origin.foo)
-  end
-end

data/test/factbase/indexed/test_indexed_factbase.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require 'elapsed'
-require 'loog'
-require 'timeout'
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase'
-require_relative '../../../lib/factbase/indexed/indexed_factbase'
-
-# Factbase test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestIndexedFactbase < Factbase::Test
-  def test_queries_after_update
-    origin = Factbase.new
-    fb = Factbase::IndexedFactbase.new(origin)
-    fb.insert.foo = 42
-    fb.query('(exists foo)').each do |f|
-      f.bar = 33
-    end
-    refute_empty(origin.query('(exists bar)').each.to_a)
-    refute_empty(fb.query('(exists bar)').each.to_a)
-  end
-
-  def test_queries_after_update_in_txn
-    [
-      '(exists boom)',
-      '(one boom)',
-      '(and (exists boom) (exists boom))',
-      '(and (exists boom) (exists boom) (exists boom))',
-      '(and (one boom) (one boom))',
-      '(and (one boom) (one foo))',
-      '(and (one boom) (one boom) (one boom))',
-      '(and (one boom) (one boom) (one boom) (one foo))',
-      '(and (one boom) (exists boom))',
-      '(and (exists boom) (one boom) (one boom))',
-      '(and (exists boom) (exists boom) (one boom))',
-      '(and (eq foo 42) (exists boom) (one boom) (not (exists bar)))'
-    ].each do |q|
-      origin = Factbase.new
-      fb = Factbase::IndexedFactbase.new(origin)
-      f = fb.insert
-      f.foo = 42
-      f.boom = 33
-      fb.txn do |fbt|
-        fbt.query(q).each do |n|
-          n.bar = n.foo + 1
-        end
-      end
-      refute_empty(origin.query('(exists bar)').each.to_a, q)
-      refute_empty(fb.query('(exists bar)').each.to_a, q)
-    end
-  end
-
-  def test_queries_after_insert_in_txn
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    fb.txn(&:insert)
-    refute_empty(fb.query('(always)').each.to_a)
-  end
-
-  def test_works_with_huge_dataset
-    fb = Factbase.new
-    fb = Factbase::IndexedFactbase.new(fb)
-    10_000.times do |i|
-      fb.insert.then do |f|
-        f.id = i
-        f.foo = [42, 1, 256, 7, 99].sample
-        f.bar = [42, 13, 88, 19, 93].sample
-        f.rarely = rand if rand > 0.95
-        f.often = rand if rand > 0.05
-      end
-    end
-    [
-      '(and (eq foo 42) (exists bar))',
-      '(and (eq foo 42) (exists rarely))',
-      '(and (eq foo 42) (exists often))',
-      '(and (eq foo 42) (exists often) (exists bar) (absent rarely))',
-      '(and (eq foo 42) (empty (eq foo 888)))',
-      '(and (eq foo 42) (empty (eq foo $id)))',
-      '(and (eq foo 42) (empty (eq foo $often)))',
-      '(and (eq foo 42) (empty (and (eq foo $often) (gt foo 43))))',
-      '(and (eq foo 42) (empty (and (eq foo 42) (eq bar 42) (eq id -1))))',
-      '(and (eq foo 42) (empty (exists another)))'
-    ].each do |q|
-      Timeout.timeout(4) do
-        elapsed(Loog::NULL, good: q) do
-          refute_empty(fb.query(q).each.to_a)
-        end
-      end
-    end
-  end
-end

data/test/factbase/indexed/test_indexed_query.rb

@@ -1,208 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase'
-require_relative '../../../lib/factbase/cached/cached_factbase'
-require_relative '../../../lib/factbase/indexed/indexed_factbase'
-
-# Query test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestIndexedQuery < Factbase::Test
-  def test_converts_to_string
-    fb = Factbase.new
-    fb.insert.foo = 42
-    refute_nil(Factbase::IndexedQuery.new(fb.query('(exists foo)'), {}, fb).to_s)
-  end
-
-  def test_queries_and_updates_origin
-    fb = Factbase.new
-    fb.insert.foo = 42
-    Factbase::IndexedQuery.new(fb.query('(exists foo)'), {}, fb).each do |f|
-      f.bar = 33
-    end
-    refute_empty(fb.query('(exists bar)').each.to_a)
-  end
-
-  def test_queries_many_times
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    total = 5
-    total.times { fb.insert }
-    total.times do
-      assert_equal(5, fb.query('(always)').each.to_a.size)
-    end
-  end
-
-  def test_finds_by_eq
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    fb.insert.foo = 42
-    fb.insert
-    3.times do
-      assert_equal(1, fb.query('(eq foo 42)').each.to_a.size)
-    end
-  end
-
-  def test_fills_up_the_index
-    idx = {}
-    fb = Factbase::IndexedFactbase.new(Factbase.new, idx)
-    fb.query('(eq x 1)').each.to_a
-    assert_equal(1, idx.size)
-    fb.insert
-    assert_empty(idx)
-  end
-
-  def test_finds_by_eq_with_symbol
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    f = fb.insert
-    f.num = 256
-    f.num = 42
-    fb.insert.num = 42
-    fb.insert.num = 55
-    fb.insert
-    fb.insert
-    3.times do
-      assert_equal(1, fb.query('(eq 1 (agg (eq num $num) (count)))').each.to_a.size)
-    end
-  end
-
-  def test_finds_by_eq_with_array
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    f = fb.insert
-    f.foo = 33
-    f.foo = 42
-    f.foo = 1
-    3.times do
-      assert_equal(1, fb.query('(eq foo 42)').each.to_a.size)
-    end
-  end
-
-  def test_finds_by_eq_with_agg
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    fb.insert.foo = 42
-    fb.insert.foo = 33
-    fb.insert
-    3.times do
-      assert_equal(1, fb.query('(eq foo (agg (exists foo) (max foo)))').each.to_a.size)
-    end
-  end
-
-  def test_finds_max_value
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    fb.insert.foo = 42
-    fb.insert.foo = 33
-    fb.insert
-    3.times do
-      assert_equal(42, fb.query('(agg (exists foo) (max foo))').one)
-    end
-  end
-
-  def test_finds_by_eq_with_formula
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    fb.insert.foo = 42
-    fb.insert
-    3.times do
-      assert_equal(1, fb.query('(eq foo (plus 40 2))').each.to_a.size)
-    end
-  end
-
-  def test_finds_by_eq_in_txn
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    fb.insert.foo = 42
-    fb.insert
-    3.times do
-      fb.txn { |fbt| assert_equal(1, fbt.query('(eq foo 42)').each.to_a.size) }
-    end
-  end
-
-  def test_finds_with_conjunction
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    fb.insert.foo = 42
-    fb.insert.bar = 33
-    3.times do
-      assert_equal(2, fb.query('(or (exists foo) (exists bar))').each.to_a.size)
-    end
-  end
-
-  def test_finds_with_disjunction
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    fb.insert.foo = 42
-    fb.insert.bar = 33
-    f = fb.insert
-    f.foo = 42
-    f.bar = 33
-    3.times do
-      assert_equal(1, fb.query('(and (exists foo) (exists bar))').each.to_a.size)
-    end
-  end
-
-  def test_finds_with_inversion
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    fb.insert.foo = 42
-    fb.insert.bar = 33
-    3.times do
-      assert_equal(1, fb.query('(not (exists foo))').each.to_a.size)
-    end
-  end
-
-  def test_finds_with_disjunction_in_txn
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    fb.insert.foo = 42
-    fb.insert.bar = 33
-    f = fb.insert
-    f.foo = 42
-    f.bar = 33
-    3.times do
-      fb.txn { |fbt| assert_equal(1, fbt.query('(and (exists foo) (exists bar))').each.to_a.size) }
-    end
-  end
-
-  def test_attaches_alias
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    total = 10
-    total.times do |i|
-      f = fb.insert
-      f.foo = rand(0..10)
-      f.bar = rand(0..10)
-      f.xyz = i
-    end
-    3.times do
-      assert_equal(total, fb.query('(as boom (agg (eq foo $bar) (min xyz)))').each.to_a.size)
-    end
-  end
-
-  def test_joins_simple_one
-    idx = {}
-    fb = Factbase::IndexedFactbase.new(Factbase.new, idx)
-    fb.insert.who = 4
-    fb.insert.friend = 4
-    assert_equal(1, fb.query('(and (exists who) (join "f<=friend" (eq friend $who)))').each.to_a.size)
-    assert_equal(2, idx.size)
-  end
-
-  def test_joins_too
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    total = 10_000
-    total.times do |i|
-      f = fb.insert
-      f.who = i
-    end
-    total.times do |i|
-      f = fb.insert
-      f.friend = i
-    end
-    3.times do
-      assert_equal(total, fb.query('(and (exists who) (join "f<=friend" (eq friend $who)))').each.to_a.size)
-    end
-  end
-
-  def test_deletes_too
-    fb = Factbase::IndexedFactbase.new(Factbase.new)
-    fb.insert.foo = 1
-    fb.query('(eq foo 1)').delete!
-    assert_equal(0, fb.query('(always)').each.to_a.size)
-  end
-end

data/test/factbase/indexed/test_indexed_term.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase'
-require_relative '../../../lib/factbase/term'
-require_relative '../../../lib/factbase/taped'
-require_relative '../../../lib/factbase/indexed/indexed_term'
-
-# Term test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestIndexedTerm < Factbase::Test
-  def test_predicts_on_eq
-    term = Factbase::Term.new(:eq, [:foo, 42])
-    idx = {}
-    term.redress!(Factbase::IndexedTerm, idx:)
-    maps = Factbase::Taped.new([{ 'foo' => [42] }, { 'bar' => [7] }, { 'foo' => [22, 42] }, { 'foo' => [] }])
-    n = term.predict(maps, {})
-    assert_equal(2, n.size)
-    assert_kind_of(Factbase::Taped, n)
-  end
-
-  def test_predicts_on_exists
-    term = Factbase::Term.new(:exists, [:foo])
-    idx = {}
-    term.redress!(Factbase::IndexedTerm, idx:)
-    maps = Factbase::Taped.new([{ 'foo' => [42] }, { 'bar' => [7] }, { 'foo' => [22, 42] }, { 'foo' => [] }])
-    n = term.predict(maps, {})
-    assert_equal(3, n.size)
-    assert_kind_of(Factbase::Taped, n)
-  end
-
-  def test_predicts_on_one
-    term = Factbase::Term.new(:one, [:foo])
-    idx = {}
-    term.redress!(Factbase::IndexedTerm, idx:)
-    maps = Factbase::Taped.new([{ 'foo' => [42] }, { 'bar' => [7] }, { 'foo' => [22, 42] }, { 'foo' => [] }])
-    n = term.predict(maps, {})
-    assert_equal(1, n.size)
-    assert_kind_of(Factbase::Taped, n)
-  end
-
-  def test_predicts_on_not
-    term = Factbase::Term.new(:not, [Factbase::Term.new(:eq, [:foo, 42])])
-    idx = {}
-    term.redress!(Factbase::IndexedTerm, idx:)
-    maps = Factbase::Taped.new([{ 'foo' => [42] }, { 'bar' => [7], 'foo' => [22, 42] }, { 'foo' => [22] }])
-    n = term.predict(maps, {})
-    assert_equal(1, n.size)
-    assert_kind_of(Factbase::Taped, n)
-  end
-
-  def test_predicts_on_and
-    term = Factbase::Term.new(
-      :and,
-      [
-        Factbase::Term.new(:eq, [:foo, 42]),
-        Factbase::Term.new(:eq, %i[bar $jeff])
-      ]
-    )
-    idx = {}
-    term.redress!(Factbase::IndexedTerm, idx:)
-    maps = Factbase::Taped.new([{ 'foo' => [42] }, { 'bar' => [7], 'foo' => [22, 42] }, { 'foo' => [22, 42] }])
-    n = term.predict(maps, Factbase::Tee.new({}, { 'jeff' => [7] }))
-    assert_equal(1, n.size)
-    assert_kind_of(Factbase::Taped, n)
-  end
-
-  def test_predicts_on_single_and
-    term = Factbase::Term.new(:and, [Factbase::Term.new(:eq, [:foo, 42])])
-    idx = {}
-    term.redress!(Factbase::IndexedTerm, idx:)
-    maps = Factbase::Taped.new([{ 'foo' => [42] }, { 'bar' => [7], 'foo' => [4] }])
-    assert_equal(1, term.predict(maps, {}).size)
-  end
-
-  def test_predicts_on_or
-    term = Factbase::Term.new(
-      :or,
-      [
-        Factbase::Term.new(:exists, [:bar]),
-        Factbase::Term.new(:eq, [:foo, 42]),
-        Factbase::Term.new(:eq, [:bar, 7])
-      ]
-    )
-    idx = {}
-    term.redress!(Factbase::IndexedTerm, idx:)
-    maps = Factbase::Taped.new([{ 'foo' => [42] }, { 'bar' => [7], 'foo' => [22, 42] }, { 'foo' => [22, 42] }])
-    n = term.predict(maps, {})
-    assert_equal(3, n.size)
-    assert_kind_of(Factbase::Taped, n)
-  end
-
-  def test_predicts_on_others
-    term = Factbase::Term.new(:boom, [])
-    idx = {}
-    term.redress!(Factbase::IndexedTerm, idx:)
-    maps = Factbase::Taped.new([{ 'foo' => [42] }, { 'alpha' => [] }, {}])
-    n = term.predict(maps, {})
-    assert_nil(n)
-  end
-
-  def test_predicts_on_gt
-    term = Factbase::Term.new(:gt, [:foo, 42])
-    idx = {}
-    term.redress!(Factbase::IndexedTerm, idx:)
-    maps = Factbase::Taped.new([
-                                 { 'foo' => [10] },
-                                 { 'foo' => [43] },
-                                 { 'foo' => [42] },
-                                 { 'foo' => [100, 5] },
-                                 { 'bar' => [50] },
-                                 { 'foo' => [41, 42, 43] }
-                               ])
-    n = term.predict(maps, {})
-    assert_equal(3, n.size)
-    assert_kind_of(Factbase::Taped, n)
-  end
-
-  def test_predicts_on_lt
-    term = Factbase::Term.new(:lt, [:foo, 42])
-    idx = {}
-    term.redress!(Factbase::IndexedTerm, idx:)
-    maps = Factbase::Taped.new([
-                                 { 'foo' => [10] },
-                                 { 'foo' => [43] },
-                                 { 'foo' => [42] },
-                                 { 'foo' => [100, 5] },
-                                 { 'bar' => [50] },
-                                 { 'foo' => [41, 42, 43] }
-                               ])
-    n = term.predict(maps, {})
-    assert_equal(3, n.size)
-    assert_kind_of(Factbase::Taped, n)
-  end
-end

data/test/factbase/sync/test_sync_factbase.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase'
-require_relative '../../../lib/factbase/sync/sync_factbase'
-
-# Sync factbase test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestSyncFactbase < Factbase::Test
-  def test_queries_and_inserts
-    fb = Factbase::SyncFactbase.new(Factbase.new)
-    fb.insert.foo = 42
-    fb.query('(exists foo)').each do
-      fb.insert
-    end
-  end
-end

data/test/factbase/sync/test_sync_query.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase'
-require_relative '../../../lib/factbase/sync/sync_factbase'
-
-# Query test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestSyncQuery < Factbase::Test
-  def test_queries_many_times
-    fb = Factbase::SyncFactbase.new(Factbase.new)
-    total = 5
-    total.times { fb.insert }
-    total.times do
-      assert_equal(5, fb.query('(always)').each.to_a.size)
-    end
-  end
-
-  def test_deletes_too
-    fb = Factbase::SyncFactbase.new(Factbase.new)
-    fb.insert.foo = 1
-    fb.query('(eq foo 1)').delete!
-    assert_equal(0, fb.query('(always)').each.to_a.size)
-  end
-end

data/test/factbase/terms/test_aggregates.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase/term'
-require_relative '../../../lib/factbase/syntax'
-
-# Aggregates test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestAggregates < Factbase::Test
-  def test_aggregation
-    maps = [
-      { 'x' => [1], 'y' => [0], 'z' => [4] },
-      { 'x' => [2], 'y' => [42], 'z' => [3] },
-      { 'x' => [3], 'y' => [42], 'z' => [5] },
-      { 'x' => [4], 'y' => [42], 'z' => [2] },
-      { 'x' => [5], 'y' => [42], 'z' => [1] },
-      { 'x' => [8], 'y' => [0], 'z' => [6] }
-    ]
-    {
-      '(eq x (agg (eq y 42) (min x)))' => '(eq x 2)',
-      '(eq z (agg (eq y 0) (max z)))' => '(eq x 8)',
-      '(eq x (agg (and (eq y 42) (gt z 1)) (max x)))' => '(eq x 4)',
-      '(and (eq x (agg (eq y 42) (min x))) (eq z 3))' => '(eq x 2)',
-      '(eq x (agg (eq y 0) (nth 0 x)))' => '(eq x 1)',
-      '(eq x (agg (eq y 0) (first x)))' => '(eq x 1)',
-      '(agg (eq foo 42) (always))' => '(eq x 1)'
-    }.each do |q, r|
-      t = Factbase::Syntax.new(q).to_term
-      f = maps.find { |m| t.evaluate(fact(m), maps, Factbase.new) }
-      refute_nil(f, "nothing found by: #{q}")
-      assert(Factbase::Syntax.new(r).to_term.evaluate(fact(f), [], Factbase.new))
-    end
-  end
-
-  def test_empty
-    maps = [
-      { 'x' => [1], 'y' => [0], 'z' => [4] },
-      { 'x' => [8], 'y' => [0] }
-    ]
-    {
-      '(empty (eq y 42))' => true,
-      '(empty (eq x 1))' => false
-    }.each do |q, r|
-      t = Factbase::Syntax.new(q).to_term
-      assert_equal(r, t.evaluate(Factbase::Fact.new({}), maps, Factbase.new), q)
-    end
-  end
-
-  def test_empty_with_params
-    maps = [
-      { 'a' => [3], 'b' => [44] },
-      { 'a' => [4], 'b' => [55] }
-    ]
-    t = Factbase::Syntax.new('(empty (eq b $x))').to_term
-    assert(t.evaluate(Factbase::Fact.new({ 'x' => [42] }), maps, Factbase.new))
-    refute(t.evaluate(Factbase::Fact.new({ 'x' => [44] }), maps, Factbase.new))
-  end
-end