def test_load_unknown_class(self):
        def class_loader(x):
            return None

        pyamf.register_class_loader(class_loader)

        self.assertRaises(pyamf.UnknownClassAlias, pyamf.load_class, 'spam.eggs')

    def test_load_class_bad_return(self):
        def class_loader(x):
            return 'xyz'

        pyamf.register_class_loader(class_loader)

        self.assertRaises(TypeError, pyamf.load_class, 'spam.eggs')

    def test_unregister(self):
        self.assertTrue(chr not in pyamf.CLASS_LOADERS)
        pyamf.register_class_loader(chr)
        self.assertTrue(chr in pyamf.CLASS_LOADERS)

        pyamf.unregister_class_loader(chr)
        self.assertTrue(chr not in pyamf.CLASS_LOADERS)

        self.assertRaises(LookupError, pyamf.unregister_class_loader, chr)

    def test_load_class_by_alias(self):
        def class_loader(x):
            self.assertEqual(x, 'spam.eggs')
            return pyamf.ClassAlias(Spam, 'spam.eggs')

        pyamf.register_class_loader(class_loader)

        self.assertTrue('spam.eggs' not in pyamf.CLASS_CACHE.keys())
        pyamf.load_class('spam.eggs')
        self.assertTrue('spam.eggs' in pyamf.CLASS_CACHE.keys())

    def test_load_class_by_alias(self):
        def class_loader(x):
            self.assertEquals(x, "spam.eggs")
            return pyamf.ClassAlias(Spam, "spam.eggs")

        pyamf.register_class_loader(class_loader)

        self.assertTrue("spam.eggs" not in pyamf.CLASS_CACHE.keys())
        pyamf.load_class("spam.eggs")
        self.assertTrue("spam.eggs" in pyamf.CLASS_CACHE.keys())

 def test_bad_register(self):
     self.assertRaises(TypeError, pyamf.register_class_loader, 1)
     pyamf.register_class_loader(ord)

 def test_register(self):
     self.assertTrue(chr not in pyamf.CLASS_LOADERS)
     pyamf.register_class_loader(chr)
     self.assertTrue(chr in pyamf.CLASS_LOADERS)

        def __init__(self, alias):
            dict.__init__(self)

        def __readamf__(self, input):
            data = input.readObject()
            self["data"] = data

    def pyamf_class_loader(s):
        for i in pyamf.CLASS_LOADERS:
            if i != pyamf_class_loader:
                v = i(s)
                if v:
                    return v
        return DummyObject

    pyamf.register_class_loader(pyamf_class_loader)

    class ViewAMF:
        name = "AMF"
        prompt = ("amf", "f")
        content_types = ["application/x-amf"]

        def unpack(self, b, seen=set([])):
            if hasattr(b, "body"):
                return self.unpack(b.body, seen)
            if isinstance(b, DummyObject):
                if id(b) in seen:
                    return "<recursion>"
                else:
                    seen.add(id(b))
                    for k, v in b.items():

"""


def register_alias(cls, alias, static_attrs=None, exclude_attrs=None, dynamic=True):
    if static_attrs is None and hasattr(cls, '__slots__'):
        static_attrs = cls.__slots__
    class_alias = ClassAlias(cls, alias, static_attrs=static_attrs, exclude_attrs=exclude_attrs, dynamic=dynamic)
    _amf_aliases[alias] = class_alias
    CLASS_CACHE[cls] = class_alias


def _class_loader(alias):
    return _amf_aliases.get(alias)


register_class_loader(_class_loader)


def _keys_to_string(s):
    if isinstance(s, dict):
        re = {}
        for k, v in s.iteritems():
            k = unicode(k)
            if not k:
                continue
            re[k] = _keys_to_string(v)
        return re
    elif isinstance(s, (list, tuple, set)):
        re = []
        for v in s:
            re.append(_keys_to_string(v))