int main()
{
do_it();
do_it();
do_it();
do_it();
do_it();
}
int main(void)
{
plan_tests(3);
do_it(1);
do_it(10);
do_it(300);
return exit_status();
}
int main(int argc,char **argv)
{
int listenfd,connfd;
pid_t childpid;
struct sockaddr_in servaddr,cliaddr;
socklen_t clilen;
listenfd = Socket(AF_INET,SOCK_STREAM,0);
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(WBING_PORT);
Bind(listenfd,(SA *) &servaddr,sizeof(servaddr));
Listen(listenfd,10);
signal(SIGCHLD,sig_chld);
for(;;)
{
clilen = sizeof(cliaddr);
connfd = Accept(listenfd,(SA*) &cliaddr,&clilen);
if((childpid=Fork())==0){
Close(listenfd);
do_it(connfd);
exit(0);
}
Close(connfd);
}
}
BOOST_FORCEINLINE
void del(A0& a0, A1 & a1, const char& orient, boost::mpl::long_<2> const&) const
{
BOOST_AUTO_TPL(r1, boost::proto::child_c<1>(a1));
BOOST_AUTO_TPL(q1, boost::proto::child_c<0>(a1));
do_it(a0,orient,q1,r1);
}
void stack_for_each(struct stack * _stack, void (*do_it)(struct node *))
{
struct node * cur = _stack->head_node->next;
for (; cur != _stack->head_node; cur = cur->next)
do_it(cur);
}
int main(int argc, char **argv) {
char *file;
int c;
optarg = NULL;
while ((c = getopt(argc, argv, "sqc")) != -1) {
switch (c) {
case 's':
silent = 1;
break;
case 'q':
query = 1;
break;
case 'c':
suppress = 1;
break;
case '?':
usage();
}
}
if (optind == argc)
usage();
else
file = argv[optind++];
return do_it(file, argc-optind, &argv[optind]);
}
int
main(int argc, char *argv[])
{
int sr, err;
GUI_mode = NO;
StopIt = NO;
wr_title();
if( (argc != 2) && (argc != 3) )
{
hlp_usage();
exit(1);
}
if(argc==2) {
log_level_limit=LOG_LEVEL_DEFAULT;
} else {
sr=sscanf(argv[2], "%d", &log_level_limit);
if(sr<=0 || sr== EOF) {
print_derr(
"Wrong number for verbosity level, set to %d.",
LOG_LEVEL_DEFAULT);
log_level_limit=LOG_LEVEL_DEFAULT;
}
}
err = do_it(argv[1]);
if (err != NO_ERROR ) {
exit(1);
}
exit(0);
}
static void khrn_worker_llat_callback(void)
{
if (more_msgs(khrn_worker_msg.done_it, khrn_worker_msg.post) &&
do_it() &&
more_msgs(khrn_worker_msg.done_it, khrn_worker_msg.post)) {
khrn_llat_notify(llat_i);
}
}
void main(void)
{
float f = 0.0;
printf("Please input a float num: ");
scanf("%f", &f);
do_it(f);
}
int
main(int argc,char **argv )
{
int port,i;
int count;
if( argc != 4 ){
fprintf( stderr, "Usage: mcli host port count\n" );
return 1;
}
port = atoi( argv[2] );
count = atoi( argv[3] );
gettimeofday( &start_time, NULL );
/* 最初に一挙にconnect */
for(i=0;i<count;i++){
int s , nso;
struct sockaddr_in sin;
memset( &sin, 0 , sizeof( sin ));
sin.sin_family = AF_INET;
sin.sin_port = htons( port );
if( inet_aton( argv[1], &sin.sin_addr ) ==0 ){
return 1;
}
s = socket( AF_INET, SOCK_STREAM, 0 );
if( s < 0 ){
fprintf( stderr , "socket() error:%s\n", strerror(errno ) );
return 1;
}
if( connect( s, (struct sockaddr*)&sin, sizeof( sin )) < 0 ){
fprintf( stderr ,"connect error\n" );
return 1;
}
nso = new_so();
if( nso < 0 ){
fprintf( stderr , "new_so fail\n" );
return 1;
}
so[nso].use = 1;
so[nso].fd = s;
so[nso].read_total = so[nso].write_total = 0.0F;
}
while(1){
do_it();
}
close_all();
return 0;
}
int main()
{
char* arr[3] = {"hello", "world", "goodbye"};
do_it(arr);
return 0;
}
int main(int argc, char *argv[]) {
int ret;
IMP::base::Pointer<IMP::npctransport::SimulationData> sd
= IMP::npctransport::startup(argc, argv);
ret=do_it(sd);
return ret;
}
void main()
{
char *a;
a = malloc(20*sizeof(char));
printf("enter the input file name\n");
scanf("%s",a);
FILE *p;
p = fopen(a,"r+");
do_it(p);
}
int
main (int argc, char *argv[])
{
int i;
me = argv[0];
for (i = 0; i < sizeof (test_cases) / sizeof (struct test_case); i++)
do_it (&test_cases[i]);
return 0;
}
static void *khrn_worker_main(void * param)
{
UNUSED(param);
do {
vcos_event_wait(&event);
while (more_msgs(khrn_worker_msg.done_it, khrn_worker_msg.post) && do_it()) ;
} while (!exit_thread);
return NULL;
}
int main() {
double input;
std::string output;
std::tie(input, output) = secret_sauce();
// example test
assert(to_string(0.5) == "0.5");
// the real test
assert(do_it(input) == output);
}
static void do_it(void)
{
struct X z[8];
int i;
for (i = 0; i < ARRAY_SIZE(z); i++)
z[i] = N(i);
Z(7).d[0] = &Z(2);
Z(2).d[0] = &Z(4);
Z(4).d[0] = NULL;
Z(4).d[1] = NULL;
Z(2).d[1] = &Z(5);
Z(5).d[0] = NULL;
Z(5).d[1] = NULL;
Z(7).d[1] = &Z(1);
Z(1).d[0] = &Z(6);
Z(6).d[0] = NULL;
Z(6).d[1] = NULL;
Z(1).d[1] = &Z(3);
Z(3).d[0] = NULL;
Z(3).d[1] = NULL;
struct binary_heap b = {
.top = &Z(7),
.sz = 7,
.ord = X_ord
};
push_down(&b);
ok_eq(b.top, &Z(1));
ok_eq(Z(1).d[0], &Z(2));
ok_eq(Z(2).d[0], &Z(4));
ok_eq(Z(4).d[0], NULL);
ok_eq(Z(4).d[1], NULL);
ok_eq(Z(2).d[1], &Z(5));
ok_eq(Z(5).d[0], NULL);
ok_eq(Z(5).d[1], NULL);
ok_eq(Z(1).d[1], &Z(3));
ok_eq(Z(3).d[0], &Z(6));
ok_eq(Z(6).d[0], NULL);
ok_eq(Z(6).d[1], NULL);
ok_eq(Z(3).d[1], &Z(7));
ok_eq(Z(7).d[0], NULL);
ok_eq(Z(7).d[1], NULL);
}
int main(void)
{
plan_tests(1 + 2 + 4 + 8);
do_it();
return exit_status();
}
void main()
{
char *input;
input = malloc(30*sizeof(char));
printf("enter the file name: ");
scanf("%s",input);
FILE *p;
p = fopen(input,"r+");
int n = read(p);
int *btm = malloc(n*sizeof(int));
do_it(p,btm,n);
}
int main(int argc, char **argv)
{
gp2x_init(1000,
16, // bpp
44100, // sound freq
16, // 16-bit sound
1, // stereo
60, // unused (must not be zero!)
1 // solid font?
);
gp2x_video_YUV_setparts(0,-1,-1,-1,319,239);
gp2x_video_RGB_setwindows(0x10,0x10,0x10,0x10,319,239);
do_it();
do_it_image();
return 0;
}
int
main( int argc, char *argv[] )
{
int fd;
int i;
int count;
if( argc != 2 ) {
fprintf( stderr, "Usage %s [seconds willing to wait for ckpt signal]\n",
argv[0] );
exit( 1 );
}
count = atoi( argv[1] );
if( count <= 0 ) {
fprintf( stderr, "Seconds must be positive\n" );
exit( 1 );
}
const char* tmp_dir = create_unique_name("tmp");
if( (fd=open(tmp_dir,O_CREAT|O_TRUNC|O_RDWR,0664)) < 0 ) {
perror( "tmp directory creation failed" );
exit( 1 );
}
init_data( Data, sizeof(Data) );
/* ok, running for X seconds is a bit disingenuous because the program
could run for 5 seconds, checkpoint and be idle for > count seconds,
and when it restarts, immediately terminate. Since this test really
needs us to wait around for a checkpoint signal, the seconds count
is really the time we're willing to wait for a checkpoint signal
before stopping the io loop and exiting.
*/
{
time_t b4 = time(0);
i = 0;
while ((time(0) - b4) < count) {
do_it( Data, fd, sizeof(Data) );
printf( "%d ", i++ );
fflush( stdout );
}
}
printf( "\nNormal End Of Job\n" );
exit( 0 );
}
void parse_rvalue(void **DataPtr)
{
double local = 0.0;
int terms = 1;
*DataPtr = create_float();
switch (terms)
{
case 1:
*((double *)*DataPtr) = local;
break;
case 2:
do_it(*DataPtr, &local);
break;
}
}
int main(int argc, char **argv)
{
INT i;
INT verbose_level = 0;
t0 = os_ticks();
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-v") == 0) {
verbose_level = atoi(argv[++i]);
cout << "-v " << verbose_level << endl;
}
}
do_it(verbose_level);
the_end(t0);
}
main(int argc, char **argv)
{
FILE *src, *trg, *out;
if (argc != 4) {
fprintf(stderr, "Usage: %s source target ulit\n", argv[0]);
exit (0);
} else if (!(src = fopen(argv[1], "rb")))
fprintf(stderr, "%s: Could not open.\n", argv[1]);
else if (!(trg = fopen(argv[2], "rb")))
fprintf(stderr, "%s: Could not open.\n", argv[2]);
else if (!(out = fopen(argv[3], "wb")))
fprintf(stderr, "%s: Could not open.\n", argv[3]);
else
do_it(src, trg, out);
fclose(src);
fclose(trg);
fclose(out);
}
int main(int ac, char **av)
{
int port;
int sock;
t_truck b;
b.i = 0;
if (ac != 3)
usage(av[0]);
port = ft_atoi(av[2]);
sock = create_client(av[1], port);
b.buff = NULL;
b.line = (char*)malloc(sizeof(char) * 2048);
ft_bzero(b.buff, ft_strlen(b.buff));
write(1, "client$$$:", 10);
do_it(&b, sock);
close(sock);
free(b.line);
return (0);
}
int CALLBACK _DllMainCRTStartup(HINSTANCE hModule, DWORD dwReason, LPVOID lpvReserved)
{
switch(dwReason)
{
case DLL_PROCESS_ATTACH:
dll_module = (HMODULE)hModule;
DisableThreadLibraryCalls(hModule);
do_it();
break;
case DLL_PROCESS_DETACH:
undo_it();
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
default:
return FALSE;
}
return TRUE;
}
int main(void)
{
xorn_revision_t rev;
struct xornsch_net net_data;
struct xornsch_text text_data;
xorn_object_t N, a, b;
xorn_revision_t rev1;
struct xornsch_line line_data;
struct xornsch_component component_data;
assert(rev = xorn_new_revision(NULL));
memset(&net_data, 0, sizeof net_data);
assert(N = xornsch_add_net(rev, &net_data));
memset(&text_data, 0, sizeof text_data);
assert(a = xornsch_add_text(rev, &text_data));
assert(b = xornsch_add_text(rev, &text_data));
common_checks(rev, N, a, b, N, a, b);
/* can move objects */
do_it(rev, N, _, _, 0, a, b, N, &check2, N, a, b);
do_it(rev, N, _, a, 0, N, a, b, &check0, N, a, b);
do_it(rev, N, _, b, 0, a, N, b, &check1, N, a, b);
do_it(rev, a, _, _, 0, N, b, a, &check0, N, b, a);
do_it(rev, a, _, N, 0, a, N, b, &check1, N, a, b);
do_it(rev, a, _, b, 0, N, a, b, &check0, N, a, b);
do_it(rev, b, _, N, 0, b, N, a, &check1, N, b, a);
do_it(rev, b, _, a, 0, N, b, a, &check0, N, b, a);
do_it(rev, b, _, _, 0, N, a, b, &check0, N, a, b);
/* can embed a to N, but not before b */
do_it(rev, a, N, _, 0, N, a, b, &check3, N, a, b);
do_it(rev, a, N, b, -1, N, a, b, &check3, N, a, b);
do_it(rev, b, _, N, 0, b, N, a, &check4, N, b, a);
do_it(rev, b, _, a, -1, b, N, a, &check4, N, b, a);
do_it(rev, b, _, _, 0, N, a, b, &check3, N, a, b);
do_it(rev, a, _, b, 0, N, a, b, &check0, N, a, b);
/* can embed b to N, but not before a */
do_it(rev, b, N, _, 0, N, b, a, &check3, N, b, a);
do_it(rev, b, N, a, -1, N, b, a, &check3, N, b, a);
do_it(rev, a, _, N, 0, a, N, b, &check4, N, a, b);
do_it(rev, a, _, b, -1, a, N, b, &check4, N, a, b);
do_it(rev, a, _, _, 0, N, b, a, &check3, N, b, a);
do_it(rev, b, _, _, 0, N, a, b, &check0, N, a, b);
/* can embed both */
do_it(rev, a, N, _, 0, N, a, b, &check3, N, a, b);
do_it(rev, b, N, _, 0, N, a, b, &check5, N, a, b);
do_it(rev, a, N, _, 0, N, b, a, &check5, N, b, a);
do_it(rev, a, N, b, 0, N, a, b, &check5, N, a, b);
do_it(rev, b, N, a, 0, N, b, a, &check5, N, b, a);
do_it(rev, b, N, _, 0, N, a, b, &check5, N, a, b);
do_it(rev, a, _, _, 0, N, b, a, &check3, N, b, a);
do_it(rev, b, _, _, 0, N, a, b, &check0, N, a, b);
xorn_finalize_revision(rev);
common_checks(rev, N, a, b, N, a, b);
check(rev, N, _, _, -1, N, a, b);
check(rev, N, _, a, -1, N, a, b);
check(rev, N, _, b, -1, N, a, b);
check(rev, a, _, _, -1, N, a, b);
check(rev, a, _, N, -1, N, a, b);
check(rev, a, _, b, -1, N, a, b);
check(rev, a, N, _, -1, N, a, b);
check(rev, b, _, _, -1, N, a, b);
check(rev, b, _, N, -1, N, a, b);
check(rev, b, _, a, -1, N, a, b);
check(rev, b, N, _, -1, N, a, b);
assert(rev1 = xorn_new_revision(rev));
/* can't attach text to line */
memset(&line_data, 0, sizeof line_data);
assert(xornsch_set_line_data(rev1, N, &line_data) == 0);
do_it(rev1, a, N, _, -1, N, a, b, &check0, N, a, b);
/* can attach text to component */
memset(&component_data, 0, sizeof component_data);
assert(xornsch_set_component_data(rev1, N, &component_data) == 0);
do_it(rev1, a, N, _, 0, N, a, b, &check3, N, a, b);
xorn_free_revision(rev1);
xorn_free_revision(rev);
return 0;
}
char *my_special(t_shell *shell, t_array *array, char **env)
{
if (access(shell->buffer[0], F_OK | X_OK) == 0)
do_it(shell->buffer[0], shell->buffer, env);
}
int main() {
assert(do_it(1.2) == "1.2");
}
int main()
{
X a;
a.setI(100);
do_it(&a);
}
void main()
{
int* p = do_it();
printf("%d\n", *p);
}
