extern "C" void
badReceiver(void *arg)
{
    epicsMessageQueue *q = (epicsMessageQueue *)arg;
    char cbuf[80];
    int len;

    cbuf[0] = '\0';
    len = q->receive(cbuf, 1);
    if (len < 0 && cbuf[0] == '\0')
        testPass("receive into undersized buffer returned error (%d)", len);
    else if (len == 1 && cbuf[0] == *msg1)
        testPass("receive into undersized buffer truncated message");
    else
        testFail("receive into undersized buffer returned %d", len);

    epicsThreadSleep(3.0);

    cbuf[0] = '\0';
    len = q->receive(cbuf, 1);
    if (len < 0 && cbuf[0] == '\0')
        testPass("receive into undersized buffer returned error (%d)", len);
    else if (len == 1 && cbuf[0] == *msg1)
        testPass("receive into undersized buffer truncated message");
    else
        testFail("receive into undersized buffer returned %d", len);
}
Esempio n. 2
0
bool            xpathplugin_xbn_and::testUnit()
{
	return	testPass("true() and true()"	, 1, xbnode::xbn_temp, "true")
		&	testPass("true() and false()"	, 1, xbnode::xbn_temp, "false")
		&	testPass("false() and true()"	, 1, xbnode::xbn_temp, "false")
		&	testPass("false() and false()"	, 1, xbnode::xbn_temp, "false");
}
Esempio n. 3
0
bool            xpathplugin_xbn_or::testUnit()
{
	return	testPass("true() or true()"		, 1, xbnode::xbn_temp, "true")
		|	testPass("true() or false()"	, 1, xbnode::xbn_temp, "true")
		|	testPass("false() or true()"	, 1, xbnode::xbn_temp, "true")
		|	testPass("false() or false()"	, 1, xbnode::xbn_temp, "false");
}
Esempio n. 4
0
bool            xpathplugin_round::testUnit()
{
	return testPass( "round(1)", 1, xbnode::xbn_temp, "1" )
			&testPass( "round(1.5)", 1, xbnode::xbn_temp, "2" )
			&testPass( "round(1.4)", 1, xbnode::xbn_temp, "1" )
			&testPass( "round(-1.5)", 1, xbnode::xbn_temp, "-2" )
			&testPass( "round(-1.4)", 1, xbnode::xbn_temp, "-1" );
}
Esempio n. 5
0
/* Action function for state "get" in state set "read_named" */
static void seqg_action_read_named_0_get(SS_ID seqg_env, int seqg_trn, int *seqg_pnst)
{
	switch(seqg_trn)
	{
	case 0:
		{
# line 37 "../pvGet.st"
			seq_efSet(seqg_env, ef_read_named);
		}
		return;
	case 1:
		{
# line 40 "../pvGet.st"
			epicsMutexMustLock(mutex);
# line 41 "../pvGet.st"
			seqg_var->seqg_vars_read_named.expected = shared;
# line 42 "../pvGet.st"
			seq_pvGetTmo(seqg_env, 1/*named*/, ASYNC, DEFAULT_TIMEOUT);
# line 43 "../pvGet.st"
			epicsMutexUnlock(mutex);
# line 44 "../pvGet.st"
			if (seq_pvGetComplete(seqg_env, 1/*named*/))
			{
# line 46 "../pvGet.st"
				testOk(seqg_var->seqg_vars_read_named.expected == seqg_var->seqg_vars_read_named.named, "immediate completion:      expected=%d==%d=named", seqg_var->seqg_vars_read_named.expected, seqg_var->seqg_vars_read_named.named);
			}
			else
			{
# line 48 "../pvGet.st"
				testPass("no immediate completion");
			}
# line 50 "../pvGet.st"
			epicsThreadSleep(0.1);
# line 51 "../pvGet.st"
			if (seq_pvGetComplete(seqg_env, 1/*named*/))
			{
# line 53 "../pvGet.st"
				testOk(seqg_var->seqg_vars_read_named.expected == seqg_var->seqg_vars_read_named.named, "completion after delay:    expected=%d==%d=named", seqg_var->seqg_vars_read_named.expected, seqg_var->seqg_vars_read_named.named);
			}
			else
			{
# line 55 "../pvGet.st"
				testPass("no completion after delay");
			}
		}
		return;
	}
}
Esempio n. 6
0
/* Action function for state "get" in state set "read_anon" */
static void seqg_action_read_anon_1_get(SS_ID seqg_env, int seqg_trn, int *seqg_pnst)
{
	switch(seqg_trn)
	{
	case 0:
		{
# line 77 "../pvGet.st"
			seq_efSet(seqg_env, ef_read_anon);
		}
		return;
	case 1:
		{
# line 80 "../pvGet.st"
			epicsMutexMustLock(mutex);
# line 81 "../pvGet.st"
			seqg_var->seqg_vars_read_anon.expected = shared;
# line 82 "../pvGet.st"
			seq_pvGetTmo(seqg_env, 0/*anon*/, ASYNC, DEFAULT_TIMEOUT);
# line 83 "../pvGet.st"
			epicsMutexUnlock(mutex);
# line 84 "../pvGet.st"
			if (seq_pvGetComplete(seqg_env, 0/*anon*/))
			{
# line 86 "../pvGet.st"
				testOk(seqg_var->seqg_vars_read_anon.expected == seqg_var->anon, "immediate completion:      expected=%d==%d=anon", seqg_var->seqg_vars_read_anon.expected, seqg_var->anon);
			}
			else
			{
# line 88 "../pvGet.st"
				testPass("no immediate completion");
			}
# line 90 "../pvGet.st"
			epicsThreadSleep(0.1);
# line 91 "../pvGet.st"
			if (seq_pvGetComplete(seqg_env, 0/*anon*/))
			{
# line 93 "../pvGet.st"
				testOk(seqg_var->seqg_vars_read_anon.expected == seqg_var->anon, "completion after delay:    expected=%d==%d=anon", seqg_var->seqg_vars_read_anon.expected, seqg_var->anon);
			}
			else
			{
# line 95 "../pvGet.st"
				testPass("no completion after delay");
			}
		}
		return;
	}
}
Esempio n. 7
0
/* Entry function for state "check_msg" in state set "check" */
static void seqg_entry_check_1_check_msg(SS_ID seqg_env)
{
# line 103 "../opttVar.st"
	seqg_var->seqg_vars_check.xp = seqg_var->seqg_vars_check.expected;
# line 104 "../opttVar.st"
	testPass("start 1st round...");
}
Esempio n. 8
0
/**
 * Test for ethernet loopback (ethloop) driver packet acceptance.
 */
thread test_ethloop(bool verbose)
{
#if NETHLOOP
    /* the failif macro depends on 'passed' and 'verbose' vars */
    bool passed = TRUE;
    int i;

    for (i = 0; i < NETHLOOP; i++)
    {
        passed &= ethloopn_test(verbose, i + ELOOP);
    }

    /* always print out the overall tests status */
    if (passed)
    {
        testPass(TRUE, "");
    }
    else
    {
        testFail(TRUE, "");
    }

#else /* NETHLOOP */
    testSkip(TRUE, "");
#endif /* !NETHLOOP */
    return OK;
}
Esempio n. 9
0
/* Action function for state "check_msg" in state set "check" */
static void seqg_action_check_1_check_msg(SS_ID seqg_env, int seqg_trn, int *seqg_pnst)
{
	switch(seqg_trn)
	{
	case 0:
		{
# line 107 "../opttVar.st"
			seqg_var->seqg_vars_check.xp = seqg_var->seqg_vars_check.expected;
# line 108 "../opttVar.st"
			testPass("one more time...");
# line 109 "../opttVar.st"
			seqg_var->seqg_vars_check.repeat = 0;
		}
		return;
	case 1:
		{
		}
		return;
	case 2:
		{
# line 114 "../opttVar.st"
			testOk(strcmp(*seqg_var->seqg_vars_check.xp, seqg_var->msg) == 0, "msg=%s", seqg_var->msg);
# line 115 "../opttVar.st"
			seqg_var->seqg_vars_check.xp++;
		}
		return;
	}
}
Esempio n. 10
0
void catchWrongTypeTestsInitialPass(ParamVal *param, const char* fcnName, ParamValWrongType *e ){
	  testPass("Should not be able to %s on %s\n   %s",
			  fcnName, param->getTypeName(), e->what());
	  testOk(!param->isDefined(), "%s value should be undefined after initial %s",
			  param->getName(), fcnName);
	  testOk(!param->hasValueChanged(), "%s value should report value "
			  "not changed after initial %s", param->getName(), fcnName);
}
Esempio n. 11
0
void assertTest(void *given, void *expected, char info[])
{
	if (given == expected)
	{
		testPass(info);
	}
	else
	{
		testFail(info, given, expected);
		
	}
}
Esempio n. 12
0
/* Action function for state "done" in state set "reassign" */
static void A_reassign_0_done(SS_ID ssId, struct UserVar *pVar, int transNum, int *pNextState)
{
    switch(transNum)
    {
    case 0:
    {
# line 90 "../reassign.st"
        testPass("ok");
    }
    return;
    }
}
Esempio n. 13
0
static
void toolate(void *arg, epicsJobMode mode)
{
    epicsJob *job=arg;
    if(mode==epicsJobModeCleanup){
        epicsJobDestroy(job);
        return;
    }
    testPass("Job runs");
    numtoolate++;
    epicsEventSignal(cancel[0]);
    epicsEventMustWait(cancel[1]);
}
Esempio n. 14
0
/* Action function for state "get_async" in state set "pvGetAsync" */
static void A_pvGetAsync_0_get_async(SS_ID ssId, struct UserVar *pVar, int transNum, int *pNextState)
{
	switch(transNum)
	{
	case 0:
		{
# line 30 "../pvGetAsync.st"
			testPass("pvGet completed %d times", 100000);
		}
		return;
	case 1:
		{
		}
		return;
	}
}
Esempio n. 15
0
/* Action function for state "check_not_set" in state set "myss" */
static void seqg_action_myss_0_check_not_set(SS_ID seqg_env, int seqg_trn, int *seqg_pnst)
{
	switch(seqg_trn)
	{
	case 0:
		{
# line 29 "../userfuncEf.st"
			testFail("argh, no timeout!");
		}
		return;
	case 1:
		{
# line 32 "../userfuncEf.st"
			testPass("cool, we came here");
		}
		return;
	}
}
Esempio n. 16
0
/*------------------------------------------------------------------------
 *  main  --  user main program
 *------------------------------------------------------------------------
 */
int test_bigargs(int argc, char **argv)
{
	uchar testArray[20];
	printf("Test Suite: More than four arguments");
	
	ready(create((void *)bigargs, INITSTK, 31, "BIGARGS", 
				 7, 10, 20, 30, 40, 50, 60, testArray), RESCHED_YES);
	
	if ((10 == testArray[0])
		&& (20 == testArray[1])
		&& (30 == testArray[2])
		&& (40 == testArray[3])
		&& (50 == testArray[4])
		&& (60 == testArray[5])
		&& (210 == testArray[6]))
	{ testPass(""); }
	else
	{ testFail(""); }

	return OK;
}
Esempio n. 17
0
/* Action function for state "makeRequest" in state set "monitorEvflagTest" */
static void A_monitorEvflagTest_0_makeRequest(SS_ID ssId, struct UserVar *pVar, int transNum, int *pNextState)
{
	switch(transNum)
	{
	case 0:
		{
		}
		return;
	case 1:
		{
# line 38 "../monitorEvflag.st"
			testPass("no error in %d cycles", (20 * 500));
		}
		return;
	case 2:
		{
# line 41 "../monitorEvflag.st"
			pVar->requested = pVar->UserVar_monitorEvflagTest.cycleCount;
# line 42 "../monitorEvflag.st"
			seq_pvPut(ssId, 0/*requested*/, 0);
		}
		return;
	}
}
Esempio n. 18
0
/* Action function for state "makeRequest" in state set "monitorEvflagTest" */
static void seqg_action_monitorEvflagTest_0_makeRequest(SS_ID seqg_env, int seqg_trn, int *seqg_pnst)
{
	switch(seqg_trn)
	{
	case 0:
		{
		}
		return;
	case 1:
		{
# line 38 "../monitorEvflag.st"
			testPass("no error in %d cycles", (20 * 500));
		}
		return;
	case 2:
		{
# line 41 "../monitorEvflag.st"
			seqg_var->requested = seqg_var->seqg_vars_monitorEvflagTest.cycleCount;
# line 42 "../monitorEvflag.st"
			seq_pvPutTmo(seqg_env, 0/*requested*/, DEFAULT, DEFAULT_TIMEOUT);
		}
		return;
	}
}
Esempio n. 19
0
/**
 * Tests the stdlib.h header in the Xinu Standard Library.
 * @return OK when testing is complete
 */
thread test_libStdlib(bool verbose)
{
    int i;
    char list[10] = "BCADFEHGI";
    bool passed = TRUE;

    /* atoi */
    testPrint(verbose, "ASCII to integer");
    failif((-456 != atoi("-456"))
           || (123 != atoi("+123"))
           || (2147483647 != atoi("2147483647"))
           || (-1 != atoi("-1one"))
           || (2 != atoi("+2two"))
           || (3 != atoi("3three"))
           || (0 != atoi("-on1e"))
           || (0 != atoi("+tw2o")) || (0 != atoi("thre3e")), "");

    /* atol */
    testPrint(verbose, "ASCII to long");
    failif((-456 != atol("-456"))
           || (123 != atol("+123"))
           || (2147483647 != atol("2147483647"))
           || (-1 != atol("-1one"))
           || (2 != atol("+2two"))
           || (3 != atol("3three"))
           || (0 != atol("-one"))
           || (0 != atol("+two")) || (0 != atol("three")), "");

    /* qsort */
    testPrint(verbose, "Quick sort");
    qsort(list, sizeof(list) - 1, 1, (void *)qsort_callback);
    failif((0 != strncmp(list, "ABCDEFGHI", sizeof(list))), "");

    /* bzero */
    testPrint(verbose, "bzero");
    bzero(list, sizeof(list));
    for (i = 0; i < sizeof(list); i++)
    {
        if ('\0' != *(list + i))
        {
            testFail(verbose, "");
            passed = FALSE;
            break;
        }
    }
    if (i == sizeof(list))
    {
        testPass(verbose, "");
    }

    /* abs */
    testPrint(verbose, "Absolute value");
    failif((2147483647 != abs(-2147483647))
           || (123 != abs(123)) || (0 != abs(0)), "");

    /* labs */
    testPrint(verbose, "Long absolute value");
    failif((2147483647 != labs(-2147483647))
           || (123 != labs(123)) || (0 != labs(0)), "");

    /* rand */
    testPrint(verbose, "Random number generation");
    failif((rand() == rand())
           && (rand() == rand())
           && (rand() == rand())
           && (rand() == rand()), "that was unlikely");

    /* malloc (in test_umemory.c) */

    if (passed)
    {
        testPass(TRUE, "");
    }
    else
    {
        testFail(TRUE, "");
    }

    return OK;
}
Esempio n. 20
0
/**
 * Tests UDP
 * @return OK when testing is complete
 */
thread test_udp(bool verbose)
{
#ifdef UDP1
    struct udp *udpptr = NULL;
    ushort pta;
    ushort ptb;
    struct netaddr ipc;
    struct netaddr ipd;
    struct netaddr ipl;
    struct netaddr src;
    struct netaddr dst;
    struct netaddr mask;
    struct netaddr ipzero;
    struct packet *pkt[10];
    struct udpPkt *udppkt;
    struct udpPseudoHdr *pseudo;
    uchar buffera[12];
    uchar bufferb[12];
    uchar bufferc[12];
    uchar bufferd[12];
    uchar bufferp[40];
    bool passed = TRUE;

    /*   struct pcap_pkthdr phdr;
       struct netif *netptr;
       int nproc;
       int i;
       int wait;
       struct packet *pktA;
       uchar buf[100];
       uchar *data;
       uchar *buffer;
     */
    pta = 20000;
    ptb = 30000;

    /* IP address "C" */
    ipc.type = NETADDR_IPv4;
    ipc.len = IPv4_ADDR_LEN;
    ipc.addr[0] = 192;
    ipc.addr[1] = 168;
    ipc.addr[2] = 1;
    ipc.addr[3] = 5;

    /* IP address "D" */
    ipd.type = NETADDR_IPv4;
    ipd.len = IPv4_ADDR_LEN;
    ipd.addr[0] = 192;
    ipd.addr[1] = 168;
    ipd.addr[2] = 1;
    ipd.addr[3] = 7;

    /* "Local" IP address */
    ipl.type = NETADDR_IPv4;
    ipl.len = IPv4_ADDR_LEN;
    ipl.addr[0] = 192;
    ipl.addr[1] = 168;
    ipl.addr[2] = 1;
    ipl.addr[3] = 8;

    /* Source IP address */
    src.type = NETADDR_IPv4;
    src.len = IPv4_ADDR_LEN;
    src.addr[0] = 192;
    src.addr[1] = 168;
    src.addr[2] = 1;
    src.addr[3] = 6;

    /* Destination IP address */
    dst.type = NETADDR_IPv4;
    dst.len = IPv4_ADDR_LEN;
    dst.addr[0] = 192;
    dst.addr[1] = 168;
    dst.addr[2] = 1;
    dst.addr[3] = 1;

    /* Mask */
    mask.type = NETADDR_IPv4;
    mask.len = IPv4_ADDR_LEN;
    mask.addr[0] = 255;
    mask.addr[1] = 255;
    mask.addr[2] = 255;
    mask.addr[3] = 0;

    /* Empty address */
    ipzero.type = 0;
    ipzero.len = 0;
    ipzero.addr[0] = 0;
    ipzero.addr[1] = 0;
    ipzero.addr[2] = 0;
    ipzero.addr[3] = 0;
    ipzero.addr[4] = 0;
    ipzero.addr[5] = 0;

    /* Test udpPkt structure */
    //testPrint(verbose, "Header structure");
    /* TODO: Figure out how this should be done */

    /* Test udpOpen */
    testPrint(verbose, "Open UDP devices (NULL local port)");
    if (SYSERR == open(UDP0, &ipl, &ipd, NULL, ptb))
    {
        failif(TRUE, "");
    }

    if (SYSERR == open(UDP1, &ipl, &ipc, NULL, pta))
    {
        failif(TRUE, "");
    }
    failif((udptab[0].localpt == udptab[1].localpt)
           || (udptab[0].localpt < UDP_PSTART)
           || (udptab[0].localpt > UDP_PMAX)
           || (udptab[1].localpt < UDP_PSTART)
           || (udptab[1].localpt > UDP_PMAX), "");
    if (SYSERR == close(UDP0))
    {
        failif(TRUE, "");
    }
    if (SYSERR == close(UDP1))
    {
        failif(TRUE, "");
    }

    /* Test udpOpen */
    testPrint(verbose, "Open UDP device (NULL remote port)");
    if (SYSERR == open(UDP0, &ipl, &ipd, pta, NULL))
    {
        failif(TRUE, "");
    }
    failif(udptab[0].remotept != NULL, "");
    if (SYSERR == close(UDP0))
    {
        failif(TRUE, "");
    }

    /* Test udpOpen */
    testPrint(verbose, "Open UDP device (NULL remote ip)");
    if (SYSERR == open(UDP0, &ipl, NULL, pta, ptb))
    {
        failif(TRUE, "");
    }
    failif(0 == netaddrequal(&udptab[0].remoteip, &ipzero), "");
    if (SYSERR == close(UDP0))
    {
        failif(TRUE, "");
    }


    /* Test udpOpen */
    testPrint(verbose, "Open UDP devices (same local port)");
    if (SYSERR == open(UDP0, &ipl, &ipd, pta, ptb))
    {
        failif(TRUE, "");
    }

    if (SYSERR == open(UDP1, &ipl, &ipd, pta, pta))
    {
        failif(TRUE, "");
    }
    failif(udptab[0].localpt != udptab[1].localpt, "");

    /* Only close the second UDP device this time, we want to test close
     * using UDP0 */
    if (SYSERR == close(UDP1))
    {
        failif(TRUE, "");
    }

    /* Test udpClose */
    testPrint(verbose, "Close UDP device");
    if (SYSERR == close(UDP0))
    {
        failif(TRUE, "");
    }
    failif((udptab[0].dev != 0) || (udptab[0].icount != 0)
           || (udptab[0].istart != 0) || (udptab[0].isem != 0)
           || (udptab[0].localpt != 0) || (udptab[0].remotept != 0)
           || (FALSE == netaddrequal(&udptab[0].localip, &ipzero))
           || (FALSE == netaddrequal(&udptab[0].remoteip, &ipzero))
           || (udptab[0].state != 0) || (udptab[0].flags != 0), "");

    /* Test udpControl */
    testPrint(verbose, "UDP Control: Binding");
    /* Open UDP device to resume testing of that device */
    if (SYSERR == open(UDP0, &ipl, NULL, NULL, NULL))
    {
        failif(TRUE, "");
    }
    control(UDP0, UDP_CTRL_ACCEPT, pta, (long)&ipl);
    control(UDP0, UDP_CTRL_BIND, ptb, (long)&ipc);
    failif((udptab[0].localpt != pta)
           || (FALSE == netaddrequal(&udptab[0].localip, &ipl))
           || (udptab[0].remotept != ptb)
           || (FALSE == netaddrequal(&udptab[0].remoteip, &ipc)), "");

    /* Test udpControl */
    testPrint(verbose, "UDP Control: Flags");
    control(UDP0, UDP_CTRL_SETFLAG, UDP_FLAG_PASSIVE | UDP_FLAG_NOBLOCK
            | UDP_FLAG_BINDFIRST, NULL);
    control(UDP0, UDP_CTRL_CLRFLAG, UDP_FLAG_NOBLOCK, NULL);
    /* At this point NOBLOCK should be the only flag that is off */
    failif((FALSE == (udptab[0].flags & UDP_FLAG_PASSIVE))
           || (udptab[0].flags & UDP_FLAG_NOBLOCK)
           || (FALSE == (udptab[0].flags & UDP_FLAG_BINDFIRST)), "");

    /* Test udpDemux */
    testPrint(verbose, "UDP Demux (2 sockets)");
    open(UDP1, &ipl, NULL, pta, NULL);
    udpptr = udpDemux(pta, ptb, &ipl, &ipc);
    failif((udpptr == &udptab[1]) || (NULL == udpptr), "");

    /* Test udpRecv and udpRead */
    testPrint(verbose, "Receive and read UDP packets");

    control(UDP0, UDP_CTRL_CLRFLAG, UDP_FLAG_PASSIVE
            | UDP_FLAG_BINDFIRST, NULL);

    control(UDP0, UDP_CTRL_ACCEPT, pta, (long)&ipl);
    control(UDP0, UDP_CTRL_BIND, ptb, (long)&ipc);

    pkt[0] = makePkt(ptb, pta, &ipl, &ipc, 5, "ABCDE");
    pkt[1] = makePkt(ptb, pta, &ipl, &ipc, 4, "FGHI");
    pkt[2] = makePkt(ptb, pta, &ipl, &ipc, 3, "JKL");
    pkt[3] = makePkt(ptb, pta, &ipl, &ipc, 2, "MN");
    if (SYSERR == udpRecv(pkt[0], &ipc, &ipl))
    {
        failif(TRUE, "recva");
    }
    if (SYSERR == udpRecv(pkt[1], &ipc, &ipl))
    {
        failif(TRUE, "recvb");
    }
    if (SYSERR == udpRecv(pkt[2], &ipc, &ipl))
    {
        failif(TRUE, "recvc");
    }
    if (SYSERR == udpRecv(pkt[3], &ipc, &ipl))
    {
        failif(TRUE, "recvd");
    }
    if (SYSERR == read(UDP0, buffera, 5))
    {
        failif(TRUE, "reada");
    }
    if (SYSERR == read(UDP0, bufferb, 5))
    {
        failif(TRUE, "readb");
    }
    if (SYSERR == read(UDP0, bufferc, 5))
    {
        failif(TRUE, "readc");
    }
    if (SYSERR == read(UDP0, bufferd, 5))
    {
        failif(TRUE, "readd");
    }
    failif((0 != strncmp((char *)buffera, "ABCDE", 5))
           || (0 != strncmp((char *)bufferb, "FGHI", 4))
           || (0 != strncmp((char *)bufferc, "JKL", 3))
           || (0 != strncmp((char *)bufferd, "MN", 2)), "");

    /* Test udpRecv and udpRead */
    testPrint(verbose, "Two UDP sockets");
    pkt[0] = makePkt(pta, pta, &ipc, &ipl, 9, "ABCDEFGHI");
    udpRecv(pkt[0], &ipc, &ipl);
    read(UDP1, bufferc, 9);
    failif(0 != strncmp((char *)bufferc, "ABCDEFGHI", 9), "");

    /* Test udpRecv and udpRead */
    testPrint(verbose, "Receive and read UDP packets (again)");

    control(UDP0, UDP_CTRL_CLRFLAG, UDP_FLAG_PASSIVE
            | UDP_FLAG_BINDFIRST, NULL);

    control(UDP0, UDP_CTRL_ACCEPT, pta, (long)&ipl);
    control(UDP0, UDP_CTRL_BIND, ptb, (long)&ipc);

    pkt[0] = makePkt(ptb, pta, &ipl, &ipc, 5, "OPQRS");
    pkt[1] = makePkt(ptb, pta, &ipl, &ipc, 3, "TUV");
    pkt[2] = makePkt(ptb, pta, &ipl, &ipc, 2, "WX");
    pkt[3] = makePkt(ptb, pta, &ipl, &ipc, 2, "YZ");
    udpRecv(pkt[0], &ipc, &ipl);
    udpRecv(pkt[1], &ipc, &ipl);
    udpRecv(pkt[2], &ipc, &ipl);
    udpRecv(pkt[3], &ipc, &ipl);
    if (SYSERR == read(UDP0, buffera, 5))
    {
        failif(TRUE, "reada");
    }
    if (SYSERR == read(UDP0, bufferb, 3))
    {
        failif(TRUE, "readb");
    }
    if (SYSERR == read(UDP0, bufferc, 2))
    {
        failif(TRUE, "readc");
    }
    if (SYSERR == read(UDP0, bufferd, 2))
    {
        failif(TRUE, "readd");
    }
    failif(0 != strncmp((char *)buffera, "OPQRS", 5)
           || (0 != strncmp((char *)bufferb, "TUV", 3))
           || (0 != strncmp((char *)bufferc, "WX", 2))
           || (0 != strncmp((char *)bufferd, "YZ", 2)), "");

    /* Test udpRecv and udpRead on multiple sockets */
    testPrint(verbose, "Recv/read with varying sockets (1)");

    /* Test 1 */
    control(UDP0, UDP_CTRL_ACCEPT, pta, (long)&ipl);
    control(UDP0, UDP_CTRL_BIND, NULL, NULL);
    pkt[0] = makePkt(ptb, pta, &ipc, &ipl, 5, "test1");
    udpRecv(pkt[0], &ipc, &ipl);
    read(UDP0, buffera, 5);
    failif(strncmp((char *)buffera, "test1", 5), "");

    /* Test 2 */
    testPrint(verbose, "Recv/read socket test 2");
    control(UDP0, UDP_CTRL_ACCEPT, pta, (long)&ipl);
    control(UDP0, UDP_CTRL_BIND, ptb, NULL);

    control(UDP1, UDP_CTRL_ACCEPT, pta, (long)&ipl);
    control(UDP1, UDP_CTRL_BIND, 0, NULL);

    pkt[0] = makePkt(ptb, pta, &ipc, &ipl, 6, "test2a");
    pkt[1] = makePkt(pta, pta, &ipc, &ipl, 6, "test2b");
    udpRecv(pkt[0], &ipc, &ipl);
    udpRecv(pkt[1], &ipc, &ipl);
    read(UDP0, buffera, 6);
    read(UDP1, bufferb, 6);

    failif(0 != strncmp((char *)buffera, "test2a", 6)
           || (0 != strncmp((char *)bufferb, "test2b", 6)), "");

    /* Test 3 */
    testPrint(verbose, "Recv/read socket test 3");
    control(UDP0, UDP_CTRL_BIND, ptb, (long)&ipc);
    control(UDP1, UDP_CTRL_BIND, ptb, NULL);

    pkt[0] = makePkt(ptb, pta, &ipc, &ipl, 6, "test3a");
    pkt[1] = makePkt(ptb, pta, &ipd, &ipl, 6, "test3b");
    udpRecv(pkt[0], &ipc, &ipl);
    udpRecv(pkt[1], &ipd, &ipl);
    read(UDP0, buffera, 6);
    read(UDP1, bufferb, 6);

    failif((0 != strncmp((char *)buffera, "test3a", 6))
           || (0 != strncmp((char *)bufferb, "test3b", 6)), "");

    /* Test 4 */
    testPrint(verbose, "Recv/read socket test 4");
    control(UDP0, UDP_CTRL_BIND, ptb, (long)&ipc);
    control(UDP1, UDP_CTRL_BIND, ptb, (long)&ipd);

    pkt[0] = makePkt(ptb, pta, &ipc, &ipl, 6, "test4a");
    pkt[1] = makePkt(ptb, pta, &ipd, &ipl, 6, "test4b");
    udpRecv(pkt[0], &ipc, &ipl);
    udpRecv(pkt[1], &ipd, &ipl);
    read(UDP0, buffera, 6);
    read(UDP1, bufferb, 6);

    failif((0 != strncmp((char *)buffera, "test4a", 6))
           || (0 != strncmp((char *)bufferb, "test4b", 6)), "");

    /* Test 5 */
    testPrint(verbose, "Recv/read socket test 5");
    control(UDP0, UDP_CTRL_BIND, 0, NULL);
    control(UDP1, UDP_CTRL_ACCEPT, ptb, (long)&ipl);
    control(UDP1, UDP_CTRL_BIND, 0, NULL);

    pkt[0] = makePkt(ptb, pta, &ipc, &ipl, 6, "test5a");
    pkt[1] = makePkt(pta, ptb, &ipc, &ipl, 6, "test5b");
    udpRecv(pkt[0], &ipc, &ipl);
    udpRecv(pkt[1], &ipc, &ipl);
    read(UDP0, buffera, 6);
    read(UDP1, bufferb, 6);

    failif((0 != strncmp((char *)buffera, "test5a", 6))
           || (0 != strncmp((char *)bufferb, "test5b", 6)), "");

    /* Read entire UDP packet */
    testPrint(verbose, "Read entire UDP packet");
    control(UDP0, UDP_CTRL_SETFLAG, UDP_FLAG_PASSIVE, NULL);
    pkt[0] = makePkt(ptb, pta, &ipc, &ipl, 7, "passive");
    udpRecv(pkt[0], &ipc, &ipl);
    read(UDP0, bufferp, UDP_HDR_LEN + 7 + sizeof(struct udpPseudoHdr));
    pseudo = (struct udpPseudoHdr *)bufferp;
    udppkt = (struct udpPkt *)(pseudo + 1);
    failif((0 != memcmp(pseudo->srcIp, ipc.addr, IPv4_ADDR_LEN))
           || (0 != memcmp(pseudo->dstIp, ipl.addr, IPv4_ADDR_LEN))
           || (udppkt->srcPort != ptb) || (udppkt->dstPort != pta)
           || (udppkt->len != UDP_HDR_LEN + 7)
           || (0 != strncmp((char *)udppkt->data, "passive", 7)), "");

    /* Done testing, attempt to close all UDP devices (MAKE SURE BOTH
     * DEVICES ARE OPEN BEFORE YOU CLOSE THEM!!!) */
    close(UDP0);
    close(UDP1);

    /* Print out the overall test's status (pass or fail) */
    if (passed)
    {
        testPass(TRUE, "");
    }
    else
    {
        testFail(TRUE, "");
    }
#else /* UDP1 */
    testSkip(TRUE, "");
#endif /* !UDP1 */
    return OK;
}
Esempio n. 21
0
thread test_semaphore3(bool verbose)
{
#if NSEM
    tid_typ atid, btid;
    bool passed = TRUE;
    semaphore s;
    uchar testResult = 0;
    char msg[50];

    testPrint(verbose, "Semaphore creation: ");
    s = semcreate(1);
    if (isbadsem(s))
    {
        passed = FALSE;
        sprintf(msg, "%d", s);
        testFail(verbose, msg);
    }
    else if (test_checkSemCount(s, 1))
    {
        testPass(verbose, "");
    }
    else
    {
        passed = FALSE;
    }

    /* We use a higher priority for thread A to ensure it is not rescheduled to
     * thread B before it is even able to wait on the semaphore.  */
    ready(atid =
          create((void *)test_semWaiter, INITSTK, 32,
                 "SEMAPHORE-A", 3, s, 1, &testResult), RESCHED_NO);
    ready(btid =
          create((void *)test_semWaiter, INITSTK, 31,
                 "SEMAPHORE-B", 3, s, 1, &testResult), RESCHED_YES);

    testPrint(verbose, "Wait on semaphore: ");
    /* Process A should be admitted, but B should wait. */
    if (test_checkProcState(atid, THRFREE)
        && test_checkProcState(btid, THRWAIT)
        && test_checkSemCount(s, -1) && test_checkResult(testResult, 1))
    {
        testPass(verbose, "");
    }
    else
    {
        passed = FALSE;
    }

    signal(s);

    /* Process B waited, so signal should release it. */
    testPrint(verbose, "Signal waiting semaphore: ");
    if (test_checkProcState(btid, THRFREE)
        && test_checkSemCount(s, 0) && test_checkResult(testResult, 2))
    {
        testPass(verbose, "");
    }
    else
    {
        passed = FALSE;
    }

    if (TRUE == passed)
    {
        testPass(TRUE, "");
    }
    else
    {
        testFail(TRUE, "");
    }

    /* Processes should be dead, but in case the test failed. */
    kill(atid);
    kill(btid);
    semfree(s);

#else /* NSEM */
    testSkip(TRUE, "");
#endif /* NSEM == 0 */
    return OK;
}
int test_policychecker(int argc, char *argv[])
{

        PKIX_Boolean initialPolicyMappingInhibit = PKIX_FALSE;
        PKIX_Boolean initialAnyPolicyInhibit = PKIX_FALSE;
        PKIX_Boolean initialExplicitPolicy = PKIX_FALSE;
        PKIX_Boolean expectedResult = PKIX_FALSE;
        PKIX_UInt32 chainLength = 0;
        PKIX_UInt32 initArgs = 0;
        PKIX_UInt32 firstCert = 0;
        PKIX_UInt32 i = 0;
        PKIX_Int32  j = 0;
        PKIX_UInt32 actualMinorVersion;
        PKIX_ProcessingParams *procParams = NULL;
        char *firstTrustAnchor = "yassir2yassir";
        char *secondTrustAnchor = "yassir2bcn";
        char *dateAscii = "991201000000Z";
        PKIX_ValidateParams *valParams = NULL;
        PKIX_ValidateResult *valResult = NULL;
        PKIX_List *userInitialPolicySet = NULL; /* List of PKIX_PL_OID */
        char *certNames[PKIX_TEST_MAX_CERTS];
        PKIX_PL_Cert *certs[PKIX_TEST_MAX_CERTS];
        PKIX_List *chain = NULL;
        PKIX_Error *validationError = NULL;
	PKIX_VerifyNode *verifyTree = NULL;
	PKIX_PL_String *verifyString = NULL;
        char *dirName = NULL;
        char *dataCentralDir = NULL;
        char *anchorName = NULL;

        PKIX_TEST_STD_VARS();

        PKIX_TEST_EXPECT_NO_ERROR(
            PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext));

        /*
         * Perform hard-coded tests if no command line args.
         * If command line args are provided, they must be:
         * arg[1]: test name
         * arg[2]: "ENE" or "EE", for "expect no error" or "expect error"
         * arg[3]: directory for certificates
         * arg[4]: user-initial-policy-set, consisting of braces
         *      containing zero or more OID sequences, separated by commas
         * arg[5]: (optional) "E", indicating initialExplicitPolicy
         * arg[firstCert]: the path and filename of the trust anchor certificate
         * arg[firstCert+1..(n-1)]: successive certificates in the chain
         * arg[n]: the end entity certificate
         *
         * Example: test_policychecker test1EE ENE
         *      {2.5.29.32.0,2.5.29.32.3.6} Anchor CA EndEntity
         */

        dirName = argv[3+j];
        dataCentralDir = argv[4+j];

        if (argc <= 5 || ((6 == argc) && (j))) {

                testPass
                    (dataCentralDir,
                    firstTrustAnchor,
                    secondTrustAnchor,
                    dateAscii);

                testNistTest1(dirName);

                testNistTest2(dirName);

                goto cleanup;
        }

        if (argc < (7 + j)) {
                printUsage(argv[0]);
                pkixTestErrorMsg = "Invalid command line arguments.";
                goto cleanup;
        }

        if (PORT_Strcmp(argv[2+j], "ENE") == 0) {
                expectedResult = PKIX_TRUE;
        } else if (PORT_Strcmp(argv[2+j], "EE") == 0) {
                expectedResult = PKIX_FALSE;
        } else {
                printUsage(argv[0]);
                pkixTestErrorMsg = "Invalid command line arguments.";
                goto cleanup;
        }

        userInitialPolicySet = policySetParse(argv[5+j]);
        if (!userInitialPolicySet) {
                printUsage(argv[0]);
                pkixTestErrorMsg = "Invalid command line arguments.";
                goto cleanup;
        }

        for (initArgs = 0; initArgs < 3; initArgs++) {
                if (PORT_Strcmp(argv[6+j+initArgs], "A") == 0) {
                        initialAnyPolicyInhibit = PKIX_TRUE;
                } else if (PORT_Strcmp(argv[6+j+initArgs], "E") == 0) {
                        initialExplicitPolicy = PKIX_TRUE;
                } else if (PORT_Strcmp(argv[6+j+initArgs], "P") == 0) {
                        initialPolicyMappingInhibit = PKIX_TRUE;
                } else {
                        break;
                }
        }

        firstCert = initArgs + j + 6;
        chainLength = argc - (firstCert + 1);
        if (chainLength > PKIX_TEST_MAX_CERTS) {
                printUsageMax(chainLength);
                pkixTestErrorMsg = "Invalid command line arguments.";
                goto cleanup;
        }

        /*
         * Create a chain, but don't include the first certName.
         * That's the anchor, and is supplied separately from
         * the chain.
         */
        for (i = 0; i < chainLength; i++) {

                certNames[i] = argv[i + (firstCert + 1)];
                certs[i] = NULL;
        }
        chain = createCertChainPlus
                (dirName, certNames, certs, chainLength, plContext);

        subTest(argv[1+j]);

        valParams = createValidateParams
                (dirName,
                argv[firstCert],
                NULL,
                NULL,
                userInitialPolicySet,
                initialPolicyMappingInhibit,
                initialAnyPolicyInhibit,
                initialExplicitPolicy,
                PKIX_FALSE,
                chain,
                plContext);

        if (expectedResult == PKIX_TRUE) {
                subTest("   (expecting successful validation)");

                PKIX_TEST_EXPECT_NO_ERROR(PKIX_ValidateChain
                        (valParams, &valResult, &verifyTree, plContext));

                printValidPolicyTree(valResult);

        } else {
                subTest("   (expecting validation to fail)");
                validationError = PKIX_ValidateChain
                        (valParams, &valResult, &verifyTree, plContext);
                if (!validationError) {
                        printValidPolicyTree(valResult);
                        pkixTestErrorMsg = "Should have thrown an error here.";
                }
                PKIX_TEST_DECREF_BC(validationError);
        }

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString
                ((PKIX_PL_Object*)verifyTree, &verifyString, plContext));
        (void) printf("verifyTree is\n%s\n", verifyString->escAsciiString);

cleanup:

        PKIX_PL_Free(anchorName, plContext);

        PKIX_TEST_DECREF_AC(verifyString);
        PKIX_TEST_DECREF_AC(verifyTree);
        PKIX_TEST_DECREF_AC(userInitialPolicySet);
        PKIX_TEST_DECREF_AC(chain);
        PKIX_TEST_DECREF_AC(valParams);
        PKIX_TEST_DECREF_AC(valResult);
        PKIX_TEST_DECREF_AC(validationError);

        PKIX_Shutdown(plContext);

        PKIX_TEST_RETURN();

        endTests("PolicyChecker");

        return (0);
}
Esempio n. 23
0
thread test_ip(bool verbose)
{
#if NETHER
    struct netaddr dst;
    struct netaddr src;
    struct netaddr mask;
    struct netif *netptr;
    struct pcap_file_header pcap;
    struct pcap_pkthdr phdr;
    struct packet *pktA;
    struct packet *pktB;
    uchar *data;
    uchar buf[500];
    int i;
    int nproc;
    int wait;
    bool passed = TRUE;

    src.type = NETADDR_IPv4;
    src.len = IPv4_ADDR_LEN;
    dst.type = NETADDR_IPv4;
    dst.len = IPv4_ADDR_LEN;
    mask.type = NETADDR_IPv4;
    mask.len = IPv4_ADDR_LEN;

    src.addr[0] = 192;
    src.addr[1] = 168;
    src.addr[2] = 1;
    src.addr[3] = 6;

    dst.addr[0] = 192;
    dst.addr[1] = 168;
    dst.addr[2] = 1;
    dst.addr[3] = 1;

    mask.addr[0] = 255;
    mask.addr[1] = 255;
    mask.addr[2] = 255;
    mask.addr[3] = 0;

    testPrint(verbose, "Initialization");
    sleep(500);
    if (SYSERR == open(ELOOP))
    {
        failif(TRUE, "Open returned SYSERR");
    }
    else
    {
        if (SYSERR == netUp(ELOOP, &src, &mask, &dst))
        {
            failif(TRUE, "netUp returned SYSERR");
        }
        else
        {
            netptr = NULL;
            for (i = 0; i < NNETIF; i++)
            {
                if (ELOOP == netiftab[i].dev)
                {
                    netptr = &netiftab[i];
                    break;
                }
            }
            pktA = netGetbuf();
            pktB = netGetbuf();
            failif(((NULL == netptr)
                    || (SYSERR == (int)pktA)
                    || (SYSERR == (int)pktB)),
                   "Buffer allocation failed");
        }
    }
    if (!passed)
    {
        testFail(TRUE, "");
        return OK;
    }

    data = (uchar *)(&_binary_data_testip_pcap_start);
    memcpy(&pcap, data, sizeof(pcap));
    data += sizeof(pcap);

    testPrint(verbose, "Ipv4Send");
    /* Get 1st Packet */
    memcpy(&phdr, data, sizeof(phdr));
    data += sizeof(phdr);
    if (PCAP_MAGIC != pcap.magic)
    {
        phdr.caplen = endswap(phdr.caplen);
    }
    nproc = netptr->nproc;
    write(ELOOP, data, phdr.caplen);
    wait = 0;
    while ((wait < MAX_WAIT) && (netptr->nproc == nproc))
    {
        wait++;
        sleep(10);
    }
    if (MAX_WAIT == wait)
    {
        failif(TRUE, "Wait time expired");
    }
    else
    {
        /* Get 2nd Packet */
        data += phdr.caplen;
        memcpy(&phdr, data, sizeof(phdr));
        data += sizeof(phdr);
        if (PCAP_MAGIC != pcap.magic)
        {
            phdr.caplen = endswap(phdr.caplen);
        }
        memcpy(pktA->data, data, phdr.caplen);
        pktA->len = phdr.caplen;
        pktA->nif = netptr;
        pktA->linkhdr = pktA->data;
        pktA->nethdr = pktA->linkhdr + ETH_HDR_LEN;
        pktA->curr = pktA->nethdr + IPv4_HDR_LEN;

        pktB->curr -= UDP_HDR_LEN + 4;
        pktB->len += UDP_HDR_LEN + 4;
        memcpy(pktB->curr, pktA->curr, pktB->len);

        control(ELOOP, ELOOP_CTRL_SETFLAG, ELOOP_FLAG_HOLDNXT, NULL);

        if (OK != ipv4Send(pktB, &src, &dst, IPv4_PROTO_UDP))
        {
            failif(TRUE, "ipv4Send didn't return okay");
        }
        else
        {
            control(ELOOP, ELOOP_CTRL_GETHOLD, (long)buf, 500);
            failif(0 != memcmp(buf, pktA->linkhdr, pktA->len), "");
        }
    }

    /* ipv4Recv Testing */
    //TODO: Finish ipv4Recv
/*	testPrint(verbose, "ipv4Recv");
	pktA->curr -= IPv4_HDR_LEN;

	if (SYSERR == rawOpen(RAW0, IPv4_PROTO_UDP, ))
    {
        failif(TRUE, "Open returned SYSERR");
    }

	

	if (OK != ipv4Recv(pktA))
	{
		failif(TRUE, "Didn't return okay");
	}
	else
	{
	}
*/
    netDown(ELOOP);
    close(ELOOP);

    /* always print out the overall tests status */
    if (passed)
    {
        testPass(TRUE, "");
    }
    else
    {
        testFail(TRUE, "");
    }
#else /* NETHER */
    testSkip(TRUE, "");
#endif /* NETHER == 0 */
    return OK;
}
Esempio n. 24
0
/**
 * Tests the string.h header in the Xinu Standard Library.
 * @return OK when testing is complete
 */
thread test_libString(bool verbose)
{
    char *s1 = NULL;
    char *s2 = NULL;
    char str[LEN_STR] = "ZYXWYZ";

    bool passed = TRUE;

    /* strncmp */
    testPrint(verbose, "String n comparison");
    failif(((0 > strncmp("ZYX", "WVU", 2))
            || (0 < strncmp("wvu", "zyx", 2))
            || (0 < strncmp("wvu", "zyx", 50))
            || (0 > strncmp("zyx", "wvu", 50))
            || (0 != strncmp("abc", "abc", 50))
            || (0 != strncmp("987", "987", 2))
            || (0 < strncmp("NOP", "NOQ", 3))
            || (0 > strncmp("noq", "nop", 3))
            || (0 != strncmp("450", "456", 2))), "");

    /* strncpy */
    testPrint(verbose, "String n copy");
    char sB[6] = "abcde";

    s1 = strncpy(sB, "fghij", 3);
    failif(((0 != strncmp(sB, "fghde", 5)) || (s1 != sB)), "");

    /* strncat */
    testPrint(verbose, "String n concantenate");
    char sD[6] = "zyx";

    s1 = strncat(sD, "wv", 1);
    failif(((0 != strncmp(sD, "zyxw", 4))
            || (0 != strncmp(s1, "zyxw", 4))), "");

    /* * * strchr * * */
    /* fail to find char */
    testPrint(verbose, "Fail to find; strchr()");
    s1 = strchr(str, 'a');
    failif(NULL != s1, "");

    /* find a uniq char */
    testPrint(verbose, "Find unique char; strchr()");
    s1 = strchr(str, 'X');
    failif('W' != *(s1 + 1), "");

    /* find a non-uniq char */
    testPrint(verbose, "Find non-unique char; strchr()");
    s1 = strchr(str, 'Y');
    failif('X' != *(s1 + 1), "");

    /* find null char */
    testPrint(verbose, "Find null char; strchr()");
    s1 = strchr(str, '\0');
    failif(str + (LEN_STR - 1) != s1 || '\0' != *s1, "");

    /* * * strrchr * * */
    /* fail to find char */
    testPrint(verbose, "Fail to find; strrchr()");
    s1 = strrchr(str, 'a');
    failif(NULL != s1, "");

    /* find a uniq char */
    testPrint(verbose, "Find unique char; strrchr()");
    s1 = strrchr(str, 'X');
    failif('W' != *(s1 + 1), "");

    /* find a non-uniq char */
    testPrint(verbose, "Find non-unique char; strrchr()");
    s1 = strrchr(str, 'Y');
    failif('Z' != *(s1 + 1), "");

    /* find null char */
    testPrint(verbose, "Find null char; strrchr()");
    s1 = strrchr(str, '\0');
    failif(str + (LEN_STR - 1) != s1 || '\0' != *s1, "");

    /* strstr */
    testPrint(verbose, "String search");
    char sG[9] = "ABBCDEBA";

    s1 = strstr(sG, "BCD");
    s1 += 3;
    failif(('E' != *s1), "");

    /* strnlen */
    testPrint(verbose, "String n length");
    failif(((5 != strnlen("12345", 100))
            || (0 != strnlen("", 5))
            || (3 != strnlen("12345", 3))
            || (0 != strnlen("12345", 0))), "");

    /* memcmp */
    testPrint(verbose, "Memory comparsion");
    failif(((0 < memcmp("ABC", "DEF", 3))
            || (0 > memcmp("def", "abc", 3))
            || (0 != memcmp("123", "123", 3))), "");

    /* memcpy */
    testPrint(verbose, "Memory copy");
    char sH[6] = "ABCDE";

    s1 = memcpy(sH, "FGHIJ", 5);
    failif(((0 != memcmp(sH, "FGHIJ", 5))
            || (0 != memcmp(s1, "FGHIJ", 5))), "");

    /* memchr */
    testPrint(verbose, "Memory character search");
    char sI[7] = "abcdba";

    s1 = memchr(sI, 'b', 6) + 1;
    s2 = memchr(sI, 'c', 6) + 1;
    failif((('c' != *s1) || ('d' != *s2)), "");

    /* memset */
    testPrint(verbose, "Memory set");
    char sJ[6] = "ABCDE";

    s1 = memset(sJ, 'F', 3);
    failif(((0 != memcmp(sJ, "FFFDE", 5)) || (s1 != sJ)), "");

    if (passed)
    {
        testPass(TRUE, "");
    }
    else
    {
        testFail(TRUE, "");
    }

    return OK;
}
Esempio n. 25
0
thread test_netaddr(bool verbose)
{
#if NETHER
    bool passed = TRUE;
    struct netaddr a;
    struct netaddr b;

    /* Setup structures */
    a.type = NETADDR_ETHERNET;
    a.len = ETH_ADDR_LEN;
    a.addr[0] = 0xAA;
    a.addr[1] = 0xBB;
    a.addr[2] = 0xCC;
    a.addr[3] = 0xDD;
    a.addr[4] = 0xEE;
    a.addr[5] = 0xFF;

    b.type = NETADDR_ETHERNET;
    b.len = ETH_ADDR_LEN;
    b.addr[0] = 0xAA;
    b.addr[1] = 0xBB;
    b.addr[2] = 0xCC;
    b.addr[3] = 0xDD;
    b.addr[4] = 0xEE;
    b.addr[5] = 0xFF;

    testPrint(verbose, "Comparison (diff lengths)");
    b.len = ETH_ADDR_LEN - 1;
    failif((TRUE == netaddrequal(&a, &b)), "");

    testPrint(verbose, "Comparison (diff types)");
    b.len = ETH_ADDR_LEN;
    a.type = NETADDR_IPv4;
    failif((TRUE == netaddrequal(&a, &b)), "");

    testPrint(verbose, "Comparison (equal MACs)");
    a.type = NETADDR_ETHERNET;
    failif((FALSE == netaddrequal(&a, &b)), "");

    testPrint(verbose, "Comparison (diff MACs)");
    b.addr[5] = 0x00;
    failif((TRUE == netaddrequal(&a, &b)), "");

    /* Setup structures */
    a.type = NETADDR_IPv4;
    a.len = IPv4_ADDR_LEN;
    a.addr[0] = 192;
    a.addr[1] = 168;
    a.addr[2] = 1;
    a.addr[3] = 1;

    b.type = NETADDR_IPv4;
    b.len = IPv4_ADDR_LEN;
    b.addr[0] = 192;
    b.addr[1] = 168;
    b.addr[2] = 1;
    b.addr[3] = 1;

    testPrint(verbose, "Comparison (equal IPs)");
    failif((FALSE == netaddrequal(&a, &b)), "");

    testPrint(verbose, "Comparison (diff IPs)");
    a.addr[3] = 2;
    failif((TRUE == netaddrequal(&a, &b)), "");

    /* always print out the overall tests status */
    if (passed)
    {
        testPass(TRUE, "");
    }
    else
    {
        testFail(TRUE, "");
    }

#else /* NETHER */
    testSkip(TRUE, "");
#endif /* NETHER == 0 */
    return OK;
}
Esempio n. 26
0
void taskNotify(void *usr)
{
    testPass("taskNotify");
}
Esempio n. 27
0
void anyNotify(void *usr, epicsThreadId tid)
{
    testPass("anyNotify(tid=%p)", (void *)tid);
}
Esempio n. 28
0
void monRemove(void *usr, epicsThreadId tid)
{
    testPass("monRemove(tid=%p)", (void *)tid);
}
Esempio n. 29
0
void monNotify(void *usr, epicsThreadId tid, int suspended)
{
    testPass("monNotify(tid=%p, suspended=%d)", (void *)tid, suspended);
    epicsThreadResume(tid);
}
Esempio n. 30
0
void monInsert(void *usr, epicsThreadId tid)
{
    testPass("monInsert(tid=%p)", (void *)tid);
}