From 66b8d57f0c054065894ab3dd0f1640594013e441 Mon Sep 17 00:00:00 2001 From: Cyrille Bagard Date: Sat, 20 Feb 2021 01:26:09 +0100 Subject: Compute a hash value for data types. --- plugins/pychrysalide/analysis/type.c | 100 +++++++++++++++++++++++++++++++++++ src/analysis/type-int.h | 4 ++ src/analysis/type.c | 31 +++++++++++ src/analysis/type.h | 3 ++ src/analysis/types/array.c | 32 +++++++++++ src/analysis/types/basic.c | 27 ++++++++++ src/analysis/types/cse.c | 29 ++++++++++ src/analysis/types/encaps.c | 31 +++++++++++ src/analysis/types/expr.c | 27 ++++++++++ src/analysis/types/literal.c | 32 +++++++++++ src/analysis/types/override.c | 27 ++++++++++ src/analysis/types/proto.c | 34 ++++++++++++ src/analysis/types/template.c | 34 ++++++++++++ tests/analysis/type.py | 17 ++++++ 14 files changed, 428 insertions(+) diff --git a/plugins/pychrysalide/analysis/type.c b/plugins/pychrysalide/analysis/type.c index cd849e4..d2801bf 100644 --- a/plugins/pychrysalide/analysis/type.c +++ b/plugins/pychrysalide/analysis/type.c @@ -52,6 +52,9 @@ static PyObject *py_data_type_new(PyTypeObject *, PyObject *, PyObject *); /* Initialise la classe des types quelconques. */ static void py_data_type_init_gclass(GDataTypeClass *, gpointer); +/* Calcule une empreinte pour un type de données. */ +static guint py_data_type_hash_wrapper(const GDataType *); + /* Crée un copie d'un type existant. */ static GDataType *py_data_type_dup_wrapper(const GDataType *); @@ -81,6 +84,9 @@ static PyObject *py_data_type_to_str(PyObject *); /* Crée un copie d'un type existant. */ static PyObject *py_data_type_dup(PyObject *, PyObject *); +/* Calcule une empreinte pour un type de données. */ +static PyObject *py_data_type_get_hash(PyObject *, void *); + /* Fournit le groupe d'appartenance d'un type donné. */ static PyObject *py_data_type_get_namespace(PyObject *, void *); @@ -187,6 +193,7 @@ static PyObject *py_data_type_new(PyTypeObject *type, PyObject *args, PyObject * static void py_data_type_init_gclass(GDataTypeClass *class, gpointer unused) { + class->hash = py_data_type_hash_wrapper; class->dup = py_data_type_dup_wrapper; class->to_string = py_data_type_to_string_wrapper; @@ -199,6 +206,58 @@ static void py_data_type_init_gclass(GDataTypeClass *class, gpointer unused) /****************************************************************************** * * +* Paramètres : type = type à consulter. * +* * +* Description : Calcule une empreinte pour un type de données. * +* * +* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static guint py_data_type_hash_wrapper(const GDataType *type) +{ + guint result; /* Empreinte à renvoyer */ + PyObject *pyobj; /* Objet Python concerné */ + PyObject *pyret; /* Bilan de consultation */ + +#define DATA_TYPE_HASH_WRAPPER PYTHON_WRAPPER_DEF \ +( \ + _hash, "$self, /", \ + METH_NOARGS, \ + "Abstract method used to create a hash of the data type.\n" \ + "\n" \ + "The returned value has to be a 32-bit integer." \ +) + + result = 0; + + pyobj = pygobject_new(G_OBJECT(type)); + + if (has_python_method(pyobj, "_hash")) + { + pyret = run_python_method(pyobj, "_hash", NULL); + + if (pyret != NULL) + { + if (PyLong_Check(pyret)) + result = PyLong_AsUnsignedLong(pyret); + } + + Py_XDECREF(pyret); + + } + + Py_DECREF(pyobj); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à dupliquer. * * * * Description : Crée un copie d'un type existant. * @@ -496,6 +555,7 @@ static int py_data_type_init(PyObject *self, PyObject *args, PyObject *kwds) " DataType()" \ "\n" \ "The following methods have to be defined for new classes:\n" \ + "* pychrysalide.analysis.DataType._hash();\n" \ "* pychrysalide.analysis.DataType._dup();\n" \ "* pychrysalide.analysis.DataType._to_string()." \ "\n" \ @@ -606,6 +666,44 @@ static PyObject *py_data_type_dup(PyObject *self, PyObject *args) * Paramètres : self = objet Python concerné par l'appel. * * closure = non utilisé ici. * * * +* Description : Calcule une empreinte pour un type de données. * +* * +* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_data_type_get_hash(PyObject *self, void *closure) +{ + PyObject *result; /* Valeur à retourner */ + GDataType *type; /* Elément à consulter */ + guint hash; /* Empreinte à transmettre */ + +#define DATA_TYPE_HASH_ATTRIB PYTHON_GET_DEF_FULL \ +( \ + hash, py_data_type, \ + "Hash value for the type, as a 32-bit integer.\n" \ + "\n" \ + "Each proporty change implies a hash change." \ +) + + type = G_DATA_TYPE(pygobject_get(self)); + + hash = g_data_type_hash(type); + + result = PyLong_FromUnsignedLong(hash); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = objet Python concerné par l'appel. * +* closure = non utilisé ici. * +* * * Description : Fournit le groupe d'appartenance d'un type donné. * * * * Retour : Eventuelle instance d'appartenance ou None. * @@ -913,6 +1011,7 @@ static PyObject *py_data_type_is_reference(PyObject *self, void *closure) PyTypeObject *get_python_data_type_type(void) { static PyMethodDef py_data_type_methods[] = { + DATA_TYPE_HASH_WRAPPER, DATA_TYPE_DUP_WRAPPER, DATA_TYPE_TO_STRING_WRAPPER, DATA_TYPE_HANDLE_NAMESPACES_WRAPPER, @@ -922,6 +1021,7 @@ PyTypeObject *get_python_data_type_type(void) }; static PyGetSetDef py_data_type_getseters[] = { + DATA_TYPE_HASH_ATTRIB, DATA_TYPE_NAMESPACE_ATTRIB, DATA_TYPE_QUALIFIERS_ATTRIB, DATA_TYPE_NAMESPACES_ATTRIB, diff --git a/src/analysis/type-int.h b/src/analysis/type-int.h index f553bf3..2c70c7b 100644 --- a/src/analysis/type-int.h +++ b/src/analysis/type-int.h @@ -29,6 +29,9 @@ +/* Calcule une empreinte pour un type de données. */ +typedef guint (* type_hash_fc) (const GDataType *); + /* Décrit le type fourni sous forme de caractères. */ typedef GDataType * (* type_dup_fc) (const GDataType *); @@ -63,6 +66,7 @@ struct _GDataTypeClass { GObjectClass parent; /* A laisser en premier */ + type_hash_fc hash; /* Prise d'empreinte */ type_dup_fc dup; /* Copie d'instance existante */ type_to_string_fc to_string; /* Conversion au format texte */ diff --git a/src/analysis/type.c b/src/analysis/type.c index 9a8e85b..350b4e2 100644 --- a/src/analysis/type.c +++ b/src/analysis/type.c @@ -138,6 +138,37 @@ static void g_data_type_finalize(GDataType *type) /****************************************************************************** * * +* Paramètres : type = type à consulter. * +* * +* Description : Calcule une empreinte pour un type de données. * +* * +* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. * +* * +* Remarques : - * +* * +******************************************************************************/ + +guint g_data_type_hash(const GDataType *type) +{ + guint result; /* Empreinte à renvoyer */ + GDataTypeClass *class; /* Classe du type */ + + class = G_DATA_TYPE_GET_CLASS(type); + + result = class->hash(type); + + result ^= g_int_hash((gint []){ g_data_type_get_qualifiers(type) }); + + if (type->namespace != NULL) + result ^= g_data_type_hash(type->namespace); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à dupliquer. * * * * Description : Crée un copie d'un type existant. * diff --git a/src/analysis/type.h b/src/analysis/type.h index 000c557..8fccbb5 100644 --- a/src/analysis/type.h +++ b/src/analysis/type.h @@ -63,6 +63,9 @@ typedef enum _TypeQualifier /* Indique le type défini pour un type quelconque. */ GType g_data_type_get_type(void); +/* Calcule une empreinte pour un type de données. */ +guint g_data_type_hash(const GDataType *); + /* Crée un copie d'un type existant. */ GDataType *g_data_type_dup(const GDataType *); diff --git a/src/analysis/types/array.c b/src/analysis/types/array.c index 5aea07b..5ea4179 100644 --- a/src/analysis/types/array.c +++ b/src/analysis/types/array.c @@ -72,6 +72,9 @@ static void g_array_type_dispose(GArrayType *); /* Procède à la libération totale de la mémoire. */ static void g_array_type_finalize(GArrayType *); +/* Calcule une empreinte pour un type de données. */ +static guint g_array_type_hash(const GArrayType *); + /* Crée un copie d'un type existant. */ static GDataType *g_array_type_dup(const GArrayType *); @@ -108,6 +111,7 @@ static void g_array_type_class_init(GArrayTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->hash = (type_hash_fc)g_array_type_hash; type->dup = (type_dup_fc)g_array_type_dup; type->to_string = (type_to_string_fc)g_array_type_to_string; @@ -206,6 +210,34 @@ GDataType *g_array_type_new(GDataType *members) /****************************************************************************** * * +* Paramètres : type = type à consulter. * +* * +* Description : Calcule une empreinte pour un type de données. * +* * +* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static guint g_array_type_hash(const GArrayType *type) +{ + guint result; /* Empreinte à renvoyer */ + + if (type->numbered) + result = g_int_hash((gint []){ type->dim_number }); + else + result = g_str_hash(type->dim_expr); + + result ^= g_data_type_hash(type->members); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à dupliquer. * * * * Description : Crée un copie d'un type existant. * diff --git a/src/analysis/types/basic.c b/src/analysis/types/basic.c index a907f2d..038bfb0 100644 --- a/src/analysis/types/basic.c +++ b/src/analysis/types/basic.c @@ -61,6 +61,9 @@ static void g_basic_type_dispose(GBasicType *); /* Procède à la libération totale de la mémoire. */ static void g_basic_type_finalize(GBasicType *); +/* Calcule une empreinte pour un type de données. */ +static guint g_basic_type_hash(const GBasicType *); + /* Crée un copie d'un type existant. */ static GDataType *g_basic_type_dup(const GBasicType *); @@ -97,6 +100,7 @@ static void g_basic_type_class_init(GBasicTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->hash = (type_hash_fc)g_basic_type_hash; type->dup = (type_dup_fc)g_basic_type_dup; type->to_string = (type_to_string_fc)g_basic_type_to_string; @@ -187,6 +191,29 @@ GDataType *g_basic_type_new(BaseType type) /****************************************************************************** * * +* Paramètres : type = type à consulter. * +* * +* Description : Calcule une empreinte pour un type de données. * +* * +* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static guint g_basic_type_hash(const GBasicType *type) +{ + guint result; /* Empreinte à renvoyer */ + + result = g_int_hash((gint []){ g_basic_type_get_base(type) }); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à dupliquer. * * * * Description : Crée un copie d'un type existant. * diff --git a/src/analysis/types/cse.c b/src/analysis/types/cse.c index 9f9adcd..c79ea72 100644 --- a/src/analysis/types/cse.c +++ b/src/analysis/types/cse.c @@ -62,6 +62,9 @@ static void g_class_enum_type_dispose(GClassEnumType *); /* Procède à la libération totale de la mémoire. */ static void g_class_enum_type_finalize(GClassEnumType *); +/* Calcule une empreinte pour un type de données. */ +static guint g_class_enum_type_hash(const GClassEnumType *); + /* Crée un copie d'un type existant. */ static GDataType *g_class_enum_type_dup(const GClassEnumType *); @@ -98,6 +101,7 @@ static void g_class_enum_type_class_init(GClassEnumTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->hash = (type_hash_fc)g_class_enum_type_hash; type->dup = (type_dup_fc)g_class_enum_type_dup; type->to_string = (type_to_string_fc)g_class_enum_type_to_string; @@ -194,6 +198,31 @@ GDataType *g_class_enum_type_new(ClassEnumKind kind, char *name) /****************************************************************************** * * +* Paramètres : type = type à consulter. * +* * +* Description : Calcule une empreinte pour un type de données. * +* * +* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static guint g_class_enum_type_hash(const GClassEnumType *type) +{ + guint result; /* Empreinte à renvoyer */ + + result = g_int_hash((gint []){ g_class_enum_type_get_kind(type) }); + + result ^= g_str_hash(type->name); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à dupliquer. * * * * Description : Crée un copie d'un type existant. * diff --git a/src/analysis/types/encaps.c b/src/analysis/types/encaps.c index d59516d..8e2641f 100644 --- a/src/analysis/types/encaps.c +++ b/src/analysis/types/encaps.c @@ -65,6 +65,9 @@ static void g_encapsulated_type_dispose(GEncapsulatedType *); /* Procède à la libération totale de la mémoire. */ static void g_encapsulated_type_finalize(GEncapsulatedType *); +/* Calcule une empreinte pour un type de données. */ +static guint g_encapsulated_type_hash(const GEncapsulatedType *); + /* Crée un copie d'un type existant. */ static GDataType *g_encapsulated_type_dup(const GEncapsulatedType *); @@ -107,6 +110,7 @@ static void g_encapsulated_type_class_init(GEncapsulatedTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->hash = (type_hash_fc)g_encapsulated_type_hash; type->dup = (type_dup_fc)g_encapsulated_type_dup; type->to_string = (type_to_string_fc)g_encapsulated_type_to_string; @@ -208,6 +212,33 @@ GDataType *g_encapsulated_type_new(EncapsulationType type, GDataType *child) /****************************************************************************** * * +* Paramètres : type = type à consulter. * +* * +* Description : Calcule une empreinte pour un type de données. * +* * +* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static guint g_encapsulated_type_hash(const GEncapsulatedType *type) +{ + guint result; /* Empreinte à renvoyer */ + + result = g_int_hash((gint []){ g_encapsulated_type_get_etype(type) }); + + result ^= g_data_type_hash(type->child); + + result ^= g_int_hash((gint []){ g_encapsulated_type_get_dimension(type) }); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à dupliquer. * * * * Description : Crée un copie d'un type existant. * diff --git a/src/analysis/types/expr.c b/src/analysis/types/expr.c index 02005f4..1119ab6 100644 --- a/src/analysis/types/expr.c +++ b/src/analysis/types/expr.c @@ -61,6 +61,9 @@ static void g_expr_type_dispose(GExprType *); /* Procède à la libération totale de la mémoire. */ static void g_expr_type_finalize(GExprType *); +/* Calcule une empreinte pour un type de données. */ +static guint g_expr_type_hash(const GExprType *); + /* Crée un copie d'un type existant. */ static GDataType *g_expr_type_dup(const GExprType *); @@ -97,6 +100,7 @@ static void g_expr_type_class_init(GExprTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->hash = (type_hash_fc)g_expr_type_hash; type->dup = (type_dup_fc)g_expr_type_dup; type->to_string = (type_to_string_fc)g_expr_type_to_string; @@ -190,6 +194,29 @@ GDataType *g_expr_type_new(const char *value) /****************************************************************************** * * +* Paramètres : type = type à consulter. * +* * +* Description : Calcule une empreinte pour un type de données. * +* * +* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static guint g_expr_type_hash(const GExprType *type) +{ + guint result; /* Empreinte à renvoyer */ + + result = g_str_hash(type->value); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à dupliquer. * * * * Description : Crée un copie d'un type existant. * diff --git a/src/analysis/types/literal.c b/src/analysis/types/literal.c index 3a9e5cf..addab5a 100644 --- a/src/analysis/types/literal.c +++ b/src/analysis/types/literal.c @@ -64,6 +64,9 @@ static void g_literal_type_dispose(GLiteralType *); /* Procède à la libération totale de la mémoire. */ static void g_literal_type_finalize(GLiteralType *); +/* Calcule une empreinte pour un type de données. */ +static guint g_literal_type_hash(const GLiteralType *); + /* Crée un copie d'un type existant. */ static GDataType *g_literal_type_dup(const GLiteralType *); @@ -100,6 +103,7 @@ static void g_literal_type_class_init(GLiteralTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->hash = (type_hash_fc)g_literal_type_hash; type->dup = (type_dup_fc)g_literal_type_dup; type->to_string = (type_to_string_fc)g_literal_type_to_string; @@ -202,6 +206,34 @@ GDataType *g_literal_type_new(GDataType *orig, const literal_value *value) /****************************************************************************** * * +* Paramètres : type = type à consulter. * +* * +* Description : Calcule une empreinte pour un type de données. * +* * +* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static guint g_literal_type_hash(const GLiteralType *type) +{ + guint result; /* Empreinte à renvoyer */ + + result = g_data_type_hash(type->orig); + + if (g_basic_type_get_base(G_BASIC_TYPE(type->orig)) == BTP_FLOAT) + result ^= g_double_hash((gdouble []){ type->value.float_val }); + else + result ^= g_int_hash((gint []){ type->value.int_val }); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à dupliquer. * * * * Description : Crée un copie d'un type existant. * diff --git a/src/analysis/types/override.c b/src/analysis/types/override.c index a535e80..841f10c 100644 --- a/src/analysis/types/override.c +++ b/src/analysis/types/override.c @@ -65,6 +65,9 @@ static void g_override_type_dispose(GOverrideType *); /* Procède à la libération totale de la mémoire. */ static void g_override_type_finalize(GOverrideType *); +/* Calcule une empreinte pour un type de données. */ +static guint g_override_type_hash(const GOverrideType *); + /* Crée un copie d'un type existant. */ static GDataType *g_override_type_dup(const GOverrideType *); @@ -101,6 +104,7 @@ static void g_override_type_class_init(GOverrideTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->hash = (type_hash_fc)g_override_type_hash; type->dup = (type_dup_fc)g_override_type_dup; type->to_string = (type_to_string_fc)g_override_type_to_string; @@ -229,6 +233,29 @@ GDataType *g_override_type_new_with_covariant(GDataType *base, const call_offset /****************************************************************************** * * +* Paramètres : type = type à consulter. * +* * +* Description : Calcule une empreinte pour un type de données. * +* * +* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static guint g_override_type_hash(const GOverrideType *type) +{ + guint result; /* Empreinte à renvoyer */ + + result = g_data_type_hash(type->base); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à dupliquer. * * * * Description : Crée un copie d'un type existant. * diff --git a/src/analysis/types/proto.c b/src/analysis/types/proto.c index 8d5b897..135c15a 100644 --- a/src/analysis/types/proto.c +++ b/src/analysis/types/proto.c @@ -66,6 +66,9 @@ static void g_proto_type_dispose(GProtoType *); /* Procède à la libération totale de la mémoire. */ static void g_proto_type_finalize(GProtoType *); +/* Calcule une empreinte pour un type de données. */ +static guint g_proto_type_hash(const GProtoType *); + /* Crée un copie d'un type existant. */ static GDataType *g_proto_type_dup(const GProtoType *); @@ -105,6 +108,7 @@ static void g_proto_type_class_init(GProtoTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->hash = (type_hash_fc)g_proto_type_hash; type->dup = (type_dup_fc)g_proto_type_dup; type->to_string = (type_to_string_fc)g_proto_type_to_string; @@ -209,6 +213,36 @@ GDataType *g_proto_type_new(void) /****************************************************************************** * * +* Paramètres : type = type à consulter. * +* * +* Description : Calcule une empreinte pour un type de données. * +* * +* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static guint g_proto_type_hash(const GProtoType *type) +{ + guint result; /* Empreinte à renvoyer */ + size_t i; /* Boucle de parcours */ + + if (type->ret_type == NULL) + result = 0; + else + result = g_data_type_hash(type->ret_type); + + for (i = 0; i < type->count; i++) + result ^= g_data_type_hash(type->args[i]); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à dupliquer. * * * * Description : Crée un copie d'un type existant. * diff --git a/src/analysis/types/template.c b/src/analysis/types/template.c index 75879f4..3a58169 100644 --- a/src/analysis/types/template.c +++ b/src/analysis/types/template.c @@ -66,6 +66,9 @@ static void g_template_type_dispose(GTemplateType *); /* Procède à la libération totale de la mémoire. */ static void g_template_type_finalize(GTemplateType *); +/* Calcule une empreinte pour un type de données. */ +static guint g_template_type_hash(const GTemplateType *); + /* Crée un copie d'un type existant. */ static GDataType *g_template_type_dup(const GTemplateType *); @@ -102,6 +105,7 @@ static void g_template_type_class_init(GTemplateTypeClass *klass) type = G_DATA_TYPE_CLASS(klass); + type->hash = (type_hash_fc)g_template_type_hash; type->dup = (type_dup_fc)g_template_type_dup; type->to_string = (type_to_string_fc)g_template_type_to_string; @@ -253,6 +257,36 @@ void g_template_type_set_name(GTemplateType *type, const char *name) /****************************************************************************** * * +* Paramètres : type = type à consulter. * +* * +* Description : Calcule une empreinte pour un type de données. * +* * +* Retour : Valeur arbitraire sur 32 bits, idéalement unique par type. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static guint g_template_type_hash(const GTemplateType *type) +{ + guint result; /* Empreinte à renvoyer */ + size_t i; /* Boucle de parcours */ + + if (type->name == NULL) + result = 0; + else + result = g_str_hash(type->name); + + for (i = 0; i < type->count; i++) + result ^= g_data_type_hash(type->params[i]); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : type = type à dupliquer. * * * * Description : Crée un copie d'un type existant. * diff --git a/tests/analysis/type.py b/tests/analysis/type.py index 5106cbc..b690a55 100644 --- a/tests/analysis/type.py +++ b/tests/analysis/type.py @@ -90,3 +90,20 @@ class TestDataType(ChrysalideTestCase): self.assertEqual(str(tp), 'NS.TP') self.assertEqual(tp.namespace, (ns, '.')) + + + def testTypeHash(self): + """Hash a user-defined type.""" + + class MyUserType(DataType): + + def __init__(self, name): + super(MyUserType, self).__init__() + self._name = name + + def _hash(self): + return hash(self._name) + + tp = MyUserType('random') + + self.assertEqual(tp.hash, hash('random') & ((1 << 32) - 1)) -- cgit v0.11.2-87-g4458