Example #1
0
static int seq4_test(IC_Env *env)
{
    char *stra0[3] = {"a", "long", "time"}; 
    char *stra1[3] = {"ago", "there", "was"}; 
    char *stra2[3] = {"a", "buggy", "compiler"}; 
    m_sstr3 str3s[3] = {{3, 3, stra0}, {3, 3, stra1}, {3, 3, stra2}};
    m_ssstr3 str3ssi = {3, 3, str3s}; 
    m_ssstr3 *str3sso, *str3ssr;

    fprintf(stdout, "\n======== m_i_seq4 test ======\n\n");
    str3ssr = m_i_seq4_test(NULL, &str3ssi, &str3sso, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_ssstr3(&str3ssi, str3sso) && 
		 cmp_ssstr3(&str3ssi, str3ssr));
    if (!cmp_ssstr3(&str3ssi, str3sso)){
	fprintf(stdout, " out parameter error, sent:\n");
	print_ssstr3(&str3ssi);
	fprintf(stdout, " got:\n");
	print_ssstr3(str3sso);
	fprintf(stdout, "\n");
    }
    if (!cmp_ssstr3(&str3ssi, str3ssr)) {
	fprintf(stdout, " result error, sent:\n");
	print_ssstr3(&str3ssi);
	fprintf(stdout, " got:\n");
	print_ssstr3(str3ssr);
	fprintf(stdout, "\n");
    }
    CORBA_free(str3sso);
    CORBA_free(str3ssr);
    return -1;
}
Example #2
0
static int array1_test(IC_Env *env)
{
    int i;
    long al[500];
    m_arr1 alo;
    m_arr1_slice* alr;
    
    for (i = 0; i < 500; i++)
	al[i]=i;

    fprintf(stdout, "\n======== m_i_array1 test ======\n\n");
    alr = m_i_array1_test(NULL, al, alo, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_arr1(al, alo) && cmp_arr1(al, alr));
    if (!cmp_arr1(al, alo)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_arr1(al);
	fprintf(stdout, " got:\n");
	print_arr1(alo);
	fprintf(stdout, "\n");
    }
    if (!cmp_arr1(al,alr)) {
	fprintf(stdout, " result error, sent:\n");
	print_arr1(al);
	fprintf(stdout, " got:\n");
	print_arr1(alr);
	fprintf(stdout, "\n");
    }
    free(alo);
    free(alr);
    return -1;
}   
Example #3
0
static int void_test(IC_Env *env)
{
    fprintf(stdout, "\n======== m_i_void test ======\n\n");
    m_i_void_test(NULL,env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(1);
}
Example #4
0
static int seq1_test(IC_Env *env)
{
    m_bseq bs, *bso, *bsr;

    m_b ba[3] = {{4711, 'a'}, {4712, 'b'}, {4713, 'c'}};
    bs._length = 3;
    bs._buffer = ba;

    fprintf(stdout, "\n======== m_i_seq1 test ======\n\n");
    bsr = m_i_seq1_test(NULL, &bs, &bso, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_bseq(&bs, bso) && cmp_bseq(&bs, bsr));
    if (!cmp_bseq(&bs, bso)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_bseq(&bs);
	fprintf(stdout, " got:\n");
	print_bseq(bso);
	fprintf(stdout, "\n");
    }
    if (!cmp_bseq(&bs, bsr)) {
	fprintf(stdout, " result error, sent:\n");
	print_bseq(&bs);
	fprintf(stdout, " got:\n");
	print_bseq(bsr);
	fprintf(stdout, "\n");
    }
    CORBA_free(bso);
    CORBA_free(bsr);
    return -1;
}
Example #5
0
static int term_sequence_test(IC_Env *env)
{
    ETERM* et_array[4] = {
	erl_format("[{apa, 1, 23}, \"string\", {1.23, 45}]"),
	erl_format("[{banan, 1, 23}, \"string\", {1.23, 45}]"),
	erl_format("[{apelsin, 1, 23}, \"string\", {1.23, 45}]"),
	erl_format("[{mango, 1, 23}, \"string\", {1.23, 45}]")};
    m_etseq etsi = {4, 4, et_array}, *etso, *etsr;

    fprintf(stdout, "\n======== m_i_term_sequence test ======\n\n");
    etsr = m_i_term_sequence_test(NULL, &etsi, &etso, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_etseq(&etsi, etso) && cmp_etseq(&etsi, etsr));
    if (!cmp_etseq(&etsi, etso)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_etseq(&etsi);
	fprintf(stdout, "got:\n");
	print_etseq(etso);
    }
    if (!cmp_etseq(&etsi, etsr)) {
	fprintf(stdout, " result error, sent:\n");
	print_etseq(&etsi);
	fprintf(stdout, "got:\n");
	print_etseq(etsr);
    }
    free_etseq_buf(&etsi);
    free_etseq_buf(etso);
    free_etseq_buf(etsr);
    CORBA_free(etso);
    CORBA_free(etsr);
    return -1;
}
Example #6
0
static int term_struct_test(IC_Env *env)
{
    m_et eti = { erl_format("[{hej, 1, 23}, \"string\", {1.23, 45}]"), 
		 121212 };
    m_et eto, etr;

    fprintf(stdout, "\n======== m_i_term_struct test ======\n\n");
    etr = m_i_term_struct_test(NULL, &eti, &eto, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_et(&eti, &eto) && cmp_et(&eti, &etr));
    if (!cmp_et(&eti, &eto)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_et(&eti);
	fprintf(stdout, "got:\n");
	print_et(&eto);
    }
    if (!cmp_et(&eti, &etr)) {
	fprintf(stdout, " result error, sent:\n");
	print_et(&eti);
	fprintf(stdout, "got:\n");
	print_et(&etr);
    }
    free_et(&eti);
    free_et(&eto);
    free_et(&etr);
    return -1;
}
Example #7
0
static int typedef_test(IC_Env *env)
{
    m_banan mbi, mbo;		/* erlang_port */
    m_apa mai;			/* ETERM* */
    m_apa mao = NULL;
    long tl;

    strcpy(mbi.node,"node");
    mbi.id = 15;
    mbi.creation = 1;

    fprintf(stdout, "\n======== m_i_typedef test ======\n\n");
    mai = erl_format("[{hej, 1, 23}, \"string\", {1.23, 45}]");
    tl = m_i_typedef_test(NULL, mai, &mbi, &mao, &mbo, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(erl_match(mai, mao) && cmp_port(&mbi, &mbo) && tl == 4711);
    if (!erl_match(mai, mao)) {
	fprintf(stdout, " out parameter error (term), sent:\n");
	print_term(mai);
	fprintf(stdout, "got:\n");
	print_term(mao);
    }
    if (!cmp_port(&mbi, &mbo)) {
	fprintf(stdout, " out parameter error (port), sent:\n");
	print_port(&mbi);
	fprintf(stdout, "got:\n");
	print_port(&mbo);
    }
    if (tl != 4711) {
	fprintf(stdout, " result error, sent: 4711, got %ld\n", tl);
    }
    erl_free_term(mai);
    erl_free_term(mao);
    return -1;
} 
Example #8
0
static int inline_sequence_test(IC_Env *env)
{
    int i;
    long al[500];
    m_s isi = {4711, {500, 10, al}},  
	*iso, *isr;

    for (i = 0; i < 500; i++)
	al[i]=i;
    fprintf(stdout, "\n======== m_i_inline_sequence test ======\n\n");
    isr = m_i_inline_sequence_test(NULL, &isi, &iso, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_s(&isi, iso) && cmp_s(&isi, isr));
    if (!cmp_s(&isi, iso)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_s(&isi);
	fprintf(stdout, "got:\n");
	print_s(iso);
    }
    if (!cmp_s(&isi, isr)) {
	fprintf(stdout, " result error, sent:\n");
	print_s(&isi);
	fprintf(stdout, "got:\n");
	print_s(isr);
    }
    CORBA_free(iso);
    CORBA_free(isr);
    return -1;
}
Example #9
0
static int term_test(IC_Env *env)
{
    ETERM *ti, *to, *tr;

    ti = erl_format("[{hej, 1, 23}, \"string\", {1.23, 45}]");

    fprintf(stdout, "\n======== m_i_term test ======\n\n");
    tr = m_i_term_test(NULL, ti, &to, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(erl_match(ti, to) && erl_match(ti, tr));
    if (!erl_match(ti, to)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_term(ti);
	fprintf(stdout, "got:\n");
	print_term(to);
    }
    if (!erl_match(ti, tr)) {
	fprintf(stdout, " result error, sent:\n");
	print_term(ti);
	fprintf(stdout, "got:\n");
	print_term(tr);
    }
    erl_free_term(ti);
    erl_free_term(to);
    erl_free_term(tr);
    return -1;
}
Example #10
0
static int seq5_test(IC_Env *env)
{
    m_arr3 arr3a[3] = {
	{4711, 18931947, 3}, 
	{4711, 18931947, 3},
	{4711, 18931947, 3}};
    m_sarr3 arr3sa[3] = {{3, 3, arr3a}, {3, 3, arr3a}, {3, 3, arr3a}};
    m_ssarr3 arr3ssi = {3, 3, arr3sa};
    m_ssarr3 *arr3sso;
    m_ssarr3 *arr3ssr;

    fprintf(stdout, "\n======== m_i_seq5 test ======\n\n");
    arr3ssr = m_i_seq5_test(NULL, &arr3ssi, &arr3sso, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_ssarr3(&arr3ssi, arr3sso) &&
		 cmp_ssarr3(&arr3ssi, arr3ssr));
    if (!cmp_ssarr3(&arr3ssi, arr3sso)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_ssarr3(&arr3ssi);
	fprintf(stdout, " got:\n");
	print_ssarr3(arr3sso);
	fprintf(stdout, "\n");
    }
    if (!cmp_ssarr3(&arr3ssi, arr3ssr)) {
	fprintf(stdout, " result error, sent:\n");
	print_ssarr3(&arr3ssi);
	fprintf(stdout, " got:\n");
	print_ssarr3(arr3ssr);
	fprintf(stdout, "\n");
    }
    CORBA_free(arr3sso);
    CORBA_free(arr3ssr);
    return -1;
}
Example #11
0
static int string2_test(IC_Env *env)
{
    char* sa[3] = {"hello", "foo", "bar"};
    m_sseq ssi = {3, 3, sa};
    m_sseq *sso, *ssr;

    fprintf(stdout, "\n======== m_i_string2 test ======\n\n");
    ssr = m_i_string2_test(NULL, &ssi, &sso, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_sseq(&ssi, sso) && cmp_sseq(&ssi, sso));
    if (!cmp_sseq(&ssi, sso)) {
	fprintf(stdout, " out parameter error, sent:\n"); 
	print_sseq(&ssi); 
	fprintf(stdout, "got:\n");
	print_sseq(sso); 
    } 
    if (!cmp_sseq(&ssi, ssr)) {
	fprintf(stdout, " result error, sent:\n"); 
	print_sseq(&ssi); 
	fprintf(stdout, "got:\n"); 
	print_sseq(ssr); 
    }    
    CORBA_free(sso);
    CORBA_free(ssr);
    return -1;
}
Example #12
0
static int array2_test(IC_Env *env)
{
    long dl[2][3] = {{11, 2, 7}, {22, 8 ,13}};
    m_dd dlo;
    m_dd_slice* dlr;

    fprintf(stdout, "\n======== m_i_array2 test ======\n\n");
    dlr = m_i_array2_test(NULL, dl, dlo, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_dd(dl,dlo) && cmp_dd(dl,dlr));
    if (!cmp_dd(dl,dlo)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_dd(dl);
	fprintf(stdout, " got:\n");
	print_dd(dlo);
	fprintf(stdout, "\n");
    }
    if (!cmp_dd(dl,dlr)) {
	fprintf(stdout, " result error, sent:\n");
	print_dd(dl);
	fprintf(stdout, " got:\n");
	print_dd(dlr);
	fprintf(stdout, "\n");
    }
    free(*dlr);
    return -1;
}
Example #13
0
static int seq3_test(IC_Env *env)
{
    m_lseq lsi, *lso, *lsr;
    long al[500];
    int i=0;
    
    for (i = 0; i < 500; i++)
	al[i]=i;
    lsi._length = 500;
    lsi._buffer = al;

    fprintf(stdout, "\n======== m_i_seq3 test ======\n\n");
    lsr = m_i_seq3_test(NULL, &lsi, &lso, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_lseq(&lsi, lso) && cmp_lseq(&lsi, lsr));
    if (!cmp_lseq(&lsi, lso)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_lseq(&lsi);
	fprintf(stdout, " got:\n");
	print_lseq(lso);
	fprintf(stdout, "\n");
    }
    if (!cmp_lseq(&lsi, lsr)) {
	fprintf(stdout, " result error, sent:\n");
	print_lseq(&lsi);
	fprintf(stdout, " got:\n");
	print_lseq(lsr);
	fprintf(stdout, "\n");
    }
    CORBA_free(lso);
    CORBA_free(lsr);
    return -1;
}
Example #14
0
static int char_test(IC_Env *env)
{
    char c = 'g', co, cr;

    /* char test */
    fprintf(stdout, "\n======== m_i_char test ======\n\n");
    cr = m_i_char_test(NULL, c, &co, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(c == co && c == cr);
    if 
Example #15
0
static int unsigned_short_test(IC_Env *env)
{
    unsigned short x, y = 2, z;

    fprintf(stdout, "\n======== m_i_ushort test ======\n\n");
    x = m_i_ushort_test(NULL, y, &z, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(y == z && y == x);
    if (y != z) 
	fprintf(stdout, " out parameter error, sent: %d, got: %d\n", y, z);
    if (y != x)
	fprintf(stdout, " result error, sent: %d, got: %d\n", y, x);
    return -1;
}
Example #16
0
static int long_test(IC_Env *env)
{
    long l = 4711, lo, lr;

    fprintf(stdout, "\n======== m_i_long test ======\n\n");
    lr = m_i_long_test(NULL, l, &lo, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(l == lo && l == lr);
    if (l != lo)
	fprintf(stdout, " out parameter error, sent: %ld, got: %ld\n", l, lo);
    if (l != lr)
	fprintf(stdout, " result error, sent: %ld, got: %ld\n", l, lr);
    return -1;
}
Example #17
0
static int enum_test(IC_Env *env)
{
    m_fruit ei = m_banana, eo, er;

    fprintf(stdout, "\n======== m_i_enum test ======\n\n");
    er = m_i_enum_test(NULL, ei, &eo, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(ei == eo && ei == er);
    if (ei != eo)
	fprintf(stdout, " out parameter error, sent: %d, got: %d\n", ei, eo);
    if (ei != er)
	fprintf(stdout, " result error, sent: %d, got: %d\n", ei, er);
    return -1;
}
Example #18
0
static int bool_test(IC_Env *env)
{
    unsigned char i = 0, io, ir;	

    fprintf(stdout, "\n======== m_i_bool test ======\n\n");
    ir = m_i_bool_test(NULL, i, &io, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(i == io && i == ir);
    if (i != io)
	fprintf(stdout, " out parameter error, sent: %d, got: %d\n", i, io);
    if (i != ir)
	fprintf(stdout, " result error, sent: %d, got: %d\n", i, ir);
    return -1;
}
Example #19
0
static int octet_test(IC_Env *env)
{
    char o ='r', oo, or;
 
    fprintf(stdout, "\n======== m_i_octet test ======\n\n");
    or = m_i_octet_test(NULL, o, &oo, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(o == oo && o == or);
    if (o != oo)
	fprintf(stdout, " out parameter error, sent: %c, got: %c\n", o, oo);
    if (o != or)
	fprintf(stdout, " result error, sent: %c, got: %c\n", o, or);
    return -1;
}    
Example #20
0
static int double_test(IC_Env *env)
{
    double d = 12.1212, db, dr;

    fprintf(stdout, "\n======== m_i_double test ======\n\n");
    dr = m_i_double_test(NULL, d, &db, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(d == db && d == dr);
    if (d != db)
	fprintf(stdout, " out parameter error, sent: %f, got: %f\n", d, db);
    if (d != dr)
	fprintf(stdout, " result error, sent: %f, got: %f\n", d, dr);
    return -1;
}    
Example #21
0
static int unsigned_long_test(IC_Env *env)
{
    unsigned long ul = 5050, ulo, ulr;

    fprintf(stdout, "\n======== m_i_ulong test ======\n\n");
    ulr = m_i_ulong_test(NULL, ul, &ulo, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(ul == ulo && ul == ulr);
    if (ul != ulo) 
	fprintf(stdout, " out parameter error, sent: %lu, got: %lu\n", 
		ul, ulo);
    if (ul != ulr)
	fprintf(stdout, " result error, sent: %lu, got: %lu\n", ul, ulr);
    return -1;
}
Example #22
0
static int char_test(IC_Env *env)
{
    char c = 'g', co, cr;

    /* char test */
    fprintf(stdout, "\n======== m_i_char test ======\n\n");
    cr = m_i_char_test(NULL, c, &co, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(c == co && c == cr);
    if (c !=co) 
	fprintf(stdout, " out parameter error, sent: %c, got: %c\n", c, co);
    if (c != cr)
	fprintf(stdout, " result error, sent: %c, got: %c\n", c, cr);
    return -1;
}
Example #23
0
static int wchar_test(IC_Env *env)
{
    CORBA_wchar wc = 103, wco, wcr;

    fprintf(stdout, "\n======== m_i_wchar test ======\n\n");
    wcr = m_i_wchar_test(NULL, wc, &wco, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(wc == wco && wc == wcr);
    if (wc != wco)
	fprintf(stdout, " out parameter error, sent: %lu, got: %lu\n", 
		wc, wco);
    if (wc != wcr)
	fprintf(stdout, " result error, sent: %lu, got: %lu\n", 
		wc, wcr);
    return -1;
}    
Example #24
0
static int string3_test(IC_Env *env)
{
    char* si = longtext;
    char* so;
    char* sr;

    fprintf(stdout, "\n======== m_i_string3 test ======\n\n");
    sr = m_i_string3_test(NULL, si, &so, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_str(si, so) && cmp_str(si, so));
    if (!cmp_str(si, so))
	fprintf(stdout, " out parameter error, sent: %s, got: %s\n", si, so);
    if (!cmp_str(si, sr))
	fprintf(stdout, " result error, sent: %s, got: %s\n", si, sr);
    CORBA_free(so);
    CORBA_free(sr);
    return -1;
}
Example #25
0
static int port_test(IC_Env *env)
{
    erlang_port porti = {"node", 5, 1}, porto, portr;

    fprintf(stdout, "\n======== m_i_port test ======\n\n");
    portr = m_i_port_test(NULL, &porti, &porto, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_port(&porti, &porto) && cmp_port(&porti, &portr));
    if (!cmp_port(&porti, &porto)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_port(&porti);
	fprintf(stdout, "got:\n");
	print_port(&porto);
    }
    if (!cmp_port(&porti, &portr)) {
	fprintf(stdout, " result error, sent:\n");
	print_port(&porti);
	fprintf(stdout, "got:\n");
	print_port(&portr);
    }
    return -1;
}
Example #26
0
static int seq2_test(IC_Env *env)
{
    m_b ba[3] = {{4711, 'a'}, {4712, 'b'}, {4713, 'c'}};
    m_a a;
    m_a aa[2];
    m_aseq as, *aso, *asr;

    a.l = 9999;
    a.y._length = 3;
    a.y._buffer = ba;
    a.d = 66.89898989;

    aa[0] = a;
    aa[1] = a;
    as._length = 2;
    as._buffer = aa;

    fprintf(stdout, "\n======== m_i_seq2 test ======\n\n");
    asr = m_i_seq2_test(NULL, &as, &aso, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_aseq(&as, aso) && cmp_aseq(&as, asr));
    if (!cmp_aseq(&as, aso)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_aseq(&as);
	fprintf(stdout, " got:\n");
	print_aseq(aso);
	fprintf(stdout, "\n");
    }
    if (!cmp_aseq(&as, asr)) {
	fprintf(stdout, " result error, sent:\n");
	print_aseq(&as);
	fprintf(stdout, " got:\n");
	print_aseq(asr);
	fprintf(stdout, "\n");
    }
    CORBA_free(aso);
    CORBA_free(asr);
    return -1;
}
Example #27
0
static int ref_test(IC_Env *env)
{
    erlang_ref refi = { "node1", 3, {1, 2, 3}, 1},  
	refo, refr;

    fprintf(stdout, "\n======== m_i_ref test ======\n\n");
    refr = m_i_ref_test(NULL, &refi, &refo, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_ref(&refi, &refo) && cmp_ref(&refi, &refr));
    if (!cmp_ref(&refi, &refo)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_ref(&refi);
	fprintf(stdout, "got:\n");
	print_ref(&refo);
    }
    if (!cmp_ref(&refi, &refr)) {
	fprintf(stdout, " result error, sent:\n");
	print_ref(&refi);
	fprintf(stdout, "got:\n");
	print_ref(&refr);
    }
    return -1;
}
Example #28
0
static int pid_test(IC_Env *env)
{
    erlang_pid pid = {"", 7, 0, 0}, pido, pidr;

    strcpy(pid.node, this_node), /* this currently running node */
    fprintf(stdout, "\n======== m_i_pid test ======\n\n");
    pidr = m_i_pid_test(NULL, &pid, &pido, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_pid(&pid, &pido) && cmp_pid(&pid, &pidr));
    if (!cmp_pid(&pid, &pido)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_pid(&pid);
	fprintf(stdout, "got:\n");
	print_pid(&pido);
    }
    if (!cmp_pid(&pid, &pidr)) {
	fprintf(stdout, " result error, sent:\n");
	print_pid(&pid);
	fprintf(stdout, "got:\n");
	print_pid(&pidr);
    }
    return -1;
}
Example #29
0
static int string4_test(IC_Env *env)
{
    char as1[100] = "a string", as2[200] = "help", as3[200] = "hello there";
    m_strRec stri = { 1,	/* dd */
		      as1,	/* str4 */
		      {{'a', 'k'}, {'z', 'g'}, {'n', 'q'}}, /* str7 */
		      {3, 3, "buf"}, /* str5 */
		      as2,	/* str6 */
		      {'m', 'f', 'o'}, /* str8 */
		      as3,	/* str9 */
		      {3, 3, "stu"} /* str10 */
    };
    m_strRec *stro, *strr;

    fprintf(stdout, "\n======== m_i_string4 test ======\n\n");
    strr = m_i_string4_test(NULL, &stri, &stro, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_strRec(&stri,stro) && cmp_strRec(&stri,strr));
    if (!cmp_strRec(&stri,stro)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_strRec(&stri);
	fprintf(stdout, " got:\n");
	print_strRec(stro);
	fprintf(stdout, "\n");
    }
    if (!cmp_strRec(&stri,strr)) {
	fprintf(stdout, " result error, sent:\n");
	print_strRec(&stri);
	fprintf(stdout, " got:\n");
	print_strRec(strr);
	fprintf(stdout, "\n");
    }
    CORBA_free(stro);
    CORBA_free(strr);
    return -1;
}
Example #30
0
static int struct2_test(IC_Env *env)
{
    m_es esi = {m_peach, 5050}, eso, esr;

    fprintf(stdout, "\n======== m_i_struct2 test ======\n\n");
    esr = m_i_struct2_test(NULL, &esi, &eso, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_es(&esi, &eso) && cmp_es(&esi, &esr));
    if (!cmp_es(&esi, &eso)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_es(&esi);
	fprintf(stdout, " got:\n");
	print_es(&eso);
	fprintf(stdout, "\n");
    }
    if (!cmp_es(&esi, &esr)) {
	fprintf(stdout, " result error, sent:\n");
	print_es(&esi);
	fprintf(stdout, " got:\n");
	print_es(&esr);
	fprintf(stdout, "\n");
    }
    return -1;
}