void test_ncache_both_group(void **state)
{
errno_t ret;
struct ncache_test_ctx *test_ctx;
test_ctx = talloc_get_type_abort(*state, struct ncache_test_ctx);
assert_non_null(test_ctx);
ret = sss_ncache_init(test_ctx, TIMEOUT, TIMEOUT, &test_ctx->ncache);
assert_int_equal(ret, EOK);
set_groups(test_ctx);
check_groups(test_ctx, EEXIST, ENOENT, EEXIST, ENOENT);
talloc_zfree(test_ctx->ncache);
}
int
main (int argc, char *argv[])
{
mpfr_t x, y;
mpfr_exp_t emin, emax;
tests_start_mpfr ();
test_set_underflow ();
test_set_overflow ();
check_default_rnd();
mpfr_init (x);
mpfr_init (y);
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
if (emin >= emax)
{
printf ("Error: emin >= emax\n");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1024, MPFR_RNDN);
mpfr_set_double_range ();
mpfr_check_range (x, 0, MPFR_RNDN);
if (!mpfr_inf_p (x) || (mpfr_sgn(x) <= 0))
{
printf ("Error: 2^1024 rounded to nearest should give +Inf\n");
exit (1);
}
set_emax (1025);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1024, MPFR_RNDN);
mpfr_set_double_range ();
mpfr_check_range (x, 0, MPFR_RNDD);
if (!mpfr_number_p (x))
{
printf ("Error: 2^1024 rounded down should give a normal number\n");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1023, MPFR_RNDN);
mpfr_add (x, x, x, MPFR_RNDN);
if (!mpfr_inf_p (x) || (mpfr_sgn(x) <= 0))
{
printf ("Error: x+x rounded to nearest for x=2^1023 should give +Inf\n");
printf ("emax = %ld\n", (long) mpfr_get_emax ());
printf ("got "); mpfr_print_binary (x); puts ("");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1023, MPFR_RNDN);
mpfr_add (x, x, x, MPFR_RNDD);
if (!mpfr_number_p (x))
{
printf ("Error: x+x rounded down for x=2^1023 should give"
" a normal number\n");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_div_2exp (x, x, 1022, MPFR_RNDN);
mpfr_set_str_binary (y, "1.1e-1022"); /* y = 3/2*x */
mpfr_sub (y, y, x, MPFR_RNDZ);
if (mpfr_cmp_ui (y, 0))
{
printf ("Error: y-x rounded to zero should give 0"
" for y=3/2*2^(-1022), x=2^(-1022)\n");
printf ("y="); mpfr_print_binary (y); puts ("");
exit (1);
}
set_emin (-1026);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_div_2exp (x, x, 1025, MPFR_RNDN);
mpfr_set_double_range ();
mpfr_check_range (x, 0, MPFR_RNDN);
if (!MPFR_IS_ZERO (x) )
{
printf ("Error: x rounded to nearest for x=2^-1024 should give Zero\n");
printf ("emin = %ld\n", (long) mpfr_get_emin ());
printf ("got "); mpfr_dump (x);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
set_emin (emin);
set_emax (emax);
check_emin_emax();
check_flags();
check_set_get_prec ();
check_powerof2 ();
check_set ();
check_groups ();
tests_end_mpfr ();
return 0;
}
int main( int argc, char *argv[] )
{
Shypothesis **samples; /* Data to be combined */
unsigned int i;
FILE *kb;
char **groups;
int norm = 1; /* turn on normalisation of evidence by default */
/* these are for time keeping in the logfile */
time_t systime;
clock_t proctime;
unsigned long timeused;
unsigned int days, hours, mins, secs;
xmlDocPtr dstXMLFile;
Sfp_struct* file_pointers;
G_gisinit ( argv[0] );
module = G_define_module ();
module->description = "Combines evidences from a DST knowledge base";
parm.file = G_define_option ();
parm.file->key = "file";
parm.file->type = TYPE_STRING;
parm.file->required = YES;
parm.file->description = "Name of the knowledge base that contains the evidence";
parm.groups = G_define_option ();
parm.groups->key = "sources";
parm.groups->type = TYPE_STRING;
parm.groups->required = NO;
parm.groups->multiple = YES;
parm.groups->description = "Evidences to be combined (default: all)";
parm.type = G_define_option ();
parm.type->key = "type";
parm.type->type = TYPE_STRING;
parm.type->required = NO;
parm.type->options = "const,rast,vect";
parm.type->answer = "rast";
parm.type->description = "Type(s) of evidences to combine";
parm.output = G_define_option ();
parm.output->key = "output";
parm.output->type = TYPE_STRING;
parm.output->required = NO;
parm.output->answer = G_location ();
parm.output->description = "Prefix for result maps (dflt: location name)";
parm.vals = G_define_option ();
parm.vals->key = "values";
parm.vals->type = TYPE_STRING;
parm.vals->required = NO;
parm.vals->multiple = YES;
parm.vals->options = "bel,pl,doubt,common,bint,woc,maxbpa,minbpa,maxsrc,minsrc";
parm.vals->answer = "bel";
parm.vals->description = "Dempster-Shafer values to map";
parm.hyps = G_define_option ();
parm.hyps->key = "hypotheses";
parm.hyps->type = TYPE_STRING;
parm.hyps->required = NO;
parm.hyps->multiple = NO;
parm.hyps->description = "Hypotheses to map (default: all)";
parm.logfile = G_define_option ();
parm.logfile->key = "logfile";
parm.logfile->type = TYPE_STRING;
parm.logfile->required = NO;
parm.logfile->description = "Name of logfile";
/* TODO: not implemented yet
parm.warnings = G_define_option ();
parm.warnings->key = "warnings";
parm.warnings->type = TYPE_STRING;
parm.warnings->required = NO;
parm.warnings->description = "Name of site list to store locations of warnings." ;
*/
flag.norm = G_define_flag ();
flag.norm->key = 'n';
flag.norm->description = "Turn off normalisation";
flag.quiet = G_define_flag ();
flag.quiet->key = 'q';
flag.quiet->description = "Quiet operation: no progress diplay";
/* append output to existing logfile ? */
flag.append = G_define_flag ();
flag.append->key = 'a';
flag.append->description = "Append log output to existing file";
no_assigns = 0;
/* INIT GLOBAL VARS */
WOC_MIN = 0;
WOC_MAX = 0;
/* do not pause after a warning message was displayed */
G_sleep_on_error (0);
/* parse command line */
if (G_parser (argc, argv))
{
exit (-1);
}
/* check if given parameters are valid */
if (G_legal_filename (parm.file->answer) == -1) {
G_fatal_error ("Please provide the name of an existing DST knowledge base.\n");
}
if (G_find_file ("DST",parm.file->answer,G_mapset()) == NULL) {
G_fatal_error ("Knowledge base does not exist in user's MAPSET!\n");
}
/* check logfile */
if (parm.logfile->answer != NULL) {
if ( !G_legal_filename (parm.logfile->answer) ) {
G_fatal_error ("Please specify a legal filename for the logfile.\n");
}
/* attempt to write to logfile */
if (flag.append->answer) {
if (fopen (parm.logfile->answer, "r") == NULL) {
lp = fopen (parm.logfile->answer, "w+");
if (lp == NULL) {
G_fatal_error ("Logfile error: %s\n", strerror (errno));
}
} else {
lp = fopen (parm.logfile->answer, "a");
if (lp == NULL) {
G_fatal_error ("Logfile error: %s\n", strerror (errno));
}
fprintf (lp,"\n\n * * * * * \n\n");
}
} else {
if ( (lp = fopen ( parm.logfile->answer, "w+" ) ) == NULL ) {
G_fatal_error ("Logfile error: %s\n", strerror (errno));
}
}
/* we want unbuffered output for the logfile */
setvbuf (lp,NULL,_IONBF,0);
} else {
/* log output to stderr by default */
lp = stderr;
}
/* setup coordinate file storage, if desired */
/* try to create a sites file to store coordinates */
/* set 'warn' to point to the user-defined sites file */
/*
warn = NULL;
if ( parm.warnings != NULL ) {
}
*/
/* check if we have read/write access to knowledge base */
kb = G_fopen_old ("DST",parm.file->answer,G_mapset());
if ( kb == NULL ) {
G_fatal_error ("Cannot open knowledge base file for reading and writing!\n");
}
fclose(kb);
/* start logfile */
if ( parm.logfile->answer != NULL) {
fprintf (lp,"This is %s, version %.2f\n",argv[0],PROGVERSION);
systime = time (NULL);
fprintf (lp,"Calculation started on %s\n",ctime(&systime));
}
/* open DST file and get basic evidence group information */
dstXMLFile = stat_XML ( parm.file->answer, &NO_SINGLETONS, &N );
groups = get_groups_XML ( N, dstXMLFile );
if ( NO_SINGLETONS == 1 ) {
G_fatal_error ("Knowledge base does not contain any user-supplied hypotheses.\n");
}
if ( parm.groups->answer != NULL ) {
/* user specified a subset of groups */
N = check_groups ( groups );
}
if ( N < 2 ) {
G_fatal_error ("At least two groups of evidences must be present in the knowledge base.\n");
}
/* allocate memory for all samples
a sample holds one double for bel, pl and bpn for each
piece of evidence. The number of pieces of evidence is
the number of possible subsets in Theta
= 2^NO_SINGLETONS !
The number of samples is = number of groups in the XML
knowledge base file (N) !
*/
samples = (Shypothesis**) G_malloc ((N * sizeof(Shypothesis*)));
for ( i=0; i < N; i ++ ) {
samples[i] = (Shypothesis*) G_malloc (sizeof(Shypothesis));
}
/* turn off normalisation if user wants it so */
if ( flag.norm->answer == 1 ) {
norm = 0;
}
/* do some type-dependant checking */
/* and open file pointers for all the maps to read! */
file_pointers = NULL;
if ( !strcmp (parm.type->answer,"rast") ) {
if ( parm.groups->answer != NULL ) {
/* check only user-specified groups */
file_pointers = test_rast_XML ( parm.groups->answers, dstXMLFile );
} else {
/* check all groups */
file_pointers = test_rast_XML ( groups, dstXMLFile );
}
}
/* read in all samples in a type-dependant manner */
if ( parm.groups->answer != NULL ) {
/* read only user-specified groups */
if ( !strcmp (parm.type->answer,"const") ) {
if ( strcmp (parm.output->answer,G_location ()) != 0) {
G_warning ("Ignoring parameter 'output='.\n");
}
if ( strcmp (parm.vals->answer,"bel") !=0 ) {
G_warning ("Ignoring parameter 'values='.\n");
}
if ( parm.hyps->answer != NULL ) {
G_warning ("Ignoring parameter 'hypotheses='.\n");
}
do_calculations_const (samples,parm.groups->answers, norm, dstXMLFile);
}
if ( !strcmp (parm.type->answer,"rast") ) {
do_calculations_rast (samples,parm.groups->answers, norm,
parm.output->answer, parm.vals->answers,
parm.hyps->answer, flag.quiet->answer,
parm.logfile->answer, dstXMLFile, file_pointers );
}
} else {
/* read all groups */
if ( !strcmp (parm.type->answer,"const") ) {
if ( strcmp (parm.output->answer,G_location ()) != 0) {
G_warning ("Ignoring parameter 'output='.\n");
}
if ( strcmp (parm.vals->answer,"bel") !=0 ) {
G_warning ("Ignoring parameter 'values='.\n");
}
if ( parm.hyps->answer != NULL ) {
G_warning ("Ignoring parameter 'hypotheses='.\n");
}
do_calculations_const (samples,groups, norm, dstXMLFile);
}
if ( !strcmp (parm.type->answer,"rast") ) {
do_calculations_rast (samples,groups, norm,
parm.output->answer, parm.vals->answers,
parm.hyps->answer, flag.quiet->answer,
parm.logfile->answer, dstXMLFile, file_pointers );
}
}
/* close logfile */
/* write processing time to logfile */
proctime = clock ();
timeused = (unsigned long) proctime / CLOCKS_PER_SEC;
days = timeused / 86400;
hours = (timeused - (days * 86400)) / 3600;
mins = (timeused - (days * 86400) - (hours * 3600)) / 60;
secs = (timeused - (days * 86400) - (hours * 3600) - (mins * 60));
systime = time (NULL);
if ( parm.logfile->answer != NULL ) {
fprintf (lp,"\nCalculation finished on %s",ctime(&systime));
fprintf (lp,"Processing time: %id, %ih, %im, %is\n",
days, hours, mins, secs );
fflush (lp);
}
for (i=0; i<N; i++) {
G_free (groups[i]);
}
G_free (groups);
return (EXIT_SUCCESS);
}
