code: def test_combinations():
      seed(1234)  # random seed
  
      # XXX: archive/cache should allow scalar and list, also dict (as new table) ?
      dicts = [
          {},
          {"a": 1},
          {"a": [1, 2]},
          {"a": {"x": 3}},
      ]
      init = dicts[0]
  
      archives = [
          null_archive(None, init),
          dict_archive(None, init),
          file_archive(None, init, serialized=True),
          file_archive(None, init, serialized=False),
          file_archive("xxxx.pkl", init, serialized=True),
          file_archive("xxxx.py", init, serialized=False),
          dir_archive("memoi", init, serialized=False),
          dir_archive("memop", init, serialized=True),
          dir_archive("memoj", init, serialized=True, fast=True),
          dir_archive("memoz", init, serialized=True, compression=1),
          dir_archive("memom", init, serialized=True, memmode="r+"),
          # sqltable_archive(None,init),
          # sqltable_archive('sqlite:///memo.db',init),
          # sqltable_archive('memo',init),
          # sql_archive(None,init),
          # sql_archive('sqlite:///memo.db',init),
          # sql_archive('memo',init),
      ]
      # FIXME: even 'safe' archives throw Error when cache.load, cache.dump fails
      #       (often demonstrated in sqltable_archive, as barfs on tuple & dict)
  
      # XXX: when running a single map, there should be 3 possible results:
      #     1) flat=False may produce unhashable keys: all misses
      #     2) typed=False doesn't distinguish float & int: more hits & loads
      #     3) typed=True distingushes float & int: less hits & loads
      # XXX: due to the seed, each of the 3 cases should yield the same results
      maps = [
          None,
          keymap(typed=False, flat=True, sentinel=NOSENTINEL),
          keymap(typed=False, flat=False, sentinel=NOSENTINEL),
          # FIXME: keymap of (typed=True,flat=True) fails w/ dir_archive on Windows b/c
          #     keymap(typed=True, flat=True, sentinel=NOSENTINEL), # bad directory name?
          keymap(typed=True, flat=False, sentinel=NOSENTINEL),
          # keymap(typed=False, flat=True, sentinel=SENTINEL),
          # keymap(typed=False, flat=False, sentinel=SENTINEL),
          # keymap(typed=True, flat=True, sentinel=SENTINEL),
          # keymap(typed=True, flat=False, sentinel=SENTINEL),
          hashmap(typed=False, flat=True, sentinel=NOSENTINEL),
          hashmap(typed=False, flat=False, sentinel=NOSENTINEL),
          hashmap(typed=True, flat=True, sentinel=NOSENTINEL),
          hashmap(typed=True, flat=False, sentinel=NOSENTINEL),
          # hashmap(typed=False, flat=True, sentinel=SENTINEL),
          # hashmap(typed=False, flat=False, sentinel=SENTINEL),
          # hashmap(typed=True, flat=True, sentinel=SENTINEL),
          # hashmap(typed=True, flat=False, sentinel=SENTINEL),
          stringmap(typed=False, flat=True, sentinel=NOSENTINEL),
          stringmap(typed=False, flat=False, sentinel=NOSENTINEL),
          stringmap(typed=True, flat=True, sentinel=NOSENTINEL),
          stringmap(typed=True, flat=False, sentinel=NOSENTINEL),
          # stringmap(typed=False, flat=True, sentinel=SENTINEL),
          # stringmap(typed=False, flat=False, sentinel=SENTINEL),
          # stringmap(typed=True, flat=True, sentinel=SENTINEL),
          # stringmap(typed=True, flat=False, sentinel=SENTINEL),
          picklemap(typed=False, flat=True, sentinel=NOSENTINEL),
          picklemap(typed=False, flat=False, sentinel=NOSENTINEL),
          picklemap(typed=True, flat=True, sentinel=NOSENTINEL),
          picklemap(typed=True, flat=False, sentinel=NOSENTINEL),
          # picklemap(typed=False, flat=True, sentinel=SENTINEL),
          # picklemap(typed=False, flat=False, sentinel=SENTINEL),
          # picklemap(typed=True, flat=True, sentinel=SENTINEL),
          # picklemap(typed=True, flat=False, sentinel=SENTINEL),
      ]
      # XXX: should have option to serialize value (as well as key) ?
  
      for mapper in maps:
          # print (mapper)
          func = [_test_cache(cache, mapper) for cache in archives]
          _cleanup()
  
          for f in func:
              # print (f.info())
              assert f.info().hit + f.info().miss + f.info().load == N
  
file_path: klepto/klepto/tests/test_basic.py
imports: from klepto.safe import lru_cache
  from random import choice, seed
  from klepto.archives import *
  from klepto.keymaps import keymap, hashmap, stringmap, picklemap
  from klepto.keymaps import SENTINEL, NOSENTINEL
label_desc: Use image node_id 3 for calling a global function with example usage: test_combinations() without return types