@@@ remove debugging print

[mLib-python] / t / t-atom.py

### -*-python-*-
###
### Test atoms and related functionality
###
### (c) 2019 Straylight/Edgeware
###

###----- Licensing notice ---------------------------------------------------
###
### This file is part of the Python interface to mLib.
###
### mLib/Python is free software: you can redistribute it and/or modify it
### under the terms of the GNU General Public License as published by the
### Free Software Foundation; either version 2 of the License, or (at your
### option) any later version.
###
### mLib/Python is distributed in the hope that it will be useful, but
### WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
### General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with mLib/Python.  If not, write to the Free Software
### Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
### USA.

import mLib as M
import testutils as T
import unittest as U

###--------------------------------------------------------------------------
class TestAtoms (U.TestCase):

  def test_simple(me):
    foo = M.Atom("foo")
    bar = M.Atom("bar")
    me.assertTrue(foo is M.Atom("foo"))
    me.assertTrue(foo is not bar)
    me.assertEqual(foo, foo)
    me.assertNotEqual(foo, bar)
    me.assertEqual(set(M.atoms()), set([foo, bar]))
    me.assertEqual(foo.name, "foo")
    me.assertTrue(foo.internedp)
    me.assertEqual(foo.home, M.DEFAULT_ATOMTABLE)

  def test_obarray(me):
    tab = M.AtomTable()
    foo = tab.intern("foo")
    bar = M.Atom("bar", tab)
    g0 = tab.gensym()
    g1 = M.Atom(table = tab)
    me.assertEqual(bar, tab.intern("bar"))
    me.assertNotEqual(foo, M.Atom("foo"))
    for sym in [foo, bar, g0, g1]:
      me.assertEqual(sym.home, tab)
      me.assertTrue(sym.livep)
    for sym in [foo, bar]: me.assertTrue(sym.internedp)
    for sym in [g0, g1]: me.assertFalse(sym.internedp)
    me.assertEqual(tab["foo"], foo)
    me.assertEqual(tab.get("spong"), None)
    me.assertFalse("spong" in tab)
    spong = tab["spong"]
    me.assertTrue("spong" in tab)
    me.assertEqual(set(T.itervalues(tab)), set([foo, bar, spong, g0, g1]))
    del tab
    for sym in [foo, bar, spong, g0, g1]: me.assertFalse(sym.livep)
    me.assertRaises(ValueError, getattr, foo, "name")

    tab = M.AtomTable()
    a = tab["a"]
    me.assertRaises(TypeError, M.Atom, None, tab, foo = "extra!")
    me.assertRaises(TypeError, M.Atom, table = tab, bar = "extra!")
    me.assertRaises(TypeError, M.Atom, None, tab, "extra!")
    me.assertTrue(a.livep)
    del tab
    me.assertFalse(a.livep)


###--------------------------------------------------------------------------
class TestAssoc (T.MutableMappingTestMixin):

  def setUp(me):
    me._obarray = M.AtomTable()

  def _mkkey(me, i): return me._obarray["k#%d" % i]
  def _getkey(me, k): return int(k.name[2:])

  def test_mapping(me):
    me.check_mapping(lambda: M.AssocTable(None, me._obarray))

  def test_assoc(me):
    obarray = me._obarray
    foo = obarray["foo"]
    bar = obarray["bar"]
    baz = obarray["baz"]
    tab = M.AssocTable({ foo: 1 }, obarray, bar = 2)
    me.assertEqual(tab.table, obarray)
    me.assertEqual(tab["foo"], 1)
    me.assertEqual(tab[bar], 2)
    me.assertRaises(ValueError, tab.get, M.Atom("foo"))

###----- That's all, folks --------------------------------------------------

if __name__ == "__main__": U.main()