Ejemplo n.º 1
0
int
slaptest( int argc, char **argv )
{
	int			rc = EXIT_SUCCESS;
	const char		*progname = "slaptest";

	slap_tool_init( progname, SLAPTEST, argc, argv );

	if ( slapd_pid_file != NULL ) {
		if ( test_file( slapd_pid_file, "pid" ) ) {
			return EXIT_FAILURE;
		}
	}

	if ( slapd_args_file != NULL ) {
		if ( test_file( slapd_args_file, "args" ) ) {
			return EXIT_FAILURE;
		}
	}

	if ( !quiet ) {
		fprintf( stderr, "config file testing succeeded\n");
	}

	if ( slap_tool_destroy())
		rc = EXIT_FAILURE;

	return rc;
}
Ejemplo n.º 2
0
char		*recursive_execve(char **path, char **command, char **tabenv, int i)
{
  char		*filename;

  filename = NULL;
  if (!test_file('.', '/', command))
    {
      if (((filename = command[0]) && (access(command[0], R_OK | X_OK) == -1))
	  || (execve(filename, command, tabenv) == -1))
	return ("Permissions denied.");
    }
  else if (command[0][0] != '/')
    filename = my_strcat(path[i++], command[0], 1);
  else if (!test_file(' ', '/', command))
    if (((filename = command[0]) && (access(command[0], R_OK | X_OK) == -1))
	|| (execve(filename, command, tabenv) == -1))
      return ("Permissions denied.");
  if (filename != NULL)
    {
      execve(filename, command, tabenv);
      recursive_execve(path, command, tabenv, i);
    }
  else
    return (NULL);
  return (0);
}
Ejemplo n.º 3
0
static int
Test_verifierParseProof(void)
{
  enum {
    file_size = 2
  };
  const char* file[file_size] = {
    "$. ",
    "p $. "
  };
  const size_t thms_len[file_size] = {
    1, 2
  };
  const size_t thms_0[1] = {0};
  const size_t thms_1[2] = {0, 1};
  const size_t* thms_s[file_size] = {
    thms_0,
    thms_1
  };
  size_t i;
  struct verifier vrf;
  verifierInit(&vrf);
  struct reader r[file_size];
  struct symstring thms[file_size];
  for (i = 0; i < file_size; i++) {
    readerInitString(&r[i], file[i]);
    symstringInit(&thms[i]);
    size_tArrayAppend(&thms[i], thms_s[i], thms_len[i]);
  }
  struct frame ctx;
  frameInit(&ctx);
#define test_file(f, error) \
do { \
  verifierBeginReadingFile(&vrf, &r[f]); \
  verifierParseProof(&vrf, &ctx); \
  verifierCheckProof(&vrf, &thms[f]); \
  check_err(vrf.err, error); \
  readerClean(&r[f]); \
} while (0)
  test_file(0, error_incorrectProof);
  verifierAddConstant(&vrf, "type");
  verifierAddVariable(&vrf, "var");
  struct symstring stmt;
  symstringInit(&stmt);
  symstringAdd(&stmt, 0);
  symstringAdd(&stmt, 1);
  verifierAddFloating(&vrf, "p", &stmt);
  test_file(1, error_none);
  for (i = 0; i < file_size; i++) {
    symstringClean(&thms[i]);
  }
  frameClean(&ctx);
  verifierClean(&vrf);
  return 0;
#undef test_file
}
Ejemplo n.º 4
0
int
main(void)
{
    struct xkb_context *ctx = test_get_context(0);

    assert(test_file(ctx, "keymaps/basic.xkb"));
    assert(test_file(ctx, "keymaps/comprehensive-plus-geom.xkb"));
    assert(test_file(ctx, "keymaps/no-types.xkb"));
    assert(test_file(ctx, "keymaps/quartz.xkb"));

    assert(!test_file(ctx, "keymaps/divide-by-zero.xkb"));
    assert(!test_file(ctx, "keymaps/bad.xkb"));
    assert(!test_file(ctx, "keymaps/syntax-error.xkb"));
    assert(!test_file(ctx, "keymaps/syntax-error2.xkb"));
    assert(!test_file(ctx, "does not exist"));

    /* Test response to invalid flags and formats. */
    fclose(stdin);
    assert(!xkb_keymap_new_from_file(ctx, NULL, XKB_KEYMAP_FORMAT_TEXT_V1, 0));
    assert(!xkb_keymap_new_from_file(ctx, stdin, 0, 0));
    assert(!xkb_keymap_new_from_file(ctx, stdin, XKB_KEYMAP_USE_ORIGINAL_FORMAT, 0));
    assert(!xkb_keymap_new_from_file(ctx, stdin, 1234, 0));
    assert(!xkb_keymap_new_from_file(ctx, stdin, XKB_KEYMAP_FORMAT_TEXT_V1, -1));
    assert(!xkb_keymap_new_from_file(ctx, stdin, XKB_KEYMAP_FORMAT_TEXT_V1, 1234));

    xkb_context_unref(ctx);

    return 0;
}
Ejemplo n.º 5
0
QUEX_NAMESPACE_MAIN_OPEN
static void
test(bool BinaryF, size_t BPC)
{
    switch( BPC ) {
    case 4:  test_file(BinaryF, "examples/languages");      /* only with UCS4         */
    case 2:  test_file(BinaryF, "examples/small");          /* only with UCS4, UCS2   */
    case 1:  test_file(BinaryF, "examples/festgemauert");   /* with UCS4, UCS2, ASCII */
             break;
    default: hwut_verify(false);
    }
}
Ejemplo n.º 6
0
static int
Test_verifierParseProofSymbol(void)
{
  enum {
    file_size = 4
  };
  const char* file[file_size] = {
    "$. ",
    "undefined ",
    "defined_float ",
    "defined_assert ",
  };
  size_t i;
  int isEndOfProof;
  struct verifier vrf;
  verifierInit(&vrf);
  struct reader r[file_size];
  for (i = 0; i < file_size; i++) {
    readerInitString(&r[i], file[i]);
  }
  struct frame ctx;
  frameInit(&ctx);
#define test_file(f, error) \
do { \
  verifierBeginReadingFile(&vrf, &r[f]); \
  verifierParseProofSymbol(&vrf, &ctx, &isEndOfProof); \
  check_err(vrf.err, error); \
  readerClean(&r[f]); \
} while (0)
  test_file(0, error_none);
  test_file(1, error_undefinedSymbol);
  size_t c = verifierAddConstant(&vrf, "c");
  size_t v = verifierAddVariable(&vrf, "v");
  struct symstring stmt1;
  symstringInit(&stmt1);
  symstringAdd(&stmt1, c);
  symstringAdd(&stmt1, v);
  verifierAddFloating(&vrf, "defined_float", &stmt1);
  test_file(2, error_none);
  struct symstring stmt2;
  symstringInit(&stmt2);
  verifierAddAssertion(&vrf, "defined_assert", &stmt2);
  test_file(3, error_none);
  ut_assert(vrf.stack.size == 2, "stack size == %lu, should be 2",
    vrf.stack.size);
  frameClean(&ctx);
  verifierClean(&vrf);
  return 0;
#undef test_file
}
Ejemplo n.º 7
0
int main(int argc, char *argv[])
{
	int opt, flag;

	flag = 0;
	e_flag = 0;

	while ((opt = getopt(argc, argv, "ef:d:")) > 0) {
		switch (opt) {
			case 'f':
				test_file(optarg);
				flag = 1;
				break;
			case 'd':
				test_folder(optarg);
				flag = 1;
				break;
			case 'e':
				e_flag = 1;
				break;
			default:
				printf("Usage: %s [-e] [-f <file_name.cs>] [-d <directory>]\n", argv[0]);
				exit(-1);
		}
	}

	if (flag == 0) {
		printf("Usage: %s [-e] [-f <file_name.cs>] [-d <directory>]\n", argv[0]);
		exit(-1);
	}

	return 0;
}
Ejemplo n.º 8
0
/****** Loads recent file from list ******/
void main_menu::load_recent(int file_id)
{
	//Check to see if the file actually exists
	QFile test_file(QString::fromStdString(config::recent_files[file_id]));

	if(!test_file.exists())
	{
		std::string mesg_text = "The specified file: '" + config::recent_files[file_id] + "' could not be loaded"; 
		warning_box->setText(QString::fromStdString(mesg_text));
		warning_box->show();
		return;
	}

	//Close the core
	if(main_menu::gbe_plus != NULL) 
	{
		main_menu::gbe_plus->shutdown();
		main_menu::gbe_plus->core_emu::~core_emu();
	}

	config::rom_file = config::recent_files[file_id];
	config::save_file = config::rom_file + ".sav";

	config::sdl_render = false;
	config::render_external_sw = render_screen_sw;
	config::render_external_hw = render_screen_hw;
	config::sample_rate = settings->sample_rate;

	if(qt_gui::screen != NULL) { delete qt_gui::screen; }
	qt_gui::screen = NULL;

	boot_game();
}
Ejemplo n.º 9
0
int main()
{
	// ofstream ファイルへの書き出し
	// Cのファイル書き込みと違い、closeはしなくてもよい。
	// デストラクタ内で自動的にファイルを閉じるようになっている。
	std::ofstream file("C:\\Users\\vantan\\Desktop\\ofstream\\res\\test.txt", std::ios::trunc);

	file << "Hello, world!" << std::endl;
	
	// 明示的に閉じても問題はない。
	file.close();


	// ifstream ファイルからの読み込み
	// ofstreamと同じく、closeはしなくてもよい。
	std::ifstream test_file("C:\\Users\\vantan\\Desktop\\ofstream\\res\\test.txt");
	std::string str;

	// ファイルから1行読み込む
	while (std::getline(test_file, str)){
		test_file >> str;
		std::cout << str << std::endl;
	}
	
	return 0;
}
Ejemplo n.º 10
0
DEF_TEST(document_tests, reporter) {
    test_empty(reporter);
    test_abort(reporter);
    test_abortWithFile(reporter);
    test_file(reporter);
    test_close(reporter);
}
Ejemplo n.º 11
0
TEE_Result tee_fs_dirfile_remove(struct tee_fs_dirfile_dirh *dirh,
				 const struct tee_fs_dirfile_fileh *dfh)
{
	TEE_Result res;
	struct dirfile_entry dent;
	uint32_t file_number;

	res = read_dent(dirh, dfh->idx, &dent);
	if (res)
		return res;

	if (!dent.oidlen)
		return TEE_SUCCESS;

	file_number = dent.file_number;
	assert(dfh->file_number == file_number);
	assert(test_file(dirh, file_number));

	memset(&dent, 0, sizeof(dent));
	res = write_dent(dirh, dfh->idx, &dent);
	if (!res)
		clear_file(dirh, file_number);

	return res;
}
Ejemplo n.º 12
0
static void
test_layout (gconstpointer d)
{
  const gchar *filename = d;
  gchar *expected_file;
  GError *error = NULL;
  GString *dump;
  gchar *diff;

  expected_file = get_expected_filename (filename);

  dump = g_string_sized_new (0);

  test_file (filename, dump);

  diff = diff_with_file (expected_file, dump->str, dump->len, &error);
  g_assert_no_error (error);

  if (diff && diff[0])
    {
      g_printerr ("Contents don't match expected contents:\n%s", diff);
      g_test_fail ();
      g_free (diff);
    }

  g_string_free (dump, TRUE);
  g_free (expected_file);
}
Ejemplo n.º 13
0
/* test local file -----------------------------------------------------------*/
static int test_local(gtime_t ts, gtime_t te, double ti, const char *path,
                      const char *sta, const char *dir, int *nc, int *nt,
                      FILE *fp)
{
    gtime_t time;
    char remot[1024],remot_p[1024],dir_t[1024],local[1024],str[1024];
    int stat,abort=0;
    
    for (time=ts;timediff(time,te)<=1E-3;time=timeadd(time,ti)) {
        
        sprintf(str,"%s->%s",path,local);
        
        if (showmsg(str)) {
            abort=1;
            break;
        }
        genpath(path,sta,time,0,remot);
        genpath(dir ,sta,time,0,dir_t);
        remot2local(remot,dir_t,local);
        
        stat=test_file(local);
        
        fprintf(fp," %s",stat==0?"-":(stat==1?"o":"z"));
        
        showmsg("STAT=%s",stat==0?"x":(stat==1?"o":"z"));
        
        (*nt)++; if (stat) (*nc)++;
    }
    fprintf(fp,"\n");
    return abort;
}
Ejemplo n.º 14
0
void ex2() {
    // Testing the Multimap with subjects

    // Start by reading the file
    string test_file_name = "Test_files/my_mail.txt";
    Mail_file test_file(test_file_name);

    // See what's in the map!
    cout << "Read following subjects in the map:\n";
    for (auto b = test_file.subjects.begin(); b != test_file.subjects.end(); b++) {
        cout << "Message subject: \"" << b->first << "\"\n";
    }

    // Now, to the exercise proper:
    cout << "Enter the subject line to look up...\n> ";
    string lookup_subject;
    getline(cin, lookup_subject);

    cout << "Looking for: \"" << lookup_subject << "\"\n";

    auto found_subjects = test_file.subjects.equal_range(lookup_subject);
    if (found_subjects.first != found_subjects.second) {
        cout << "Found messages:\n";
        int count = 1;
        for (auto b = found_subjects.first; b != found_subjects.second; ++b) {
            string from_address;
            find_from_addr(&b->second, from_address);
            cout << "Message " << count++ << " from " << from_address << endl << b->second << "*** END ***\n";
        }
    }
    else
        cout << "No messages found for this subject line.\n";
}
Ejemplo n.º 15
0
int main(int argc, char * argv[])
{
   int choix = 0;
   while(choix != -1)
   {
      printf("--------MENU TP2 SDD--------\n");
      printf("1) test sur les piles       \n");
      printf("2) test sur les files       \n");
      printf("3) Question de l'examen     \n");
      printf("autre: sortie du programme  \n");

      scanf("%d",&choix);
      switch(choix)
      {
         case 1 : test_pile();
                  break;
         case 2 : test_file();
                  break;
         case 3 : exo_exam();
                  break;
         default: choix = -1;
      }

   }
   return 0;
}
                        /**
                         * This method will perform the main tasks of this application:
                         * Read the text corpus and create a trie and then read the test
                         * file and query the trie for frequencies.
                         * @param params the runtime program parameters
                         */
                        static void perform_tasks(const __executor::lm_exec_params & params) {
                            //Attempt to open the test file
                            memory_mapped_file_reader test_file(params.m_query_file_name.c_str());

                            //Assert that the query file is opened
                            ASSERT_CONDITION_THROW(!test_file.is_open(), string("The Test Queries file: '")
                                    + params.m_query_file_name + string("' does not exist!"));

                            //Connect to the language model
                            lm_configurator::connect(params.m_lm_params);

                            //Override the reporting level for testing purposes
                            //Logger::get_reporting_level() = DebugLevelsEnum::DEBUG2;

                            //Execute the queries
                            execute_queries(test_file);

                            //Deallocate the trie
                            LOG_USAGE << "Cleaning up memory ..." << END_LOG;

                            //Close the test file
                            test_file.close();

                            //Disconnect from the trie
                            lm_configurator::disconnect();
                        }
Ejemplo n.º 17
0
int			file_reader(char *file, int ***map)
{
	int		fd;
	int		ret;
	char	*line;
	int		i;

	if (!(init_map(map, file)))
		return (0);
	if (!test_file(file))
		return (0);
	i = 0;
	fd = open(file, O_RDONLY);
	while ((ret = get_next_line(fd, &line)) > 0)
	{
		if (!((*map)[i] = line_filler(line, (*map)[i])))
			return (0);
		ft_strdel(&line);
		i++;
	}
	if (!test_size(map))
		return (0);
	close(fd);
	return ((ret < 0) ? 0 : 1);
}
Ejemplo n.º 18
0
static void test_get_transfer_url_bigfile( void **state ) {
    const char *url = "http://example.org/big_file";
    const char *turl = NULL;
    char res[256];
    int i, fd;
    Hbf_State hbf_state;
    hbf_transfer_t *list = NULL;

    (void) state;

    list = hbf_init_transfer( url );
    assert_non_null( list );

    list->threshold = list->block_size = (1024*1024); /* block size 1 MB */

    /* open a file */
    fd = open( test_file("church.jpg"), O_RDONLY );
    assert_true(fd >= 0);

    hbf_state = hbf_splitlist(list, fd);
    assert_true( hbf_state == HBF_SUCCESS);
    assert_true( list->block_cnt == 2 );

    for( i=0; i < list->block_cnt; i++ ) {
        turl = get_transfer_url( list, i );
        assert_non_null(turl);

        sprintf(res, "%s-chunking-%u-%u-%u", url, list->transfer_id,
                list->block_cnt, i );
        /* printf( "XX: %s\n", res ); */
        assert_string_equal( turl, res );
    }
    hbf_free_transfer(list);
}
Ejemplo n.º 19
0
static void test_get_transfer_url( void **state ) {
    const char *url = "http://example.org/owncloud";
    const char *turl = NULL;
    int fd;
    Hbf_State hbf_state;

    hbf_transfer_t *list = NULL;

    (void) state;
    list = hbf_init_transfer( url );
    assert_non_null( list );

    /* open a file */
    fd = open( test_file("church.jpg"), O_RDONLY );
    assert_true(fd >= 0);

    hbf_state = hbf_splitlist(list, fd);
    assert_true( hbf_state == HBF_SUCCESS);
    assert_true( list->block_cnt == 1);

    turl = get_transfer_url( list, 0 );
    assert_non_null( turl );
    assert_string_equal( url, turl );

    hbf_free_transfer( list );
}
Ejemplo n.º 20
0
/* test with a file size that is not a multiply of the slize size. */
static void test_hbf_splitlist_zero( void **state ){

    hbf_transfer_t *list = NULL;
    const char *dest_url = "http://localhost/ocm/remote.php/webdav/big/zerofile.txt";
    int fd;
    Hbf_State hbf_state;

    (void) state;

    /* open a file */
    fd = open(test_file("zerofile.txt"), O_RDONLY);
    assert_true(fd >= 0);

    list = hbf_init_transfer(dest_url);
    assert_non_null(list);

    hbf_state = hbf_splitlist(list, fd);
    assert_non_null(list);
    assert_int_equal(list->stat_size, 0);
#ifndef NDEBUG
    assert_int_equal(list->calc_size, list->stat_size);
#endif
    assert_int_equal(list->block_cnt, 1);

    assert_true( hbf_state == HBF_SUCCESS);

    hbf_free_transfer( list );
}
Ejemplo n.º 21
0
int
main (int   argc,
      char *argv[])
{
    int retval;

#ifdef __SYMBIAN32__
    g_log_set_handler (NULL,  G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);
    g_set_print_handler(mrtPrintHandler);
#endif /*__SYMBIAN32__*/

    if (argc > 1)
    {
        retval = test_file (argv[1]);
#ifdef __SYMBIAN32__
        testResultXml("markup-test");
#endif /* EMULATOR */
        return retval;
    }
    else
    {
        fprintf (stderr, "Give a markup file on the command line\n");
        return 1;
    }
}
Ejemplo n.º 22
0
static void test_get_transfer_url( void **state ) {
    const char *url = "http://example.org/owncloud";
    const char *turl = NULL;
    char res[256];
    int i;
    Hbf_State hbf_state;

    hbf_transfer_t *list = NULL;
    list = hbf_init_transfer( url );
    assert_non_null( list );

    /* open a file */
    int fd = open( test_file("church.jpg"), O_RDONLY );
    assert_true(fd >= 0);

    hbf_state = hbf_splitlist(list, fd);
    assert_true( hbf_state == HBF_SUCCESS);

    for( i=0; i < list->block_cnt; i++ ) {
        turl = get_transfer_url( list, i );

        sprintf(res, "%s-chunking-%d-%d-%d", url, list->transfer_id,
                list->block_cnt, i );
        printf( "XX: %s\n", res );
        assert_string_equal( turl, res );

    }
}
Ejemplo n.º 23
0
int main(int argc, char* argv[])
{
	int i;	
	unsigned readsize;
	char *dir;

	printf("readframes tester - [email protected]\n");

	if (argc < 3) {
		printf("Usage: readframes <directory> <readsize>\n");
		exit(1);
	}

	dir = argv[1];
	readsize = strtoul(argv[2], NULL, 0);

	printf("Testing on directory %s with readsize=%u\n", 
	       dir, readsize);
	test_directory(dir);

	qsort(file_list, num_files, sizeof(char *), name_cmp);
	
	for (i=0;i<num_files;i++) {
		test_file(file_list[i], readsize);
	}

	printf("\nProcessed %d files totalling %.2f MBytes\n", 
	       num_files, total_bytes/(1024*1024));
	printf("Speed was %.2f files/sec\n", num_files/total_time);
	printf("Average speed was %.2fms per file\n", 1000.0*total_time/num_files);
	printf("Worst: %.2fms  Best: %.2fms\n", max_time*1000.0, min_time*1000.0);

        return 0;
}
bool OpenCascadeBasedSerializer::ready() {
	std::ofstream test_file(out_filename.c_str(), std::ios_base::binary);
	bool succeeded = test_file.is_open();
	test_file.close();
	remove(out_filename.c_str());
	return succeeded;
}
Ejemplo n.º 25
0
int
main (int argc, char *argv[])
{
  gboolean rv;
  GMimeStream *out_stream;
  out_stream = g_mime_stream_file_new (stdout);

  if (argc < 2) {
    g_printerr ("usage: %s <msg-files>\n", argv[0]);
    return 1;
  }

  setlocale (LC_ALL, "");

  g_mime_init(GMIME_ENABLE_RFC2047_WORKAROUNDS);

  if (argc == 2) {
    g_mime_stream_printf (out_stream, "%%{");
    g_mime_stream_printf (out_stream, "path: \"%s\", ", argv[1]);
    rv = test_file (argv[1], out_stream);
    g_mime_stream_printf (out_stream, "}");
  } else {
    g_mime_stream_printf (out_stream, "[");
    int x;
    for (x = 1; x < argc; x++ ) {
      /* printf("File: %s\n", argv[x]); */
      if (x > 1) {
        g_mime_stream_printf (out_stream, ", ");
      }
      g_mime_stream_printf (out_stream, "%%{");
      g_mime_stream_printf (out_stream, "path: \"%s\", ", argv[x]);
      rv = test_file (argv[x], out_stream);
      g_mime_stream_printf (out_stream, "}");
    }
    g_mime_stream_printf (out_stream, "]");
  }

  g_mime_shutdown ();

  /* flush stdout */
  g_mime_stream_flush (out_stream);

  /* free/close the stream */
  g_object_unref (out_stream);

  return rv ? 0 : 1;
}
Ejemplo n.º 26
0
static int
Test_verifierParseFloating(void)
{
  size_t i;
  enum {
    file_size = 5
  };
  const char* file[file_size] = {
    "$. ",
    "And mid these dancing rocks at once and ever $.\n",
    "Chopin piano $. ",
    "wff x $. ",
    "wff y $. "
  };
  struct verifier vrf;
  verifierInit(&vrf);
  struct reader r[file_size];
  struct symstring stmts[file_size];
  for (i = 0; i < file_size; i++) {
    symstringInit(&stmts[i]);
    readerInitString(&r[i], file[i]);
    check_err(vrf.err, error_none);
  }
#define test_file(rId, error) \
do { \
  LOG_DEBUG("testing file %d", rId); \
  verifierBeginReadingFile(&vrf, &r[rId]); \
  verifierParseFloating(&vrf, &stmts[rId]); \
  check_err(vrf.err, error); \
  readerClean(&r[rId]); \
} while (0)
  test_file(0, error_invalidFloatingStatement);
  test_file(1, error_invalidFloatingStatement);
  test_file(2, error_expectedVariableSymbol);
  verifierAddConstant(&vrf, "wff");
  test_file(3, error_expectedVariableSymbol);
  verifierAddVariable(&vrf, "y");
  test_file(4, error_none);
  LOG_DEBUG("cleaning stmts");
  for (i = 0; i < file_size; i++) {
    symstringClean(&stmts[i]);
  }
  LOG_DEBUG("cleaning vrf");
  verifierClean(&vrf);
  return 0;
#undef test_file
}
Ejemplo n.º 27
0
/* test with a file size that is not a multiply of the slize size. */
static void test_hbf_splitlist_odd( void **state ){

    hbf_transfer_t *list = NULL;
    const char *dest_url = "http://localhost/ocm/remote.php/webdav/big/church.jpg";
    int prev_id = 0;
    int i, fd;
    Hbf_State hbf_state;

    (void) state;

    /* open a file */
    fd = open(test_file("church.jpg"), O_RDONLY);
    assert_true(fd >= 0);

    /* do a smoke test for uniqueness */
    for( i=0; i < 10000; i++) {
        list = hbf_init_transfer(dest_url);
        assert_non_null(list);
        usleep(1);
        hbf_state = hbf_splitlist(list, fd);

        assert_int_not_equal(list->transfer_id, prev_id);
        prev_id = list->transfer_id;
        hbf_free_transfer(list);
    }

    list = hbf_init_transfer(dest_url);
    assert_non_null(list);

    hbf_state = hbf_splitlist(list, fd);
    assert_non_null(list);
#ifndef NDEBUG
    assert_int_equal(list->calc_size, list->stat_size);
#endif
    assert_int_not_equal(list->block_cnt, 0);
    assert_true( hbf_state == HBF_SUCCESS);

    /* checks on the block list */
    if( 1 ) {
      int seen_zero_seq = 0;
      int prev_seq = -1;
      int64_t prev_block_end = -1;

      for( i=0; i < list->block_cnt; i++) {
        hbf_block_t *blk = list->block_arr[i];
        assert_non_null(blk);
        if( blk->seq_number == 0 ) seen_zero_seq++;

        assert_int_equal(prev_seq, blk->seq_number -1 );
        prev_seq = blk->seq_number;

        assert_true((prev_block_end+1) == (blk->start));
        prev_block_end = blk->start + blk->size;
      }
      /* Make sure we exactly saw blk->seq_number == 0 exactly one times */
      assert_int_equal( seen_zero_seq, 1 );
    }
    hbf_free_transfer( list );
}
Ejemplo n.º 28
0
DEF_TEST(document_tests, reporter) {
    REQUIRE_PDF_DOCUMENT(document_tests, reporter);
    test_empty(reporter);
    test_abort(reporter);
    test_abortWithFile(reporter);
    test_file(reporter);
    test_close(reporter);
}
Ejemplo n.º 29
0
static char* default_file(void){
	struct stat sb;
	char *np_env=NULL, *default_file=NULL;
	char temp_file[MAX_INPUT_BUFFER];
	size_t len;

	if((np_env=getenv("NAGIOS_CONFIG_PATH"))!=NULL) {
		/* skip any starting colon... */
		while(*np_env==':') np_env++;
		/* Look for NP_DEFAULT_INI_FILENAME1 and NP_DEFAULT_INI_FILENAME2 in
		 * every PATHs defined (colon-separated).
		 */
		while((len=strcspn(np_env,":"))>0){
			/* Test NP_DEFAULT_INI_FILENAME[1-2] in current np_env token */
			if(test_file(np_env,len,NP_DEFAULT_INI_FILENAME1,temp_file)==1 ||
			   test_file(np_env,len,NP_DEFAULT_INI_FILENAME2,temp_file)==1){
				default_file=strdup(temp_file);
				break;
			}

			/* Move on to the next token */
			np_env+=len;
			while(*np_env==':') np_env++;
		} /* while(...) */
	} /* if(getenv("NAGIOS_CONFIG_PATH")) */

	/* Look for NP_DEFAULT_INI_FILENAME1 in NP_DEFAULT_INI_NAGIOS_PATH[1-4] */
	if(!default_file){
		if(test_file(NP_DEFAULT_INI_NAGIOS_PATH1,strlen(NP_DEFAULT_INI_NAGIOS_PATH1),NP_DEFAULT_INI_FILENAME1,temp_file)==1 ||
		   test_file(NP_DEFAULT_INI_NAGIOS_PATH2,strlen(NP_DEFAULT_INI_NAGIOS_PATH2),NP_DEFAULT_INI_FILENAME1,temp_file)==1 ||
		   test_file(NP_DEFAULT_INI_NAGIOS_PATH3,strlen(NP_DEFAULT_INI_NAGIOS_PATH3),NP_DEFAULT_INI_FILENAME1,temp_file)==1 ||
		   test_file(NP_DEFAULT_INI_NAGIOS_PATH4,strlen(NP_DEFAULT_INI_NAGIOS_PATH4),NP_DEFAULT_INI_FILENAME1,temp_file)==1)
			default_file=strdup(temp_file);
	}

	/* Look for NP_DEFAULT_INI_FILENAME2 in NP_DEFAULT_INI_PATH[1-3] */
	if(!default_file){
		if(test_file(NP_DEFAULT_INI_PATH1,strlen(NP_DEFAULT_INI_PATH1),NP_DEFAULT_INI_FILENAME2,temp_file)==1 ||
		   test_file(NP_DEFAULT_INI_PATH2,strlen(NP_DEFAULT_INI_PATH2),NP_DEFAULT_INI_FILENAME2,temp_file)==1 ||
		   test_file(NP_DEFAULT_INI_PATH3,strlen(NP_DEFAULT_INI_PATH3),NP_DEFAULT_INI_FILENAME2,temp_file)==1)
			default_file=strdup(temp_file);
	}

	/* Return default_file or empty string (should return NULL if we want plugins
	 * to die there)...
	 */
	if(default_file)
		return default_file;
	return "";
}
Ejemplo n.º 30
0
drvstus_t rfs_entry(driver_t * drvp, uint_t val, void * p)
{

    printfk("%s %d line \n\r", __func__, __LINE__);
    if(drvp == NULL)
    {
	printfk("drvp NULL\n\r");
	return DFCERRSTUS;
    }
    device_t * devp = new_device_dsc();
    if(devp == NULL)
    {
	printfk("new device failed\n\r");
	return DFCERRSTUS;
    }
    printfk("%s %d line \n\r", __func__, __LINE__);
    rfs_set_driver(drvp);
    printfk("%s %d line \n\r", __func__, __LINE__);
    rfs_set_device(devp, drvp);
    printfk("%s %d line \n\r", __func__, __LINE__);
    if(new_rfsdevext_mmblk(devp, FSMM_BLK) == DFCERRSTUS)
    {
	printfk("new rfsdevext_mmblk failed\n\r");
	if(del_device_dsc(devp) == DFCERRSTUS)
	{
	    printfk("del_device_dsc failed\n\r");
	}
	return DFCERRSTUS;
    }

    printfk("%s %d line \n\r", __func__, __LINE__);
    if(krldev_add_driver(devp, drvp) == DFCERRSTUS)
    {
	printfk("krldev add driver failed\n\r");
	if(del_device_dsc(devp) == DFCERRSTUS)
	{
	    printfk("del_device_dsc failed\n\r");
	}
	return DFCERRSTUS;
    }

    printfk("%s %d line \n\r", __func__, __LINE__);
    if(krlnew_device(devp) == DFCERRSTUS)
    {
	printfk("krlnew device failed\n\r");
	if(del_device_dsc(devp) == DFCERRSTUS)
	{
	    printfk("del_device_dsc failed\n\r");
	}
	return DFCERRSTUS;
    }

    init_rfs(devp);

    test_file(devp);
    return DFCOKSTUS;
}