Ensure constraints_on_doubles_respect_significant_figure_setting() {
significant_figures_for_assert_double_are(2);
Constraint *want_337 = want_double(label, 337.0);
assert_equal(compare_constraint(want_337, box_double(339.0)), 1);
significant_figures_for_assert_double_are(3);
assert_equal(compare_constraint(want_337, box_double(339.0)), 0);
destroy_constraint(want_337);
}
caddr_t
bif_nasa_tjd_fraction (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
caddr_t arg = bif_date_arg (qst, args, 0, "nasa_tjd_fraction");
double f = (((DT_HOUR (arg) * (boxint)60 + DT_MINUTE (arg)) * (boxint)60 + DT_SECOND (arg)) * (boxint)1000000 + DT_FRACTION (arg)) / (60*60*24*1000000.0);
return box_double (f);
}
void assert_that_double_(const char *file, int line, const char *expression, double actual, Constraint* constraint) {
BoxedDouble* boxed_actual;
if (NULL != constraint && is_not_comparing(constraint)) {
(*get_test_reporter()->assert_true)(
get_test_reporter(),
file,
line,
false,
"\tGot constraint of type [%s], but they are not allowed for assertions, only in mock expectations.",
constraint->name);
constraint->destroy(constraint);
return;
}
boxed_actual = (BoxedDouble*)box_double(actual);
(*get_test_reporter()->assert_true)(get_test_reporter(), file, line, (*constraint->compare)(constraint, (intptr_t)boxed_actual),
"Expected [%s] to [%s] [%s] within [%d] significant figures\n"
"\t\tactual value:\t%08f\n"
"\t\texpected value:\t%08f",
expression,
constraint->name,
constraint->expected_value_name,
get_significant_figures(),
actual,
as_double(constraint->expected_value));
free(boxed_actual);
constraint->destroy(constraint);
}
void
qst_set_double (caddr_t * state, state_slot_t * sl, double dv)
{
#ifdef QST_DEBUG
if (sl->ssl_index < QI_FIRST_FREE)
GPF_T1 ("Invalid SSL in qst_set");
else if (sl->ssl_type == SSL_CONSTANT)
GPF_T1 ("Invalid constant SSL in qst_set");
else
{
#endif
caddr_t *place = IS_SSL_REF_PARAMETER (sl->ssl_type)
? (caddr_t *) state[sl->ssl_index]
: (caddr_t *) & state[sl->ssl_index];
caddr_t old = *place;
if (IS_BOX_POINTER (old) && DV_DOUBLE_FLOAT == box_tag (old))
*(double *) old = dv;
else
{
if (old)
ssl_free_data (sl, *place);
*place = box_double (dv);
}
#ifdef QST_DEBUG
}
#endif
}
Constraint *create_not_equal_to_double_constraint(double expected_value, const char *expected_value_name) {
Constraint *constraint = create_constraint_expecting(box_double(expected_value), expected_value_name);
constraint->type = DOUBLE_COMPARER;
constraint->compare = &compare_do_not_want_double;
constraint->execute = &test_do_not_want_double;
constraint->name = "not equal double";
constraint->destroy = &destroy_double_constraint;
return constraint;
}
Constraint *create_greater_than_double_constraint(double expected_value, const char *expected_value_name) {
Constraint *constraint = create_constraint_expecting(box_double(expected_value), expected_value_name);
constraint->type = DOUBLE_COMPARER;
constraint->compare = &compare_want_greater_double;
constraint->execute = &test_true;
constraint->name = "be greater than double";
constraint->destroy = &destroy_double_constraint;
constraint->expected_value_message = "\t\texpected to be greater than:\t[%08f]";
return constraint;
}
Ensure unequal_doubles_compare_false_with_a_want_double_constraint() {
Constraint *want_37 = want_double(label, 37.0);
assert_equal(compare_constraint(want_37, box_double(36.0)), 0);
destroy_constraint(want_37);
}
static caddr_t
sa_to_dk (MonoArray *mono_list, int ofs, int mode, void *udt)
{
guint32 ret_type;
int clr_object = 0;
MonoObject *type, *value;
caddr_t ret = NULL;
MonoClass *cls;
int len = mono_array_length (mono_list), inx;
dk_set_t ret_set = NULL;
type = (MonoObject *)mono_array_get (mono_list, gpointer, ofs + 0);
ret_type = *(guint32 *)((char *)type + sizeof (MonoObject));
if (!ret_type)
{
char *error_text;
caddr_t err = NULL;
value = (MonoObject *)mono_array_get (mono_list, gpointer, ofs + 1);
error_text = mono_string_to_utf8 ((MonoString *)value);
if (error_text)
err = srv_make_new_error ("42000", "MN002", "Mono error : %.200s",
mono_class_get_name (mono_object_get_class (value)), error_text);
else
err = srv_make_new_error ("42000", "MN003", "Unknown mono error");
g_free (error_text);
sqlr_resignal (err);
}
/* get type of object */
clr_object = 0;
if (ret_type == 5 || ret_type == 6)
clr_object = 1;
for (inx = 1; inx < len; inx++)
{
value = (MonoObject *)mono_array_get (mono_list, gpointer, ofs + inx);
if (value)
{
cls = mono_object_get_class (value);
if (cls == mono_get_int32_class ())
{
gint32 v = *(gint32 *)((char *)value + sizeof (MonoObject));
if (clr_object)
{
void * what_udt;
if (mode)
{
/*add_id (v);*/
ret = box_num (v);
}
else
{
what_udt = udt_find_class_for_clr_instance (v, udt);
if (what_udt)
{
/*add_id (v);*/
ret = cpp_udt_clr_instance_allocate (v, what_udt);
}
else
{
sqlr_new_error ("22023", "MN005", "Can't map Mono result to PL type");
}
}
}
else
ret = box_num (v);
}
else if (cls == mono_get_uint32_class())
ret = box_num (*(guint32 *)((char *)value + sizeof (MonoObject)));
else if (cls == mono_get_single_class ())
ret = box_float (*(float *)((char *)value + sizeof (MonoObject)));
else if (cls == mono_get_double_class ())
ret = box_double (*(double *)((char *)value + sizeof (MonoObject)));
else if (cls == mono_get_boolean_class ())
ret = box_num (*(guint8 *)((guint8 *)value + sizeof (MonoObject)));
else if (cls == mono_get_string_class ())
{
char *utf8 = mono_string_to_utf8 ((MonoString *)value);
ret = box_utf8_as_wide_char (utf8, NULL, strlen (utf8), 0, DV_WIDE);
g_free (utf8);
}
else
{
const char *name = mono_class_get_name (cls);
sqlr_new_error ("22023", "MN006", "Can't map CLR result of type (%s) to PL type",
name ? name : "<unknown>");
}
}
else
ret = NULL;
if (ret_type != 3 && ret_type != 4 && ret_type != 5)
return ret;
else
dk_set_push (&ret_set, ret);
}
return list_to_array (dk_set_nreverse (ret_set));
}
/* equal to ARTM_BIN_FUNC (box_mod, %, numeric_modulo, 1) with some extensions */
caddr_t
box_mod (ccaddr_t box1, ccaddr_t box2, caddr_t * qst, state_slot_t * target)
{
NUMERIC_VAR (dn1);
NUMERIC_VAR (dn2);
dtp_t dtp1, dtp2, res_dtp;
retry_rdf_boxes:
NUM_TO_MEM (dn1, dtp1, box1);
NUM_TO_MEM (dn2, dtp2, box2);
if (dtp1 == DV_DB_NULL || dtp2 == DV_DB_NULL)
goto null_result; \
if (n_coerce ((caddr_t) & dn1, (caddr_t) & dn2,
dtp1, dtp2, &res_dtp))
{
switch (res_dtp)
{
case DV_LONG_INT:
if (0 == *(boxint *) &dn2)
sqlr_new_error ("22012", "SR088", "Division by 0.");
if (target)
return (qst_set_long (qst, target,
(*(boxint *) &dn1 % * (boxint *) &dn2)), (caddr_t) 0);
return (box_num (*(boxint *) &dn1 % * (boxint *) &dn2));
case DV_SINGLE_FLOAT:
if (0 == *(float *) &dn2)
sqlr_new_error ("22012", "SR089", "Division by 0.");
if (target)
return (qst_set_float (qst, target,
(float) fmod (*(float *) &dn1, * (float *) &dn2)), (caddr_t) 0);
return (box_float ((float) fmod (*(float *) &dn1, * (float *) &dn2)));
case DV_DOUBLE_FLOAT:
if (0 == *(double*) &dn2)
sqlr_new_error ("22012", "SR090", "Division by 0.");
if (target)
return (qst_set_double (qst, target, fmod (*(double*) &dn1, *(double*) &dn2)), (caddr_t) 0);
return (box_double (fmod (*(double*) &dn1, *(double*) &dn2)));
case DV_NUMERIC:
return (numeric_bin_op (numeric_modulo, (numeric_t) &dn1, (numeric_t) &dn2, qst, target));
}
}
else
{
if (dtp1 == DV_RDF || dtp2 == DV_RDF)
{
if (dtp1 == DV_RDF)
box1 = ((rdf_box_t *)(box1))->rb_box;
if (dtp2 == DV_RDF)
box2 = ((rdf_box_t *)(box2))->rb_box;
goto retry_rdf_boxes;
}
if (((query_instance_t *)qst)->qi_query->qr_no_cast_error)
goto null_result; /* see below */
sqlr_new_error ("22003", "SR087", "Non numeric arguments to arithmetic operation modulo");
}
null_result: \
if (target) \
{ \
qst_set_bin_string (qst, target, NULL, 0, DV_DB_NULL); \
return NULL; \
} \
return (dk_alloc_box (0, DV_DB_NULL)); \
}
