bool
atf_check::run_status_check(const atf::check::check_result &r)
    const
{
    int status = r.status();
    bool retval = true;

    if (m_status_check == sc_equal) {
        if (m_status_arg != status) {
            std::cerr << "Fail: incorrect exit status: "
                      << status << ", expected: "
                      << m_status_arg << std::endl;
            retval = false;
        }
    } else if (m_status_check == sc_not_equal) {
        if (m_status_arg == status) {
            std::cerr << "Fail: incorrect exit status: "
                      << status << ", expected: "
                      << "anything other" << std::endl;
            retval = false;
        }
    }

    if (retval == false) {
        std::cerr << "stdout:" << std::endl;
        print_file(r.stdout_path());
        std::cerr << std::endl;

        std::cerr << "stderr:" << std::endl;
        print_file(r.stderr_path());
        std::cerr << std::endl;
    }

    return retval;
}

void
unit_test_jit_fragment_tree()
{
    uint i;
    bb_node_t *node_list[FRAGMENT_TREE_TEST_NODE_COUNT]; /* N.B.: may contain NULLs */

    print_file(STDERR, "test DGC fragment tree: ");

    dynamo_options.opt_jit = true;

    fragment_tree = fragment_tree_create();
    set_random_seed((uint) query_time_millis());

    for (i = 0; i < 3; i++) {
        print_file(STDERR, "pass %d... ", i+1);

        unit_test_insert_random_nodes(node_list, FRAGMENT_TREE_TEST_NODE_COUNT);
        unit_test_remove_random_spans(node_list, FRAGMENT_TREE_TEST_NODE_COUNT);
        fragment_tree_clear(fragment_tree);
        unit_test_churn_narrow_span(node_list, FRAGMENT_TREE_TEST_NODE_COUNT);
        fragment_tree_clear(fragment_tree);
    }

    fragment_tree_destroy(fragment_tree);

    print_file(STDERR, "\n");
}

void
unit_test_string(void)
{
    static const char test_path[] = "/path/to/file";
    const char *ret;
    char buf[MAXIMUM_PATH];
    unsigned long num;

    print_file(STDERR, "testing string\n");

    /* strchr */
    ret = strchr(identity(test_path), '/');
    EXPECT(ret == test_path, true);
    ret = strchr(identity(test_path), '\0');
    EXPECT(ret != NULL, true);
    EXPECT(*ret, '\0');

    /* strrchr */
    ret = strrchr(identity(test_path), '/');
    EXPECT(strcmp(ret, "/file"), 0);
    ret = strrchr(identity(test_path), '\0');
    EXPECT(ret != NULL, true);
    EXPECT(*ret, '\0');

    /* strncpy, strncat */
    strncpy(buf, test_path, sizeof(buf));
    EXPECT(is_region_memset_to_char((byte *) buf + strlen(test_path),
                                    sizeof(buf) - strlen(test_path), '\0'),
           true);
    strncat(buf, "/foo_wont_copy", 4);
    EXPECT(strcmp(buf, "/path/to/file/foo"), 0);

    /* strtoul */
    num = strtoul(identity("-10"), NULL, 0);
    EXPECT((long)num, -10);  /* negative */
    num = strtoul(identity("0777"), NULL, 0);
    EXPECT(num, 0777);  /* octal */
    num = strtoul(identity("0xdeadBEEF"), NULL, 0);
    EXPECT(num, 0xdeadbeef);  /* hex */
    num = strtoul(identity("deadBEEF next"), (char **) &ret, 16);
    EXPECT(num, 0xdeadbeef);  /* non-0x prefixed hex */
    EXPECT(strcmp(ret, " next"), 0);  /* end */
    num = strtoul(identity("1001a"), NULL, 2);
    EXPECT(num, 9);  /* binary */
    num = strtoul(identity("1aZ"), NULL, 36);
    EXPECT(num, 1 * 36 * 36 + 10 * 36 + 35);  /* weird base */
    num = strtoul(identity("1aZ"), (char **) &ret, 37);
    EXPECT(num, ULONG_MAX);  /* invalid base */
    EXPECT(ret == NULL, true);

    /* memmove */
    strncpy(buf, test_path, sizeof(buf));
    memmove(buf + 4, buf, strlen(buf) + 1);
    strncpy(buf, "/foo", 4);
    EXPECT(strcmp(buf, "/foo/path/to/file"), 0);

    print_file(STDERR, "done testing string\n");
}

int
cgiMain()
{ 
	cgiHeaderContentType("text/html");
	
	int serverside = 0;
	cgiFormInteger("serverside", &serverside, 0);
	
	char function_call[50];
	int callback = 0;
	if (cgiFormString("function_call", &function_call[0], 50) == cgiFormSuccess)
		callback = 1;
	
	if(serverside) {
		/* Initialise the SEE library */
		SEE_init();
		
		/* Initialise an interpreter */
		SEE_interpreter_init(&g_interp_storage);
		g_interp = &g_interp_storage;
	
		/* Bring our native functions into the interpreter */
		SEE_CFUNCTION_PUTA(g_interp, g_interp->Global, "println", g_println, 1, 0);
		SEE_CFUNCTION_PUTA(g_interp, g_interp->Global, "include", g_include, 1, 0);
		SEE_CFUNCTION_PUTA(g_interp, g_interp->Global, "version", g_version, 1, 0);
		
		/* evaluate bootstrapping code, and then script, then transform events */
		evaluate_file(g_interp, &g_result, "/Users/alan/working/golf/boot/serverside.js");
		evaluate_file(g_interp, &g_result, cgiPathTranslated);
		
		/* this is dangerous lol.  should check to make sure the callback is a function */
		if(callback)
			evaluate_string(g_interp, &g_result, function_call);
		
		/* this converts elements with onclick event attributes into links */
		evaluate_file(g_interp, &g_result, "/Users/alan/working/golf/boot/transform.js");
		evaluate_string(g_interp, &g_result, "document.render();");
		
	} else {
		
		fprintf(cgiOut, "<html>\n<head>\n");
		fprintf(cgiOut, "<script type = \"text/javascript\">\n");
		fprintf(cgiOut, "function boot() {\n");
		print_file("/Users/alan/working/golf/boot/clientside.js");
		print_file(cgiPathTranslated);
		fprintf(cgiOut, "\n}\n");
		fprintf(cgiOut, "</script>\n</head>\n");
		fprintf(cgiOut, "<body onload = \"boot();\">\n");
		fprintf(cgiOut, "</body>\n</html>");
		
	}
	
	return EXIT_SUCCESS;
}

void
dump_thread_kstats(dcontext_t *dcontext)
{
    if (dcontext->thread_kstats == NULL)
        return;

    /* add thread id's in case outfile is rerouted to process_kstats_outfile */
    print_file(dcontext->thread_kstats->outfile_kstats, "Thread %d KSTATS {\n",
               dcontext->thread_kstats->thread_id);
    kstat_report(dcontext->thread_kstats->outfile_kstats,
                 &dcontext->thread_kstats->vars_kstats);
    print_file(dcontext->thread_kstats->outfile_kstats, "} KSTATS\n");
}

/** 도움말을 출력합니다
 *
 * 인자로 받은 도움말 종류중 하나를 출력합니다
 *
 * @param int help 출력할 도움말 `HELP_ALL` , `HELP_START`, `HELP_DONE` ,
 *                 `HELP_LIST` , `HELP_REPORT` 중 하나
 */
void print_help(int help) {
  switch(help) {
    case HELP_ALL:
      print_file("./docs/help.md");
      break;
    case HELP_START:
      print_file("./docs/help_start.md");
      break;
    case HELP_DONE:
      print_file("./docs/help_done.md");
      break;
    default:
      printf("unrecognize option for HELP");
  }
}

/**
 * Prints a graphical view of the directory structure.
 */
int main(int argc, char *argv[]) {

  // directory to list
  char *dir_name;
  // directory listing
  struct dirent **dir_list;
  // file count and loop variable
  int count, i;


  // check if we provided an arguement
  if( argc < 2 ) {
    // use the current dir
    dir_name = ".";
  } else {
    // use the provided dir
    dir_name = argv[1];
  }

  // read directory listing into array
  count = scandir(dir_name, &dir_list, file_select, alphasort);

  // loop through each file
  for (i=1; i<count+1; ++i)
    print_file(dir_list[i-1]);

  // exit cleanly
  return 0;

}

int
main(int argc, char **argv, char **envp)
{
    dcontext_t *dc = standalone_init();

    /* Each test will abort if it fails, so we just call each in turn and return
     * 0 for success.  If we want to be able to call each test independently, it
     * might be worth looking into gtest, which already does this.
     */
    unit_test_io();
#ifdef UNIX
    unit_test_string();
    unit_test_os();
#endif
    unit_test_utils();
    unit_test_options();
    unit_test_vmareas();
#ifdef WINDOWS
    unit_test_drwinapi();
#endif
    unit_test_asm(dc);
    unit_test_atomic_ops();
    unit_test_jit_fragment_tree();
    print_file(STDERR, "all done\n");
    return 0;
}

int main(int ac, char **av) {
  /* Function opens, sends to print, and closes file to be printed */
  int fd;

  if (ac != 2) /* Confirm there are two arguments */
    return 1;

  fd = open(av[1], O_RDONLY); /* Opens the file */
  if (fd == -1) {
    perror("open");
    return 1;
  }

  if (print_file(fd) == 1){ /* Prints the file */
    perror("read");
    return 1;
  }

  if (close(fd) == -1) { /* Close the file */
    perror("close");
    return 1;
  }

  return 0;
}

/* funcao responsavel pela montagem do arquivo. Une  todos processos. */
void mount(char* fileFrom, char* fileTo) {
    set_table s_table;
    label_table l_table = build_labels(fileFrom, &s_table);

    print_file(fileFrom, fileTo, l_table, s_table);
    free_tables(s_table, l_table);
}

int main()
{

	printf("Hello world! \n");
	int i=0;
	char *liste;
	int16_t taille_liste=0;
	int16_t nb_block= 500;
	sfs = createSfs("sfstest", nb_block);
	printf("dans createSfs la signature est %s \n", sfs.sb.signature);
	printf("taille de sfs en block %d \n", sfs.sb.nbBlockTotal);
	sfsadd(&sfs, "fichier.txt");
	sfsadd(&sfs, "fichier2.txt");


	liste=sfslist(&sfs,&taille_liste);
	printf("Dans main liste est \n");
	for(i=0; i<taille_liste; i++)
		printf("%c", liste[i]);
	printf("\n");;

	printf("sfs.name[0] %s \n", sfs.fe[0].name);
	printf("sfs.name[1] %s \n", sfs.fe[1].name);
	printf("sfs.name[2] %s \n", sfs.fe[2].name);
	print_file(sfs.fc.data[2]);
	createImage();
	return 0;
}

void		print_dir(t_files *head, char *dir_name, t_ls_args *args)
{
	int		links_column;
	int		size_column;

	links_column = get_length_column(head, 1);
	size_column = get_length_column(head, 2);
	ft_putstr(dir_name);
	ft_putendl(":");
	if (ft_strchr(args->options, 'l') && head)
	{
		ft_putstr("total ");
		ft_putnbr(get_total_size(head));
		ft_putchar('\n');
	}
	while (head)
	{
		if (ft_strchr(args->options, 's'))
		{
			ft_putnbr(head->blocks);
			ft_putchar(' ');
		}
		print_file(head, args, links_column, size_column);
		head = head->next;
	}
}

int main(int argc, char *argv[]) {
    num_tokens = 0;
    num_vars = 0;

    // set yyin to file if passed by user
    if(argc > 1) {
        yyin = fopen(argv[1], "r");
        if(yyin == NULL) {
            printf("error: invalid file\n");
            exit(1);
        }
    }
    else {
        printf("> "); // prompt
    }

    yyparse();
    fclose(yyin);
    generate_pla(root);

    and_or_not(root);
    freopen ("/dev/tty", "a", stdout); // make sure stdout is restored

    free_ast(root);
    empty_tokens();
    reformat_output();

    // print output
    char *fname = (char *)"out.pla";
    print_file(&fname);

    return 0;
}

/* PR 312534: reduce stack usage (gcc does not combine locals) */
static void
kstat_print_individual(file_t outf, kstat_variable_t *kv,
                       const char *name, const char *desc)
{
    print_file(outf, "%20s:"FIXED_TIMESTAMP_FORMAT" totc,"
               "%8u num,"
               FIXED_TIMESTAMP_FORMAT" minc,"
               FIXED_TIMESTAMP_FORMAT" avg,"
               FIXED_TIMESTAMP_FORMAT" maxc,"
               FIXED_TIMESTAMP_FORMAT" self,"
               FIXED_TIMESTAMP_FORMAT" sub,"
               "\n"
               "                   "
               FIXED_TIMESTAMP_FORMAT" ms,"
               FIXED_TIMESTAMP_FORMAT" ms out,"
               "%s\n",
               name,
               kv->total_self + kv->total_sub,
               kv->num_self,
               (kv->min_cum == (timestamp_t)-1) ? 0 : kv->min_cum,
               (kv->total_self + kv->total_sub) / kv->num_self,
               kv->max_cum,
               kv->total_self,
               kv->total_sub,
               (kv->total_self + kv->total_sub) / kstat_frequency_per_msec,
               kv->total_outliers/ kstat_frequency_per_msec,
               desc);
}

double print_file2()
{
  char filename[100];
  FILE *fr;
  
  printf("Zadejte jmeno souboru: ");
  scanf("%s", filename);

  if ((fr = fopen(filename, "r")) == NULL) {
    printf("Soubor %s nebyl nalezen!\n", filename);
    return filename_is_k(filename) ? 2.2 : 1.1;
  }

  print_file(fr);
  
  if (fclose(fr) == EOF) {
    printf("Nepodarilo se zavrit soubor %s!\n", filename);
    return 0.5;
  }

  if (filename_is_k(filename)) {
    return 2.2;
  }

  return 0.5;

}

int do_normal_ls(const char *remote_path, int option_show_detail) {
//{{{
    int ret             = 0;
    PCSFile *file       = NULL;
    PCSFileList *list   = NULL;
    PCSFile *tmp        = NULL;
    const char *error   = NULL;

    file = BaiduPCS_NewRemoteFile(api, remote_path);
    error = BaiduPCS_GetError(api);
    if (error != NULL || file == NULL) {
        color_log(COLOR_LOG_ERROR, "%s 获取文件信息失败:%s\n", remote_path, error);
        ret = 1;
        goto free;
    }

    if (!file->is_dir) {
        print_file(file, option_show_detail);
    } else {
        list = BaiduPCS_ListRemoteDir(api, file->path);
        error = BaiduPCS_GetError(api);
        if (error != NULL || list == NULL) {
            color_log(COLOR_LOG_ERROR, "%s 获取文件信息失败:%s\n", file->path, error);
            ret = 1;
            goto free;
        }
        tmp = list->first;
        while (tmp) {
            print_file(tmp, option_show_detail);
            tmp = tmp->next;
        }
        PCSFileList_Free(list);
        list = NULL;
    }

free:
    if (file != NULL) {
        PCSFile_Free(file); 
    }

    if (list != NULL) {
        PCSFileList_Free(list);
    }

    return ret;
}

void
print_path(const char *file)
{
    struct stat st;
    lstat(file, &st);
    if (S_ISDIR(st.st_mode))
        print_dir(file);
        else print_file(file);
}

static int do_ls(int argc, char **argv)
{
	u8 buf[256], *cur = buf;
	int r, count;

	r = sc_list_files(card, buf, sizeof(buf));
	if (r < 0) {
		check_ret(r, SC_AC_OP_LIST_FILES, "unable to receive file listing", current_file);
		return -1;
	}
	count = r;
	printf("FileID\tType  Size\n");
	while (count >= 2) {
		sc_path_t path;
		sc_file_t *file = NULL;
		char filename[10];
		int i = 0;
		int matches = 0;

		/* construct file name */
		sprintf(filename, "%02X%02X", cur[0], cur[1]);

		 /* compare file name against patterns */
		for (i = 0; i < argc; i++) {
			if (pattern_match(argv[i], filename)) {
				matches = 1;
				break;
			}
		}

		/* if any filename pattern were given, filter only matching file names */
		if (argc == 0 || matches) {
			if (current_path.type != SC_PATH_TYPE_DF_NAME) {
				path = current_path;
				sc_append_path_id(&path, cur, 2);
			} else {
				if (sc_path_set(&path, SC_PATH_TYPE_FILE_ID, cur, 2, 0, 0) != SC_SUCCESS) {
					printf("unable to set path.\n");
					die(1);
				}
			}

			r = sc_select_file(card, &path, &file);
			if (r) {
				printf(" %02X%02X unable to select file, %s\n", cur[0], cur[1], sc_strerror(r));
			} else {
				file->id = (cur[0] << 8) | cur[1];
					print_file(file);
				sc_file_free(file);
			}
		}
		cur += 2;
		count -= 2;
		select_current_path_or_die();
	}
	return 0;
}

int main(int argc, const char **argv) {
    char *id = NULL, *line = NULL;
    int show_utmp = 1, show_wtmp = 0;
    int c;
    poptContext optCon;
    struct poptOption optionsTable[] = {
        { "utmp", 'u', POPT_ARG_NONE|POPT_ARGFLAG_XOR, 
	   &show_utmp, 0,
          "toggle showing contents of utmp file", NULL },
        { "wtmp", 'w', POPT_ARG_NONE|POPT_ARGFLAG_XOR, 
	   &show_wtmp, 0,
          "toggle showing contents of wtmp file", NULL },
        { "id", 'i', POPT_ARG_STRING, &id, 0,
          "show process entries for specified inittab id", 
	  "<inittab id>" },
        { "line", 'l', POPT_ARG_STRING, &line, 0,
          "show process entries for specified device line", 
	  "<line>" },
        POPT_AUTOHELP
        POPT_TABLEEND
    };

    optCon = poptGetContext("utmp", argc, argv, optionsTable, 0);
    if ((c = poptGetNextOpt(optCon)) < -1) {
        fprintf(stderr, "%s: %s\n",
            poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
            poptStrerror(c));
        return 1;
    }
    poptFreeContext(optCon);

    if (id && line)
        fprintf(stderr, "Cannot choose both by id and line, "
			"choosing by line\n");

    if (show_utmp)
        print_file(_PATH_UTMP, id, line);
    if (show_utmp && show_wtmp)
        printf("\n\n\n");
    if (show_wtmp)
        print_file(_PATH_WTMP, id, line);

    return 0;
}

int main(int argc, char **argv)
{
    static char *callback = NULL, *user;
    int i;
    extern int headers_initialized;

    if (argc < 2) {  /* normal operation as a CGI application */
	cgi_init();
	atexit(cgi_end);
       	cgi_process_form();
	printf("Content-type: application/javascript; charset=utf-8\r\n\r\n");
    }
    else
        interactive = 1;  /* interactive mode for debugging */
    wfdbquiet();	  /* suppress WFDB library error messages */
    atexit(cleanup);	/* release allocated memory before exiting */

    /* Define data sources to be accessed via this server. */
    setrepos();		/* function defined in "setrepos.c" */

    if (!(action = get_param("action"))) {
	print_file(LWDIR "/doc/about.txt");
	exit(0);
    }

    if (!interactive && (callback = get_param("callback"))) {
	printf("%s(", callback);	/* JSONP:  "wrap" output in callback */
	atexit(jsonp_end);	/* close the output with ")" before exiting */
    }

    if (strcmp(action, "dblist") == 0)
	dblist();

    else if ((db = get_param("db")) == NULL)
	lwfail("Your request did not specify a database");
  
    else if (strcmp(action, "rlist") == 0)
	rlist();

    else if (strcmp(action, "alist") == 0)
	alist();

    else if ((record = get_param("record")) == NULL)
	lwfail("Your request did not specify a record");

    else if (strcmp(action, "info") == 0)
	info();

    else if (strcmp(action, "fetch") == 0)
	fetch();

    else
	lwfail("Your request did not specify a valid action");

    exit(0);
}