static RNG *
get_rng (void)
{
  static RNG rng;
  static bool rng_initialized = false;

  if (!rng_initialized)
    {
      if (!check_result (InitRng (&rng)))
        return NULL;
      rng_initialized = true;
    }

  return &rng;
}

int cgroup_add(unicorn_t * u){
	int i;
	for (i=0; i< cgroup_subsystems_lengh; i++){
		char system_path[80];
		check_result(sprintf(system_path, "%s/%s", cgroup_base_dir, cgroup_subsystems[i]),system_path);

		char cmd[100];
		check_result(sprintf(cmd, "mkdir -p %s/%s", system_path, u->unicorn_id),cmd);
		check_result(system(cmd), "system call mkdir ");

		// char file_path[100];
		// check_result(sprintf(file_path, "%s/%s/%s/tasks", cgroup_base_dir, cgroup_subsystems[i], u->unicorn_id),file_path);

  //       char value[10];
  //       check_result(sprintf(value, "%d", u->child_pid), value);
  //       printf("write value %s to %s \n", value, file_path);	
		// FILE * f = fopen(file_path, "w");
		// if(f == NULL){
		// 	printf("open file error %s \n", strerror(errno));
		// 	exit(errno);
		// }
		// int rt = fputs("2345", f);
		// if( rt < 0) {
		// 	printf("write task file error %s ", cgroup_subsystems[i]);
		// 	exit(-1);
		// }
		// printf("write %d chars \n", rt);
        if( strcmp(cgroup_subsystems[i], "cpuset") == 0){
        	check_result(sprintf(cmd, "cat %s/cpuset.mems > %s/%s/cpuset.mems", system_path, system_path, u->unicorn_id),cmd);
        	check_result(system(cmd), "system call add cpuset.mems ");

        	check_result(sprintf(cmd, "cat %s/cpuset.cpus > %s/%s/cpuset.cpus", system_path, system_path, u->unicorn_id),cmd);
        	check_result(system(cmd), "system call add cpuset.cpus ");

        }
		check_result(sprintf(cmd, "echo %d > %s/%s/tasks", u->child_pid, system_path, u->unicorn_id),cmd);
		check_result(system(cmd), "system call add pid ");
    }

	return 0;
}

bool
tr_rand_buffer (void   * buffer,
                size_t   length)
{
  bool ret;
  tr_lock * rng_lock = get_rng_lock ();

  assert (buffer != NULL);

  tr_lockLock (rng_lock);
  ret = check_result (RNG_GenerateBlock (get_rng (), buffer, length));
  tr_lockUnlock (rng_lock);

  return ret;
}

int flatcc_verify_struct_as_nested_root(flatcc_table_verifier_descriptor_t *td,
        voffset_t id, int required, const char *fid, uint16_t align, size_t size)
{
    const uoffset_t *buf;
    uoffset_t bufsiz;

    check_result(flatcc_verify_vector_field(td, id, required, align, 1, FLATBUFFERS_COUNT_MAX(1)));
    if (0 == (buf = get_field_ptr(td, id))) {
        return flatcc_verify_ok;
    }
    buf = (const uoffset_t *)((size_t)buf + read_uoffset(buf, 0));
    bufsiz = read_uoffset(buf, 0);
    ++buf;
    return flatcc_verify_struct_as_root(buf, bufsiz, fid, align, size);
}

void TopParser::next(TypeDef::Atom *atom)
 {
  TypeDef::State *state=topState();
  
  TypeDef::Rule *rule=Find(state->final->actions,atom);
  
  if( rule )
    {
     Printf(Exception,"App::TopParser::next(...) : rule mismatch");
    }
  
  if( atom ) 
    push(atom,Transition(state->transitions,atom));
  else
    check_result();
 }

int ulcd_sd_image_load(ulcd_dev *dev, const char *file, uint16_t x, uint16_t y) {
    // Write commands
    write_char(dev, 0x40);
    write_char(dev, 0x6D);
    serial_write(dev->port, file, strlen(file));
    write_char(dev, 0x00);
    write_word(dev, x);
    write_word(dev, y);
    write_word(dev, 0);

    // Check results
    if(!check_result(dev, "Image load+show failed.")) {
        return 0;
    }
    return 1;
}

static int maintain_reactor(int epoll_fd, int action, int fd, int event_type)
{
	CHECK_FD_RETURN(epoll_fd, -1);
	CHECK_FD_RETURN(fd, -1);

	struct epoll_event event;
	memset(&event, 0, sizeof(event));

	event.events = event_type;
	event.data.fd = fd;

	int ret = epoll_ctl(epoll_fd, action, fd, &event);
	check_result(ret, errno, "epoll_ctl");

	return ret;
}

/*
 * This could be further simplified by constructing an expected
 * HANDSHAKE_RESULT, and implementing comparison methods for
 * its fields.
 */
static int check_test(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
{
    int ret = 1;
    ret &= check_result(result, test_ctx);
    ret &= check_alerts(result, test_ctx);
    if (result->result == SSL_TEST_SUCCESS) {
        ret &= check_protocol(result, test_ctx);
        ret &= check_servername(result, test_ctx);
        ret &= check_session_ticket(result, test_ctx);
        ret &= (result->session_ticket_do_not_call == 0);
        ret &= check_npn(result, test_ctx);
        ret &= check_alpn(result, test_ctx);
        ret &= check_resumption(result, test_ctx);
    }
    return ret;
}

main ()
{
  int	lp;

  int	errors = 0;


  thds = omp_get_max_threads ();
  if (thds == 1) {
    printf ("should be run this program on multi threads.\n");
    exit (0);
  }
  buf = (int *) malloc (sizeof (int) * (LOOPNUM + 1));
  if (buf == NULL) {
    printf ("can not allocate memory.\n");
    exit (1);
  }
  idbuf = (int *) malloc (sizeof (int) * thds);
  if (idbuf == NULL) {
    printf ("can not allocate memory.\n");
    exit (1);
  }
  omp_set_dynamic (0);


  clear ();
  #pragma omp parallel
  {
    #pragma omp for
    for (lp=0; lp<LOOPNUM; lp++) {
      buf[lp] = omp_get_thread_num ();
    }
  }
  errors += check_result ();


  if (errors == 0) {
    printf ("for 010 : SUCCESS\n");
    if (use_thd == 1) {
      printf ("but, for loop executed by 1 thread.\n");
    }
    return 0;
  } else {
    printf ("for 010 : FAILED\n");
    return 1;
  }
}

/*%
 * short_form message print handler.  Calls above say_message()
 */
static isc_result_t
short_answer(dns_message_t *msg, dns_messagetextflag_t flags,
	     isc_buffer_t *buf, dig_query_t *query)
{
	dns_name_t *name;
	dns_rdataset_t *rdataset;
	isc_result_t result, loopresult;
	dns_name_t empty_name;
	dns_rdata_t rdata = DNS_RDATA_INIT;

	UNUSED(flags);

	dns_name_init(&empty_name, NULL);
	result = dns_message_firstname(msg, DNS_SECTION_ANSWER);
	if (result == ISC_R_NOMORE)
		return (ISC_R_SUCCESS);
	else if (result != ISC_R_SUCCESS)
		return (result);

	for (;;) {
		name = NULL;
		dns_message_currentname(msg, DNS_SECTION_ANSWER, &name);

		for (rdataset = ISC_LIST_HEAD(name->list);
		     rdataset != NULL;
		     rdataset = ISC_LIST_NEXT(rdataset, link)) {
			loopresult = dns_rdataset_first(rdataset);
			while (loopresult == ISC_R_SUCCESS) {
				dns_rdataset_current(rdataset, &rdata);
				result = say_message(&rdata, query,
						     buf);
				if (result == ISC_R_NOSPACE)
					return (result);
				check_result(result, "say_message");
				loopresult = dns_rdataset_next(rdataset);
				dns_rdata_reset(&rdata);
			}
		}
		result = dns_message_nextname(msg, DNS_SECTION_ANSWER);
		if (result == ISC_R_NOMORE)
			break;
		else if (result != ISC_R_SUCCESS)
			return (result);
	}

	return (ISC_R_SUCCESS);
}

// gets a json value from a key
int json_object_get_string(json_t *object, char *key, char **value)
{
  char *value_return = NULL;

  int exit_code = 0;

  check_not_null(object);
  check_not_null(key);
  check_not_null(value);

  json_t *json_string_peek = json_object_get(object, key);
  if (json_string_peek == NULL)
  {
    *value = NULL;
    goto cleanup;
  }

  int json_typeof_result = json_typeof(json_string_peek);
  if (json_typeof_result != JSON_STRING)
  {
    *value = NULL;
    goto cleanup;
  }

  char *value_peek = (char *)json_string_value(json_string_peek);
  if (value_peek == NULL)
  {
    *value = NULL;
    goto cleanup;
  }

  check_result(malloc_memcpy_string(&value_return, value_peek), 0);

  *value = value_return;

  goto cleanup;

error:

  if (value_return != NULL) { free(value_return); }

  exit_code = -1;

cleanup:

  return exit_code;
}

int ulcd_draw_pixel(ulcd_dev *dev,
                    uint16_t x, uint16_t y,
                    uint16_t color) {
    char buf[7];
    buf[0] = 0x50;
    buf[1] = x >> 8;
    buf[2] = x & 0xFF;
    buf[3] = y >> 8;
    buf[4] = y & 0xFF;
    buf[5] = color >> 8;
    buf[6] = color & 0xFF;
    serial_write(dev->port, buf, 7);
    if(!check_result(dev, "Error while drawing pixel.")) {
        return 0;
    }
    return 1;
}

int solve(ull_t n)
{
	ull_t sum = 0;
	for(ull_t i = 0; i <= n; i++) {
		sum += i * i;
	}
	ull_t sum_square = 0;
	for(ull_t i = 0; i <= n; i++) {
		sum_square += i;
	}
	sum_square = sum_square * sum_square;
	printf("Sum of the squares: %llu\n", sum);
	printf("Square of the sum: %llu\n", sum_square);
	printf("Difference: %llu\n", sum_square - sum);
	check_result(n == 10, sum == 385 && sum_square == 3025);
	return 0;
}

// 读取sock peer信息
void getpeerinfo(int fd, char* addr, uint32_t* port)
{
	if (-1 == fd || NULL == addr || NULL == port) {
		assert(0);
		return;
	}

	struct sockaddr_in saddr;
	socklen_t   len = sizeof(saddr);

	int ret = getpeername(fd, (struct sockaddr*)&saddr, &len);
	check_result(ret, errno, "getpeername");
	const char* paddr = inet_ntop(AF_INET, &saddr.sin_addr, addr, INET_ADDRSTRLEN);
	assert(NULL != paddr);

	*port = ntohs(saddr.sin_port);
}

/**
 *
 * @brief Mutex lock/unlock test
 *
 * @return N/A
 */
void mutex_test(void)
{
	u32_t et; /* elapsed time */
	int i;

	PRINT_STRING(dashline, output_file);
	et = BENCH_START();
	for (i = 0; i < NR_OF_MUTEX_RUNS; i++) {
		k_mutex_lock(&DEMO_MUTEX, K_FOREVER);
		k_mutex_unlock(&DEMO_MUTEX);
	}
	et = TIME_STAMP_DELTA_GET(et);
	check_result();

	PRINT_F(output_file, FORMAT, "average lock and unlock mutex",
		SYS_CLOCK_HW_CYCLES_TO_NS_AVG(et, (2 * NR_OF_MUTEX_RUNS)));
}

static int konoha_test(const char *testname)
{
	verbose_debug = 0;
	verbose_sugar = 0;
	verbose_gc    = 0;
	verbose_code  = 0;
	konoha_t konoha = konoha_open();
	if(preimport != NULL) {
		konoha_preimport((CTX_t)konoha, preimport);
	}
	if(startup_script != NULL) {
		konoha_startup(konoha, startup_script);
	}
	int ret = 0;//OK
	char script_file[256];
	char correct_file[256];
	char result_file[256];
	snprintf(script_file, 256, "%s", testname);
	snprintf(correct_file, 256, "%s.proof", script_file);
	snprintf(result_file, 256, "%s.tested", script_file);
	FILE *fp = fopen(correct_file, "r");
	if (fp == NULL) {
		fprintf(stdout, "no proof file: %s\n", testname);
	}
	stdlog = fopen(result_file, "w");
	((struct _klib2*)konoha->lib2)->Kreport  = Kreport;
	((struct _klib2*)konoha->lib2)->Kreportf = Kreportf;
	konoha_load(konoha, script_file);
	fprintf(stdlog, "Q.E.D.\n");   // Q.E.D.
	fclose(stdlog);
	if(fp != NULL) {
		FILE *fp2 = fopen(result_file, "r");
		ret = check_result(fp, fp2);
		if(ret == 0) {
			fprintf(stdout, "[PASS]: %s\n", testname);
		}
		fclose(fp);
		fclose(fp2);
	}
	else {
		ret = 1;
	}
	konoha_close(konoha);
	return ret;
}

static void
show_settings(isc_boolean_t full, isc_boolean_t serv_only) {
	dig_server_t *srv;
	isc_sockaddr_t sockaddr;
	dig_searchlist_t *listent;
	isc_result_t result;

	srv = ISC_LIST_HEAD(server_list);

	while (srv != NULL) {
		char sockstr[ISC_SOCKADDR_FORMATSIZE];

		result = get_address(srv->servername, port, &sockaddr);
		check_result(result, "get_address");

		isc_sockaddr_format(&sockaddr, sockstr, sizeof(sockstr));
		printf("Default server: %s\nAddress: %s\n",
			srv->userarg, sockstr);
		if (!full)
			return;
		srv = ISC_LIST_NEXT(srv, link);
	}
	if (serv_only)
		return;
	printf("\nSet options:\n");
	printf("  %s\t\t\t%s\t\t%s\n",
	       tcpmode ? "vc" : "novc",
	       short_form ? "nodebug" : "debug",
	       debugging ? "d2" : "nod2");
	printf("  %s\t\t%s\n",
	       usesearch ? "search" : "nosearch",
	       recurse ? "recurse" : "norecurse");
	printf("  timeout = %d\t\tretry = %d\tport = %d\tndots = %d\n",
	       timeout, tries, port, ndots);
	printf("  querytype = %-8s\tclass = %s\n", deftype, defclass);
	printf("  srchlist = ");
	for (listent = ISC_LIST_HEAD(search_list);
	     listent != NULL;
	     listent = ISC_LIST_NEXT(listent, link)) {
		     printf("%s", listent->origin);
		     if (ISC_LIST_NEXT(listent, link) != NULL)
			     printf("/");
	}
	printf("\n");
}

/**
 *
 * @brief Write the number of data chunks into the mailbox
 *
 * @param size    The size of the data chunk.
 * @param count   Number of data chunks.
 * @param time    The total time.
 *
 * @return N/A
 */
void mailbox_put(u32_t size, int count, u32_t *time)
{
	int i;
	unsigned int t;

	Message.rx_source_thread = K_ANY;
	Message.tx_target_thread = K_ANY;

	/* first sync with the receiver */
	k_sem_give(&SEM0);
	t = BENCH_START();
	for (i = 0; i < count; i++) {
		k_mbox_put(&MAILB1, &Message, K_FOREVER);
	}
	t = TIME_STAMP_DELTA_GET(t);
	*time = SYS_CLOCK_HW_CYCLES_TO_NS_AVG(t, count);
	check_result();
}

static void
parse_name(char **cmdlinep, dns_name_t *name) {
	isc_result_t result;
	char *word;
	isc_buffer_t source;

	word = nsu_strsep(cmdlinep, " \t\r\n");
	if (word == NULL || *word == 0) {
		fprintf(stderr, "could not read owner name\n");
		exit(1);
	}

	isc_buffer_init(&source, word, strlen(word));
	isc_buffer_add(&source, strlen(word));
	result = dns_name_fromtext(name, &source, dns_rootname, 0, NULL);
	check_result(result, "dns_name_fromtext");
	isc_buffer_invalidate(&source);
}

int validator_test(void)
{
    int i=0;
    int success_count=0;
    jerif_err err_code = jerif_ok;

    for(i=0; i<validator_test_case_count; i++){
        printf("Test Case #%d\n", i+1);
        err_code = jerif_check_validation(validator_test_case_json_str[i]);
        success_count += check_result(validator_test_case_expected_result[i] == err_code);
    }

    if(success_count >= validator_test_case_count){
        return 0;
    }else{
        return -1;
    }
}