Exemple #1
0
/**
 * Test for getOffset() and setOffset()
 */
static void TestOffset()
{
    UErrorCode status= U_ZERO_ERROR;
    UCollator *en_us=NULL;
    UCollationElements *iter, *pristine;
    int32_t offset;
    OrderAndOffset *orders;
    int32_t orderLength=0;
    int     count = 0;
    UChar test1[50];
    UChar test2[50];

    u_uastrcpy(test1, "What subset of all possible test cases?");
    u_uastrcpy(test2, "has the highest probability of detecting");
    en_us = ucol_open("en_US", &status);
    log_verbose("Testing getOffset and setOffset for collations\n");
    iter = ucol_openElements(en_us, test1, u_strlen(test1), &status);
    if(U_FAILURE(status)){
        log_err_status(status, "ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n",
            myErrorName(status));
        ucol_close(en_us);
        return;
    }

    /* testing boundaries */
    ucol_setOffset(iter, 0, &status);
    if (U_FAILURE(status) || ucol_previous(iter, &status) != UCOL_NULLORDER) {
        log_err("Error: After setting offset to 0, we should be at the end "
                "of the backwards iteration");
    }
    ucol_setOffset(iter, u_strlen(test1), &status);
    if (U_FAILURE(status) || ucol_next(iter, &status) != UCOL_NULLORDER) {
        log_err("Error: After setting offset to end of the string, we should "
                "be at the end of the backwards iteration");
    }

    /* Run all the way through the iterator, then get the offset */

    orders = getOrders(iter, &orderLength);

    offset = ucol_getOffset(iter);

    if (offset != u_strlen(test1))
    {
        log_err("offset at end != length %d vs %d\n", offset,
            u_strlen(test1) );
    }

    /* Now set the offset back to the beginning and see if it works */
    pristine=ucol_openElements(en_us, test1, u_strlen(test1), &status);
    if(U_FAILURE(status)){
        log_err("ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n",
            myErrorName(status));
    ucol_close(en_us);
        return;
    }
    status = U_ZERO_ERROR;

    ucol_setOffset(iter, 0, &status);
    if (U_FAILURE(status))
    {
        log_err("setOffset failed. %s\n",    myErrorName(status));
    }
    else
    {
        assertEqual(iter, pristine);
    }

    ucol_closeElements(pristine);
    ucol_closeElements(iter);
    free(orders);

    /* testing offsets in normalization buffer */
    test1[0] = 0x61;
    test1[1] = 0x300;
    test1[2] = 0x316;
    test1[3] = 0x62;
    test1[4] = 0;
    ucol_setAttribute(en_us, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
    iter = ucol_openElements(en_us, test1, 4, &status);
    if(U_FAILURE(status)){
        log_err("ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n",
            myErrorName(status));
        ucol_close(en_us);
        return;
    }

    count = 0;
    while (ucol_next(iter, &status) != UCOL_NULLORDER &&
        U_SUCCESS(status)) {
        switch (count) {
        case 0:
            if (ucol_getOffset(iter) != 1) {
                log_err("ERROR: Offset of iteration should be 1\n");
            }
            break;
        case 3:
            if (ucol_getOffset(iter) != 4) {
                log_err("ERROR: Offset of iteration should be 4\n");
            }
            break;
        default:
            if (ucol_getOffset(iter) != 3) {
                log_err("ERROR: Offset of iteration should be 3\n");
            }
        }
        count ++;
    }

    ucol_reset(iter);
    count = 0;
    while (ucol_previous(iter, &status) != UCOL_NULLORDER &&
        U_SUCCESS(status)) {
        switch (count) {
        case 0:
        case 1:
            if (ucol_getOffset(iter) != 3) {
                log_err("ERROR: Offset of iteration should be 3\n");
            }
            break;
        case 2:
            if (ucol_getOffset(iter) != 1) {
                log_err("ERROR: Offset of iteration should be 1\n");
            }
            break;
        default:
            if (ucol_getOffset(iter) != 0) {
                log_err("ERROR: Offset of iteration should be 0\n");
            }
        }
        count ++;
    }

    if(U_FAILURE(status)){
        log_err("ERROR: in iterating collation elements %s\n",
            myErrorName(status));
    }

    ucol_closeElements(iter);
    ucol_close(en_us);
}
Exemple #2
0
void assertEqual(vec3 x, vec3 y, const char* m){
  assertEqual(x.x, y.x, m);
  assertEqual(x.y, y.y, m);
  assertEqual(x.z, y.z, m);
}
void test3()
{
    int bufferSize = 1000;
    char *buffer = AllocateAligned4( bufferSize );

// single message tests
    // empty message
    {
        std::memset( buffer, 0x74, bufferSize );
        OutboundPacketStream ps( buffer, bufferSize );
        ps << BeginMessage( "/no_arguments" )
            << EndMessage;
        assertEqual( ps.IsReady(), true );
        ReceivedMessage m( ReceivedPacket(ps.Data(), ps.Size()) );
        std::cout << m << "\n";\
    }

    TEST_PACK_UNPACK( "/a_bool", true, bool, AsBool );
    TEST_PACK_UNPACK( "/a_bool", false, bool, AsBool );
    TEST_PACK_UNPACK( "/a_bool", (bool)1, bool, AsBool );


#ifndef _OBJC_OBJC_H_
    TEST_PACK_UNPACK0( "/nil", Nil, true, IsNil );
#endif
    TEST_PACK_UNPACK0( "/nil", OscNil, true, IsNil );
    TEST_PACK_UNPACK0( "/inf", Infinitum, true, IsInfinitum );

    TEST_PACK_UNPACK( "/an_int", (int32)1234, int32, AsInt32 );

    TEST_PACK_UNPACK( "/a_float", 3.1415926f, float, AsFloat );

    TEST_PACK_UNPACK( "/a_char", 'c', char, AsChar );

    TEST_PACK_UNPACK( "/an_rgba_color", RgbaColor(0x22334455), uint32, AsRgbaColor );

    TEST_PACK_UNPACK( "/a_midi_message", MidiMessage(0x7F), uint32, AsMidiMessage );

    TEST_PACK_UNPACK( "/an_int64", (int64)(0xFFFFFFFF), int64, AsInt64 );

    TEST_PACK_UNPACK( "/a_time_tag", TimeTag(0xFFFFFFFF), uint64, AsTimeTag );

    TEST_PACK_UNPACK( "/a_double", (double)3.1415926, double, AsDouble );

    // blob
    {
        char blobData[] = "abcd";
        std::memset( buffer, 0x74, bufferSize );
        OutboundPacketStream ps( buffer, bufferSize );
        ps << BeginMessage( "/a_blob" )
            << Blob( blobData, 4 )
            << EndMessage;
        assertEqual( ps.IsReady(), true );
        ReceivedMessage m( ReceivedPacket(ps.Data(), ps.Size()) );
        std::cout << m << "\n";

        const void *value;
        osc_bundle_element_size_t size;
        m.ArgumentsBegin()->AsBlob( value, size );
        assertEqual( size, (osc_bundle_element_size_t)4 );
        assertEqual( (memcmp( value, blobData, 4 ) == 0), true );
    }

    // array
    {
        int32 arrayData[] = {1,2,3,4};
        const std::size_t sourceArrayItemCount = 4;
        std::memset( buffer, 0x74, bufferSize );
        OutboundPacketStream ps( buffer, bufferSize );
        ps << BeginMessage( "/an_array" )
            << BeginArray;
        for( std::size_t j=0; j < sourceArrayItemCount; ++j )
            ps << arrayData[j];
        ps << EndArray << EndMessage;
        assertEqual( ps.IsReady(), true );
        ReceivedMessage m( ReceivedPacket(ps.Data(), ps.Size()) );
        std::cout << m << "\n";

        ReceivedMessageArgumentIterator i = m.ArgumentsBegin();
        assertEqual( i->IsArrayBegin(), true );
        assertEqual( i->ComputeArrayItemCount(), sourceArrayItemCount );
        std::size_t arrayItemCount = i->ComputeArrayItemCount();
        ++i; // move past array begin marker        
        for( std::size_t j=0; j < arrayItemCount; ++j ){
            assertEqual( true, i->IsInt32() );
            int32 k = i->AsInt32();
            assertEqual( k, arrayData[j] );
            ++i;
        }

        assertEqual( i->IsArrayEnd(), true );
    }



    TEST_PACK_UNPACK( "/a_string", "hello world", const char*, AsString );

    TEST_PACK_UNPACK( "/a_symbol", Symbol("foobar"), const char*, AsSymbol );


    // nested bundles, and multiple messages in bundles...

    {
        std::memset( buffer, 0x74, bufferSize );
        OutboundPacketStream ps( buffer, bufferSize );
        ps << BeginBundle()
            << BeginMessage( "/message_one" ) << 1 << 2 << 3 << 4 << EndMessage
            << BeginMessage( "/message_two" ) << 1 << 2 << 3 << 4 << EndMessage
            << BeginMessage( "/message_three" ) << 1 << 2 << 3 << 4 << EndMessage
            << BeginMessage( "/message_four" ) << 1 << 2 << 3 << 4 << EndMessage
            << EndBundle;
        assertEqual( ps.IsReady(), true );
        ReceivedBundle b( ReceivedPacket(ps.Data(), ps.Size()) );
        std::cout << b << "\n";
    }
}
int main()
{
	{
		Location p1(0,0,0);
		Location p2(10,0,0);
		Location p3(0,0,10);

		Location p(10,0,0);

		interpolate(p1, p2, p3, p);

		assertEqual(p, Location(10,0,0));
	}
	{
		Location p1(0,0,0);
		Location p2(10,0,0);
		Location p3(0,0,10);

		Location p(1,0,1);

		interpolate(p1, p2, p3, p);

		assertEqual(p, Location(1,0,1));
	}
	{
		Location p1(0,2,0);
		Location p2(2,0,0);
		Location p3(0,0,2);

		Location p(1,0,0);

		interpolate(p1, p2, p3, p);

		assertEqual(p, Location(1,1,0));
	}
	{
		Location p1(0,2,0);
		Location p2(2,0,0);
		Location p3(0,0,2);

		Location p(0,0,1);

		interpolate(p1, p2, p3, p);

		assertEqual(p, Location(0,1,1));
	}
	{
		Location p1(0,2,0);
		Location p2(2,0,0);
		Location p3(0,0,2);

		Location p(0,0,1);

		interpolate(p1, p2, p3, p);

		assertEqual(p, Location(0,1,1));
	}
	{
		Location p1(0,2,0);
		Location p2(2,0,0);
		Location p3(0,0,2);

		Location p(FixedPoint(1,2),0,FixedPoint(1,2));

		interpolate(p1, p2, p3, p);

		assertEqual(p, Location(FixedPoint(1,2),1,FixedPoint(1,2)));
	}
}
void test3()
{
    int bufferSize = 1000;
    char *buffer = AllocateAligned4( bufferSize );

// single message tests
    // empty message
    {
        memset( buffer, 0x74, bufferSize );
        OutboundPacketStream ps( buffer, bufferSize );
        ps << BeginMessage( "/no_arguments" )
            << EndMessage;
        assertEqual( ps.IsReady(), true );
        ReceivedMessage m( ReceivedPacket(ps.Data(), ps.Size()) );
        std::cout << m << "\n";\
    }

    TEST_PACK_UNPACK( "/a_bool", true, bool, AsBool );
    TEST_PACK_UNPACK( "/a_bool", false, bool, AsBool );
    TEST_PACK_UNPACK( "/a_bool", (bool)1, bool, AsBool );

    TEST_PACK_UNPACK0( "/nil", Nil, true, IsNil );
    TEST_PACK_UNPACK0( "/inf", Infinitum, true, IsInfinitum );

    TEST_PACK_UNPACK( "/an_int", (int32)1234, int32, AsInt32 );

    TEST_PACK_UNPACK( "/a_float", 3.1415926f, float, AsFloat );

    TEST_PACK_UNPACK( "/a_char", 'c', char, AsChar );

    TEST_PACK_UNPACK( "/an_rgba_color", RgbaColor(0x22334455), uint32, AsRgbaColor );

    TEST_PACK_UNPACK( "/a_midi_message", MidiMessage(0x7F), uint32, AsMidiMessage );

    TEST_PACK_UNPACK( "/an_int64", (int64)(0xFFFFFFFF), int64, AsInt64 );

    TEST_PACK_UNPACK( "/a_time_tag", TimeTag(0xFFFFFFFF), uint64, AsTimeTag );

    TEST_PACK_UNPACK( "/a_double", (double)3.1415926, double, AsDouble );

    // blob
    {
        char blobData[] = "abcd";
        memset( buffer, 0x74, bufferSize );
        OutboundPacketStream ps( buffer, bufferSize );
        ps << BeginMessage( "/a_blob" )
            << Blob( blobData, 4 )
            << EndMessage;
        assertEqual( ps.IsReady(), true );
        ReceivedMessage m( ReceivedPacket(ps.Data(), ps.Size()) );
        std::cout << m << "\n";

        const void *value;
        unsigned long size;
        m.ArgumentsBegin()->AsBlob( value, size );
        assertEqual( size, (unsigned long)4 );
        assertEqual( (memcmp( value, blobData, 4 ) == 0), true );
    }


    TEST_PACK_UNPACK( "/a_string", "hello world", const char*, AsString );

    TEST_PACK_UNPACK( "/a_symbol", Symbol("foobar"), const char*, AsSymbol );


    // nested bundles, and multiple messages in bundles...

    {
        memset( buffer, 0x74, bufferSize );
        OutboundPacketStream ps( buffer, bufferSize );
        ps << BeginBundle()
            << BeginMessage( "/message_one" ) << 1 << 2 << 3 << 4 << EndMessage
            << BeginMessage( "/message_two" ) << 1 << 2 << 3 << 4 << EndMessage
            << BeginMessage( "/message_three" ) << 1 << 2 << 3 << 4 << EndMessage
            << BeginMessage( "/message_four" ) << 1 << 2 << 3 << 4 << EndMessage
            << EndBundle;
        assertEqual( ps.IsReady(), true );
        ReceivedBundle b( ReceivedPacket(ps.Data(), ps.Size()) );
        std::cout << b << "\n";
    }
}
Exemple #6
0
void webMain()
{
	std::function<int()> f=func;
	assertEqual(f(), 42, "Function object");
}
Exemple #7
0
UBool NormalizerConformanceTest::checkConformance(const UnicodeString* field,
                                                  const char *line,
                                                  int32_t options,
                                                  UErrorCode &status) {
    UBool pass = TRUE, result;
    //UErrorCode status = U_ZERO_ERROR;
    UnicodeString out, fcd;
    int32_t fieldNum;

    for (int32_t i=0; i<FIELD_COUNT; ++i) {
        fieldNum = i+1;
        if (i<3) {
            Normalizer::normalize(field[i], UNORM_NFC, options, out, status);
            if (U_FAILURE(status)) {
                dataerrln("Error running normalize UNORM_NFC: %s", u_errorName(status));
            } else {
                pass &= assertEqual("C", field[i], out, field[1], "c2!=C(c", fieldNum);
                iterativeNorm(field[i], UNORM_NFC, options, out, +1);
                pass &= assertEqual("C(+1)", field[i], out, field[1], "c2!=C(c", fieldNum);
                iterativeNorm(field[i], UNORM_NFC, options, out, -1);
                pass &= assertEqual("C(-1)", field[i], out, field[1], "c2!=C(c", fieldNum);
            }

            Normalizer::normalize(field[i], UNORM_NFD, options, out, status);
            if (U_FAILURE(status)) {
                dataerrln("Error running normalize UNORM_NFD: %s", u_errorName(status));
            } else {
                pass &= assertEqual("D", field[i], out, field[2], "c3!=D(c", fieldNum);
                iterativeNorm(field[i], UNORM_NFD, options, out, +1);
                pass &= assertEqual("D(+1)", field[i], out, field[2], "c3!=D(c", fieldNum);
                iterativeNorm(field[i], UNORM_NFD, options, out, -1);
                pass &= assertEqual("D(-1)", field[i], out, field[2], "c3!=D(c", fieldNum);
            }
        }
        Normalizer::normalize(field[i], UNORM_NFKC, options, out, status);
        if (U_FAILURE(status)) {
            dataerrln("Error running normalize UNORM_NFKC: %s", u_errorName(status));
        } else {
            pass &= assertEqual("KC", field[i], out, field[3], "c4!=KC(c", fieldNum);
            iterativeNorm(field[i], UNORM_NFKC, options, out, +1);
            pass &= assertEqual("KC(+1)", field[i], out, field[3], "c4!=KC(c", fieldNum);
            iterativeNorm(field[i], UNORM_NFKC, options, out, -1);
            pass &= assertEqual("KC(-1)", field[i], out, field[3], "c4!=KC(c", fieldNum);
        }

        Normalizer::normalize(field[i], UNORM_NFKD, options, out, status);
        if (U_FAILURE(status)) {
            dataerrln("Error running normalize UNORM_NFKD: %s", u_errorName(status));
        } else {
            pass &= assertEqual("KD", field[i], out, field[4], "c5!=KD(c", fieldNum);
            iterativeNorm(field[i], UNORM_NFKD, options, out, +1);
            pass &= assertEqual("KD(+1)", field[i], out, field[4], "c5!=KD(c", fieldNum);
            iterativeNorm(field[i], UNORM_NFKD, options, out, -1);
            pass &= assertEqual("KD(-1)", field[i], out, field[4], "c5!=KD(c", fieldNum);
        }
    }
    compare(field[1],field[2]);
    compare(field[0],field[1]);
    // test quick checks
    if(UNORM_NO == Normalizer::quickCheck(field[1], UNORM_NFC, options, status)) {
        errln("Normalizer error: quickCheck(NFC(s), UNORM_NFC) is UNORM_NO");
        pass = FALSE;
    }
    if(UNORM_NO == Normalizer::quickCheck(field[2], UNORM_NFD, options, status)) {
        errln("Normalizer error: quickCheck(NFD(s), UNORM_NFD) is UNORM_NO");
        pass = FALSE;
    }
    if(UNORM_NO == Normalizer::quickCheck(field[3], UNORM_NFKC, options, status)) {
        errln("Normalizer error: quickCheck(NFKC(s), UNORM_NFKC) is UNORM_NO");
        pass = FALSE;
    }
    if(UNORM_NO == Normalizer::quickCheck(field[4], UNORM_NFKD, options, status)) {
        errln("Normalizer error: quickCheck(NFKD(s), UNORM_NFKD) is UNORM_NO");
        pass = FALSE;
    }

    // branch on options==0 for better code coverage
    if(options==0) {
        result = Normalizer::isNormalized(field[1], UNORM_NFC, status);
    } else {
        result = Normalizer::isNormalized(field[1], UNORM_NFC, options, status);
    }
    if(!result) {
        dataerrln("Normalizer error: isNormalized(NFC(s), UNORM_NFC) is FALSE");
        pass = FALSE;
    }
    if(field[0]!=field[1] && Normalizer::isNormalized(field[0], UNORM_NFC, options, status)) {
        errln("Normalizer error: isNormalized(s, UNORM_NFC) is TRUE");
        pass = FALSE;
    }
    if(!Normalizer::isNormalized(field[3], UNORM_NFKC, options, status)) {
        dataerrln("Normalizer error: isNormalized(NFKC(s), UNORM_NFKC) is FALSE");
        pass = FALSE;
    }
    if(field[0]!=field[3] && Normalizer::isNormalized(field[0], UNORM_NFKC, options, status)) {
        errln("Normalizer error: isNormalized(s, UNORM_NFKC) is TRUE");
        pass = FALSE;
    }

    // test FCD quick check and "makeFCD"
    Normalizer::normalize(field[0], UNORM_FCD, options, fcd, status);
    if(UNORM_NO == Normalizer::quickCheck(fcd, UNORM_FCD, options, status)) {
        errln("Normalizer error: quickCheck(FCD(s), UNORM_FCD) is UNORM_NO");
        pass = FALSE;
    }
    if(UNORM_NO == Normalizer::quickCheck(field[2], UNORM_FCD, options, status)) {
        errln("Normalizer error: quickCheck(NFD(s), UNORM_FCD) is UNORM_NO");
        pass = FALSE;
    }
    if(UNORM_NO == Normalizer::quickCheck(field[4], UNORM_FCD, options, status)) {
        errln("Normalizer error: quickCheck(NFKD(s), UNORM_FCD) is UNORM_NO");
        pass = FALSE;
    }

    Normalizer::normalize(fcd, UNORM_NFD, options, out, status);
    if(out != field[2]) {
        dataerrln("Normalizer error: NFD(FCD(s))!=NFD(s)");
        pass = FALSE;
    }

    if (U_FAILURE(status)) {
        dataerrln("Normalizer::normalize returned error status: %s", u_errorName(status));
        pass = FALSE;
    }

    if(field[0]!=field[2]) {
        // two strings that are canonically equivalent must test
        // equal under a canonical caseless match
        // see UAX #21 Case Mappings and Jitterbug 2021 and
        // Unicode Technical Committee meeting consensus 92-C31
        int32_t rc;

        status=U_ZERO_ERROR;
        rc=Normalizer::compare(field[0], field[2], (options<<UNORM_COMPARE_NORM_OPTIONS_SHIFT)|U_COMPARE_IGNORE_CASE, status);
        if(U_FAILURE(status)) {
            dataerrln("Normalizer::compare(case-insensitive) sets %s", u_errorName(status));
            pass=FALSE;
        } else if(rc!=0) {
            errln("Normalizer::compare(original, NFD, case-insensitive) returned %d instead of 0 for equal", rc);
            pass=FALSE;
        }
    }

    if (!pass) {
        dataerrln("FAIL: %s", line);
    }
    return pass;
}
Exemple #8
0
int main()
{
	ipp_message *msga, *msgb;
	ipp_card *Kh;
	ipp_card *Ac, *Kc;
	ipp_card *Ad, *Kd;
	ipp_card *As, *Ks, *Qs, *Js, *Ts, *_9s, *_7s, *_6s;
	ipp_card *hand[5];

	ipp_init();

	Kh = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Kh);
	Kh->rank = KING;
	Kh->suit = HEARTS;

	Ac = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Ac);
	Ac->rank = ACE;
	Ac->suit = CLUBS;

	Kc = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Kc);
	Kc->rank = KING;
	Kc->suit = CLUBS;

	Ad = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Ad);
	Ad->rank = ACE;
	Ad->suit = DIAMONDS;

	Kd = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Kd);
	Kd->rank = KING;
	Kd->suit = DIAMONDS;

	As = ipp_new_card();
	assertNotNull("ipp_new_card() failed", As);
	As->rank = ACE;
	As->suit = SPADES;

	Ks = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Ks);
	Ks->rank = KING;
	Ks->suit = SPADES;

	Qs = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Qs);
	Qs->rank = QUEEN;
	Qs->suit = SPADES;

	Js = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Js);
	Js->rank = JACK;
	Js->suit = SPADES;

	Ts = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Js);
	Ts->rank = TEN;
	Ts->suit = SPADES;

	_9s = ipp_new_card();
	assertNotNull("ipp_new_card() failed", _9s);
	_9s->rank = NINE;
	_9s->suit = SPADES;

	_7s = ipp_new_card();
	assertNotNull("ipp_new_card() failed", _7s);
	_7s->rank = SEVEN;
	_7s->suit = SPADES;

	_6s = ipp_new_card();
	assertNotNull("ipp_new_card() failed", _6s);
	_6s->rank = SIX;
	_6s->suit = SPADES;

/* =-=-=-=-=-= */

	hand[0] = As;
	hand[1] = Ks;
	hand[2] = Qs;
	hand[3] = Js;
	hand[4] = Ts;

	msga = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msga);
	assertStringEqual("Didn't detect proper hand.", "STRAIGHTFLUSH A", msga->payload);
	assertEqual("Didn't detect proper hand.", msga->type, MSG_STRAIGHTFLUSH);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msga->payload), MSG_STRAIGHTFLUSH);

	hand[0] = As;
	hand[1] = Kd;
	hand[2] = Js;
	hand[3] = _7s;
	hand[4] = _6s;

	msgb = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msgb);
	assertStringEqual("Didn't detect proper hand.", "HIGHCARD A K J 7 6", msgb->payload);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msgb->payload), MSG_HIGHCARD);

	assertEqual("msga should beat msgb", 1, ipp_hand_compar(msga, msgb));
	assertEqual("msga should beat msgb", -1, ipp_hand_compar(msgb, msga));
	assertEqual("msga should equal msga", 0, ipp_hand_compar(msga, msga));

	ipp_free_message(msga);
	ipp_free_message(msgb);

/* =-=-=-=-=-= */

	hand[0] = As;
	hand[1] = Ks;
	hand[2] = Qs;
	hand[3] = Js;
	hand[4] = Ts;

	msga = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msga);
	assertStringEqual("Didn't detect proper hand.", "STRAIGHTFLUSH A", msga->payload);
	assertEqual("Didn't detect proper hand.", msga->type, MSG_STRAIGHTFLUSH);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msga->payload), MSG_STRAIGHTFLUSH);

	hand[0] = Ks;
	hand[1] = Qs;
	hand[2] = Js;
	hand[3] = Ts;
	hand[4] = _9s;

	msgb = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msgb);
	assertStringEqual("Didn't detect proper hand.", "STRAIGHTFLUSH K", msgb->payload);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msgb->payload), MSG_STRAIGHTFLUSH);

	assertEqual("msga should beat msgb", 1, ipp_hand_compar(msga, msgb));
	assertEqual("msga should beat msgb", -1, ipp_hand_compar(msgb, msga));
	assertEqual("msga should equal msga", 0, ipp_hand_compar(msga, msga));

	ipp_free_message(msga);
	ipp_free_message(msgb);

/* =-=-=-=-=-= */

	hand[0] = As;
	hand[1] = Ks;
	hand[2] = Kd;
	hand[3] = Kh;
	hand[4] = Kc;

	msga = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msga);
	assertStringEqual("Didn't detect proper hand.", "FOUROFAKIND K A", msga->payload);
	assertEqual("Didn't detect proper hand.", msga->type, MSG_FOUROFAKIND);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msga->payload), MSG_FOUROFAKIND);

	hand[0] = Ks;
	hand[1] = Kd;
	hand[2] = Kh;
	hand[3] = Kc;
	hand[4] = _9s;

	msgb = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msgb);
	assertStringEqual("Didn't detect proper hand.", "FOUROFAKIND K 9", msgb->payload);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msgb->payload), MSG_FOUROFAKIND);

	assertEqual("msga should beat msgb", 1, ipp_hand_compar(msga, msgb));
	assertEqual("msga should beat msgb", -1, ipp_hand_compar(msgb, msga));
	assertEqual("msga should equal msga", 0, ipp_hand_compar(msga, msga));

	ipp_free_message(msga);
	ipp_free_message(msgb);


/* =-=-=-=-=-= */

	hand[0] = As;
	hand[1] = Kd;
	hand[2] = Qs;
	hand[3] = Js;
	hand[4] = Ts;

	msga = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msga);
	assertStringEqual("Didn't detect proper hand.", "STRAIGHT A", msga->payload);
	assertEqual("Didn't detect proper hand.", msga->type, MSG_STRAIGHT);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msga->payload), MSG_STRAIGHT);

	hand[0] = Qs;
	hand[1] = Kd;
	hand[2] = Js;
	hand[3] = Ts;
	hand[4] = _9s;

	msgb = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msgb);
	assertStringEqual("Didn't detect proper hand.", "STRAIGHT K", msgb->payload);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msgb->payload), MSG_STRAIGHT);

	assertEqual("msga should beat msgb", 1, ipp_hand_compar(msga, msgb));
	assertEqual("msga should beat msgb", -1, ipp_hand_compar(msgb, msga));
	assertEqual("msga should equal msga", 0, ipp_hand_compar(msga, msga));

	ipp_free_message(msga);
	ipp_free_message(msgb);

/* =-=-=-=-=-= */

	hand[0] = As;
	hand[1] = Kd;
	hand[2] = Ac;
	hand[3] = Ad;
	hand[4] = Ks;

	msga = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msga);
	assertStringEqual("Didn't detect proper hand.", "FULLHOUSE A K", msga->payload);
	assertEqual("Didn't detect proper hand.", msga->type, MSG_FULLHOUSE);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msga->payload), MSG_FULLHOUSE);

	hand[0] = Ks;
	hand[1] = Kd;
	hand[2] = As;
	hand[3] = Ac;
	hand[4] = Kh;

	msgb = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msgb);
	assertStringEqual("Didn't detect proper hand.", "FULLHOUSE K A", msgb->payload);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msgb->payload), MSG_FULLHOUSE);

	assertEqual("msga should beat msgb", 1, ipp_hand_compar(msga, msgb));
	assertEqual("msga should beat msgb", -1, ipp_hand_compar(msgb, msga));
	assertEqual("msga should equal msga", 0, ipp_hand_compar(msga, msga));

	ipp_free_message(msga);
	ipp_free_message(msgb);

/* =-=-=-=-=-= */

	hand[0] = As;
	hand[1] = Kd;
	hand[2] = Ac;
	hand[3] = Ts;
	hand[4] = Ks;

	msga = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msga);
	assertStringEqual("Didn't detect proper hand.", "TWOPAIR A K T", msga->payload);
	assertEqual("Didn't detect proper hand.", msga->type, MSG_TWOPAIR);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msga->payload), MSG_TWOPAIR);

	hand[0] = Ks;
	hand[1] = Kd;
	hand[2] = As;
	hand[3] = Ac;
	hand[4] = _9s;

	msgb = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msgb);
	assertStringEqual("Didn't detect proper hand.", "TWOPAIR A K 9", msgb->payload);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msgb->payload), MSG_TWOPAIR);

	assertEqual("msga should beat msgb", 1, ipp_hand_compar(msga, msgb));
	assertEqual("msga should beat msgb", -1, ipp_hand_compar(msgb, msga));
	assertEqual("msga should equal msga", 0, ipp_hand_compar(msga, msga));

	ipp_free_message(msga);
	ipp_free_message(msgb);

/* =-=-=-=-=-= */

	hand[0] = _9s;
	hand[1] = Ad;
	hand[2] = Ac;
	hand[3] = Ts;
	hand[4] = As;

	msga = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msga);
	assertStringEqual("Didn't detect proper hand.", "THREEOFAKIND A T 9", msga->payload);
	assertEqual("Didn't detect proper hand.", msga->type, MSG_THREEOFAKIND);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msga->payload), MSG_THREEOFAKIND);

	hand[0] = Ks;
	hand[1] = Kd;
	hand[2] = As;
	hand[3] = Kh;
	hand[4] = _9s;

	msgb = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msgb);
	assertStringEqual("Didn't detect proper hand.", "THREEOFAKIND K A 9", msgb->payload);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msgb->payload), MSG_THREEOFAKIND);

	assertEqual("msga should beat msgb", 1, ipp_hand_compar(msga, msgb));
	assertEqual("msga should beat msgb", -1, ipp_hand_compar(msgb, msga));
	assertEqual("msga should equal msga", 0, ipp_hand_compar(msga, msga));

	ipp_free_message(msga);
	ipp_free_message(msgb);

/* =-=-=-=-=-= */

	hand[0] = _9s;
	hand[1] = Ad;
	hand[2] = _7s;
	hand[3] = Ts;
	hand[4] = As;

	msga = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msga);
	assertStringEqual("Didn't detect proper hand.", "ONEPAIR A T 9 7", msga->payload);
	assertEqual("Didn't detect proper hand.", msga->type, MSG_ONEPAIR);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msga->payload), MSG_ONEPAIR);

	hand[0] = Ks;
	hand[1] = Kd;
	hand[2] = As;
	hand[3] = _7s;
	hand[4] = _9s;

	msgb = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msgb);
	assertStringEqual("Didn't detect proper hand.", "ONEPAIR K A 9 7", msgb->payload);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msgb->payload), MSG_ONEPAIR);

	assertEqual("msga should beat msgb", 1, ipp_hand_compar(msga, msgb));
	assertEqual("msga should beat msgb", -1, ipp_hand_compar(msgb, msga));
	assertEqual("msga should equal msga", 0, ipp_hand_compar(msga, msga));

	ipp_free_message(msga);
	ipp_free_message(msgb);

/* =-=-=-=-=-= */

	hand[0] = _9s;
	hand[1] = Ad;
	hand[2] = _7s;
	hand[3] = Ts;
	hand[4] = As;

	msga = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msga);
	assertStringEqual("Didn't detect proper hand.", "ONEPAIR A T 9 7", msga->payload);
	assertEqual("Didn't detect proper hand.", msga->type, MSG_ONEPAIR);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msga->payload), MSG_ONEPAIR);

	assertEqual("msga should beat NULL", 1, ipp_hand_compar(msga, NULL));
	assertEqual("msga should beat NULL", -1, ipp_hand_compar(NULL, msga));
	assertEqual("msga should equal msga", 0, ipp_hand_compar(msga, msga));
	assertEqual("NULL should equal NULL", 0, ipp_hand_compar(NULL, NULL));

	ipp_free_message(msga);

/* =-=-=-=-=-= */

	ipp_free_card(_6s);
	ipp_free_card(_7s);
	ipp_free_card(_9s);
	ipp_free_card(Ts);
	ipp_free_card(Js);
	ipp_free_card(Qs);
	ipp_free_card(Ks);
	ipp_free_card(As);
	ipp_free_card(Kd);
	ipp_free_card(Ad);
	ipp_free_card(Kc);
	ipp_free_card(Ac);
	ipp_free_card(Kh);

	ipp_exit();
	return PASS;
}
Exemple #9
0
	void test(client::Float64Array* a)
	{
		assertEqual(a->get(2), 1.2, "Accessing typed arrays using set/get 2/3");
		testSuccessful = true;
	}
 void testLoad3DVolumeNrrdFileWithBlur()
 {
   auto loadedVolume = mitk::pa::IOUtil::LoadNrrd(TEST_FOLDER_PATH + TEST_3D_Volume_PATH + TEST_FILE_ENDING, 1);
   assertEqual(loadedVolume, m_Test3DVolume);
 }
Exemple #11
0
void webMain()
{
	int a=*ptrX;
	assertEqual(a, 1, "Access to member of global structures");
}
Exemple #12
0
void webMain()
{
	//Test new on classes
	A* a=new A;
	assertEqual(a->a, 42, "New on class types");
}
void URLEncoderTest::EncodeDecodeTest()
{
	StartTrace(URLEncoderTest.EncodeDecodeTest);
	URLEncoder encoder("encoder");

	int i;

	String EmptySt, expected;
	String EncodedString;
	String DecodedString;
	String OriginalString;

	// Test 1:
	// checkif all HEX-values can be en-/decoded
	// check for identity of original and decoded string
	// check the lengths

	// setup original
	for (  i = 0; i < 256; i++ ) {
		OriginalString.Append( (char)i );
	}

	// encode decode with URLEncoder
	// and changes '+' to ' ' in decoded string
	encoder.DoEncode( EncodedString, OriginalString);
	encoder.DoDecode( DecodedString, EncodedString);
	expected = OriginalString;
	// '+' gets converted to a space also
	expected.PutAt(long('+'), ' ');
	// assert strings are equal
	assertEqualRaw(expected, DecodedString);
	assertEqual( expected.Length(), DecodedString.Length() );

	assertEqual( expected, DecodedString );
	assertEqual( expected.Length(), DecodedString.Length() );

	// Test 3
	// reset strings
	OriginalString = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	EncodedString = EmptySt;
	DecodedString = EmptySt;

	// encode decode with URLEncoder
	encoder.DoEncode( EncodedString, OriginalString);
	encoder.DoDecode( DecodedString, EncodedString );

	// check whether the Strings are identical
	assertCharPtrEqual( OriginalString, DecodedString );
	t_assert( OriginalString == DecodedString );
	assertCharPtrEqual( "ABCDEFGHIJKLMNOPQRSTUVWXYZ", EncodedString );

	//Test 4
	// Only Unprintable Chars
	OriginalString = EmptySt;
	EncodedString = EmptySt;
	DecodedString = EmptySt;

	for ( i = 0; i < 10; i++ ) {
		OriginalString.Append( (char)i );
	}

	// encode decode with URLEncoder
	encoder.DoEncode( EncodedString, OriginalString);
	encoder.DoDecode( DecodedString, EncodedString );

	// check whether the Strings are identical
	t_assert( (memcmp( (const char *)OriginalString, (const char *)DecodedString, OriginalString.Length() ) == 0) );
	t_assert( OriginalString.Length() == DecodedString.Length() );

	assertCharPtrEqual( OriginalString, DecodedString );
	t_assert( OriginalString == DecodedString );

	assertCharPtrEqual( "%00%01%02%03%04%05%06%07%08%09", EncodedString );

	// One Printable Char, unscrambled
	OriginalString = "M";
	EncodedString = EmptySt;
	DecodedString = EmptySt;

	// check whether the Strings are identical
	encoder.DoEncode( EncodedString, OriginalString);
	encoder.DoDecode( DecodedString, EncodedString );

	assertCharPtrEqual( OriginalString, DecodedString );
	t_assert( OriginalString == DecodedString );
	assertCharPtrEqual( "M", EncodedString );

	// One Unprintable Char, unscrambled
	OriginalString = EmptySt;
	OriginalString.Append( (char)5 );

	OriginalString = OriginalString;
	EncodedString = EmptySt;
	DecodedString = EmptySt;
	encoder.DoEncode( EncodedString, OriginalString);
	encoder.DoDecode( DecodedString, EncodedString );

	assertCharPtrEqual( OriginalString, DecodedString );
	t_assert( OriginalString == DecodedString );

	// String::IntPrintOn:  05     -> \x05
	// coast::urlutils::urlEncode: \x05   -> %5Cx05
	// coast::urlutils::urlEncode: %5Cx05 -> %255Cx05
	assertCharPtrEqual( "%05", EncodedString );

	// Only Printable Chars, scrambled
	OriginalString = "ABC";
	EncodedString = EmptySt;
	DecodedString = EmptySt;
	encoder.DoEncode( EncodedString, OriginalString);
	encoder.DoDecode( DecodedString, EncodedString );

	assertCharPtrEqual( OriginalString, DecodedString );
	t_assert( OriginalString == DecodedString );
	// w\"ABC\"
	assertCharPtrEqual( "ABC", EncodedString );

	// a particularly nasty sequence of non-printables and printables
	OriginalString = "Anfang%252B+%2BEnde";
	EncodedString = EmptySt;
	DecodedString = EmptySt;

	encoder.DoEncode( EncodedString, OriginalString);
	assertEqual( "Anfang%25252B+%252BEnde", EncodedString);
	encoder.DoDecode( DecodedString, EncodedString );
	assertEqual( "Anfang%252B %2BEnde", DecodedString);

	// Only Unprintable Chars, scrambled
	OriginalString = EmptySt;
	for (  i = 0; i < 3; i++ ) {
		OriginalString.Append( (char)i );
	}
	EncodedString = EmptySt;
	DecodedString = EmptySt;
	encoder.DoEncode( EncodedString, OriginalString);
	encoder.DoDecode( DecodedString, EncodedString );

	assertCharPtrEqual( OriginalString, DecodedString );
	t_assert( OriginalString == DecodedString );

	assertCharPtrEqual( "%00%01%02", EncodedString );

	// One Printable Char, scrambled
	OriginalString = "M";
	OriginalString = OriginalString;
	EncodedString = EmptySt;
	DecodedString = EmptySt;
	encoder.DoEncode( EncodedString, OriginalString);
	encoder.DoDecode( DecodedString, EncodedString );

	assertCharPtrEqual( OriginalString, DecodedString );
	t_assert( OriginalString == DecodedString );
	assertCharPtrEqual( "M", EncodedString );

	//           1         2         3         4         5         6
	// 0123456789012345678901234567890123456789012345678901234567890123456789
	// ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-$

	// One Unprintable Char, scrambled
	OriginalString = EmptySt;
	OriginalString.Append( (char)5 );

	OriginalString = OriginalString;
	EncodedString = EmptySt;
	DecodedString = EmptySt;
	encoder.DoEncode( EncodedString, OriginalString);
	encoder.DoDecode( DecodedString, EncodedString );

	assertCharPtrEqual( OriginalString, DecodedString );
	t_assert( OriginalString == DecodedString );

	assertCharPtrEqual( "%05", EncodedString );
}
Exemple #14
0
/**
 * Test for setText()
 */
static void TestSetText()
{
    int32_t c,i;
    UErrorCode status = U_ZERO_ERROR;
    UCollator *en_us=NULL;
    UCollationElements *iter1, *iter2;
    UChar test1[50];
    UChar test2[50];

    u_uastrcpy(test1, "What subset of all possible test cases?");
    u_uastrcpy(test2, "has the highest probability of detecting");
    en_us = ucol_open("en_US", &status);
    log_verbose("testing setText for Collation elements\n");
    iter1=ucol_openElements(en_us, test1, u_strlen(test1), &status);
    if(U_FAILURE(status)){
        log_err_status(status, "ERROR: in creation of collation element iterator1 using ucol_openElements()\n %s\n",
            myErrorName(status));
    ucol_close(en_us);
        return;
    }
    iter2=ucol_openElements(en_us, test2, u_strlen(test2), &status);
    if(U_FAILURE(status)){
        log_err("ERROR: in creation of collation element iterator2 using ucol_openElements()\n %s\n",
            myErrorName(status));
    ucol_close(en_us);
        return;
    }

    /* Run through the second iterator just to exercise it */
    c = ucol_next(iter2, &status);
    i = 0;

    while ( ++i < 10 && (c != UCOL_NULLORDER))
    {
        if (U_FAILURE(status))
        {
            log_err("iter2->next() returned an error. %s\n", myErrorName(status));
            ucol_closeElements(iter2);
            ucol_closeElements(iter1);
    ucol_close(en_us);
            return;
        }

        c = ucol_next(iter2, &status);
    }

    /* Now set it to point to the same string as the first iterator */
    ucol_setText(iter2, test1, u_strlen(test1), &status);
    if (U_FAILURE(status))
    {
        log_err("call to iter2->setText(test1) failed. %s\n", myErrorName(status));
    }
    else
    {
        assertEqual(iter1, iter2);
    }

    /* Now set it to point to a null string with fake length*/
    ucol_setText(iter2, NULL, 2, &status);
    if (status != U_ILLEGAL_ARGUMENT_ERROR)
    {
        log_err("call to iter2->setText(null, 2) should yield an illegal-argument-error - %s\n",
                myErrorName(status));
    }

    ucol_closeElements(iter2);
    ucol_closeElements(iter1);
    ucol_close(en_us);
}
Exemple #15
0
int main()
{
	SystemInit();
	const Ec1 g1(-1, 1);
	const Ec2 g2(
		Fp2(Fp(g2c.aa), Fp(g2c.ab)),
		Fp2(Fp(g2c.ba), Fp(g2c.bb))
	);
	// assertBool g2 and g1 on curve
	assertBool("g1 is on EC", g1.isValid());
	assertBool("g2 is on twist EC", g2.isValid());
	puts("order of group");
	const Mpz& r = GetParamR();
	PUT(r);
	{
		Ec1 t = g1;
		t.mul(r);
		assertBool("orgder of g1 == r", t.isZero());
	}
	{
		Ec2 t = g2;
		t.mul(r);
		assertBool("order of g2 == r", t.isZero());
	}
	const Mpz a("123456789012345");
	const Mpz b("998752342342342342424242421");

	// scalar-multiplication sample
	{
		Mpz c = a;
		c.add(b);
		Ec1 Pa = g1; Pa.mul(a);
		Ec1 Pb = g1; Pb.mul(b);
		Ec1 Pc = g1; Pc.mul(c);
		Ec1 out = Pa;
		out.add(Pb);

		assertEqual("check g1 * c = g1 * a + g1 * b", Pc, out);
	}

	Fp12 e;
	// calc e : G2 x G1 -> G3 pairing
	e.pairing(g2, g1); // e = e(g2, g1)
	PUT(e);
	{
		Fp12 t = e;
		t.power(r);
		assertEqual("order of e == r", t, Fp12(1));
	}
	Ec2 g2a = g2;
	g2a.mul(a);
	Fp12 ea1;
	ea1.pairing(g2a, g1);
	Fp12 ea2 = e;
	ea2.power(a); // ea2 = e^a
	assertEqual("e(g2 * a, g1) = e(g2, g1)^a", ea1, ea2);

	Ec1 g1b = g1;
	g1b.mul(b);
	Fp12 eb1;
	eb1.pairing(g2, g1b); // eb1 = e(g2, g1b)
	Fp12 eb2 = e;
	eb2.power(b); // eb2 = e^b
	assertEqual("e(g2a, g1 * b) = e(g2, g1)^b", eb1, eb2);

	Ec1 q1 = g1;
	q1.mul(12345);
	assertBool("q1 is on EC", q1.isValid());
	Fp12 e1, e2;
	e1.pairing(g2, g1); // e1 = e(g2, g1)
	e2.pairing(g2, q1); // e2 = e(g2, q1)
	Ec1 q2 = g1;
	q2.add(q1);
	e.pairing(g2, q2); // e = e(g2, q2)
	e1.mul(e2);
	assertEqual("e = e1 * e2", e, e1);
	/*
		reduce one copy as the following
	*/
	g2a = g2;
	g2a.mul(a);
	g1b = g1;
	g1b.mul(b);
	Ec2 g2at = g2; g2at.mul(a);
	Ec1 g1bt = g1; g1bt.mul(b);
	assertEqual("g2a == g2 * a", g2a, g2at);
	assertEqual("g1b == g1 * b", g1b, g1bt);
	printf("errNum = %d\n", errNum);
}
Exemple #16
0
void webMain()
{
	char a1=*str;
	char b1=str[0];
	char c1=str[3];
	assertEqual(a1, 't', "Access to global array 1/6");
	assertEqual(b1, 't', "Access to global array 2/6");
	assertEqual(c1, 't', "Access to global array 3/6");
	short d1=*numbers;
	short e1=numbers[0];
	short f1=numbers[3];
	assertEqual(d1, 2, "Access to global array 4/6");
	assertEqual(e1, 2, "Access to global array 5/6");
	assertEqual(f1, 42, "Access to global array 6/6");

	char a2=*str2;
	char b2=str2[0];
	char c2=str2[1];
	assertEqual(a2, 't', "Access to global array using pointer 1/6");
	assertEqual(b2, 't', "Access to global array using pointer 2/6");
	assertEqual(c2, 'e', "Access to global array using pointer 3/6");
	short d2=*numbers2;
	short e2=numbers2[0];
	short f2=numbers2[3];
	assertEqual(d2, 2, "Access to global array using pointer 4/6");
	assertEqual(e2, 2, "Access to global array using pointer 5/6");
	assertEqual(f2, 42, "Access to global array using pointer 6/6");

	char a3=*str3;
	char b3=str3[0];
	char c3=str3[1];
	assertEqual(a3, 's', "Access to global array using pointer with offset 1/6");
	assertEqual(b3, 's', "Access to global array using pointer with offset 2/6");
	assertEqual(c3, 't', "Access to global array using pointer with offset 3/6");
	short d3=*numbers3;
	short e3=numbers3[0];
	short f3=numbers3[3];
	assertEqual(d3, 7, "Access to global array using pointer with offset 4/6");
	assertEqual(e3, 7, "Access to global array using pointer with offset 5/6");
	assertEqual(f3, 8, "Access to global array using pointer with offset 6/6");

	const char* str4 = str+2;
	char a4=*str4;
	char b4=str4[0];
	char c4=str4[1];
	assertEqual(a4, 's', "Access to global array using local pointer with offset 1/3");
	assertEqual(b4, 's', "Access to global array using local pointer with offset 2/3");
	assertEqual(c4, 't', "Access to global array using local pointer with offset 3/3");

	char** lstr6 = str5;
	char a5=*lstr6[0];
	char b5=lstr6[0][0];
	char c5=lstr6[0][1];
	assertEqual(a5, 't', "Access to global array using local pointer with offset 1/6");
	assertEqual(b5, 't', "Access to global array using local pointer with offset 2/6");
	assertEqual(c5, 'e', "Access to global array using local pointer with offset 3/6");

	char** lstr7 = str6;
	char a6=*lstr7[0];
	char b6=lstr7[0][0];
	char c6=lstr7[0][1];
	assertEqual(a6, 't', "Access to global array using local pointer with offset 4/6");
	assertEqual(b6, 't', "Access to global array using local pointer with offset 5/6");
	assertEqual(c6, 'S', "Access to global array using local pointer with offset 6/6");
}
int main()
{
	ipp_message *msg;
	ipp_card *Ks, *Kd, *Kh, *Kc;
	ipp_card *As, *Ad, *Ah;
	ipp_player *player;
	ipp_table *table;
	int rc, i;

	ipp_init();

	table = ipp_new_table();
	player = ipp_new_player();

	assertNotNull("Table should not be null.", table);
	assertNotNull("Player should not be null.", player);
	assertEqual("Table shouldn't have any players", table->nplayers, 0);

	rc = ipp_add_player(table, player);
	assertNotEqual("Should have been able to add player", rc, -1);
	assertEqual("Should have one player", table->nplayers, 1);

	Kh = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Kh);
	Kh->rank = KING;
	Kh->suit = HEARTS;

	Kc = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Kc);
	Kc->rank = KING;
	Kc->suit = CLUBS;

	Ks = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Ks);
	Ks->rank = KING;
	Ks->suit = SPADES;

	Kd = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Kd);
	Kd->rank = KING;
	Kd->suit = DIAMONDS;

	Ah = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Ah);
	Ah->rank = ACE;
	Ah->suit = HEARTS;

	As = ipp_new_card();
	assertNotNull("ipp_new_card() failed", As);
	As->rank = ACE;
	As->suit = SPADES;

	Ad = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Ad);
	Ad->rank = ACE;
	Ad->suit = DIAMONDS;

	table->board[0] = Ad;
	table->board[1] = Ah;
	table->board[2] = Kd;
	table->board[3] = Kh;
	table->board[4] = Kc;
	table->players[0]->hole[0] = As;
	table->players[0]->hole[1] = Ks;
	table->stage = SHOWDOWN;

	msg = ipp_best_combination(table, 0);
	assertNotNull("ipp_best_combination() should have return an answer", msg);

	printf("%s\n", msg->payload);
	assertStringEqual("Out of Ad Ah As Kd Ks Kh Kc, FOUROFAKIND K A should be the best hand.", "FOUROFAKIND K A", msg->payload);

	ipp_free_message(msg);
	ipp_free_table(table);	/* will also free player */

	ipp_exit();
	return PASS;
}
void StringTokenizerTest::constrMethods2 ()
{
	String token;
	bool ret;

	StringTokenizer st("0123450678901230456078901230456709012", '2' );
	assertEqual( st.fString, "0123450678901230456078901230456709012" );
	t_assert( st.fDelimiter == '2' );

	ret = st.NextToken(token);
	assertEqual("01", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("3450678901", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("30456078901", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("3045670901", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("", token);		// PT: new version has correct behavior
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("", token);
	assertEqual(false, ret);
}
Exemple #19
0
void webMain()
{
	volatile float val = 2.0f;
	float ret = powf(val, 10.0f);
	assertEqual(ret, 1024.0f, "libc pow");
}
void StringTokenizerTest::constrMethods0 ()
{
	String token;
	bool ret;

	StringTokenizer st("0123450678901230456078901230456709012", '0' );
	assertEqual( st.fString, "0123450678901230456078901230456709012" );
	t_assert( st.fDelimiter == '0' );

	ret = st.NextToken(token);
	assertEqual("", token);	// ????  Empty token if String begins with a delimiter
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("12345", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("6789", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("123", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("456", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("789", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("123", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("4567", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("9", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("12", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("12", token);
	assertEqual(false, ret);

	ret = st.NextToken(token);
	assertEqual("12", token);
	assertEqual(false, ret);
}
Exemple #21
0
int main() {
    {
    polynomialDemo();

    int a[5] = {0, 1, 2, 3, 4};
    Polynomial<int> p(1);
    Polynomial<int> q(a, a + 5);
    Polynomial<int> z(a, a + 5);
    Polynomial<int> t(q);

    startTest("Operator << :");
    std::cout << q <<" ";
    endTest();

    startTest("Operator == test");
    assertEqual(q, t);
    endTest();


    startTest("Operator != test");
    if (q == p) {
        std::runtime_error("FAILED!");
    }
    endTest();


    startTest("Operator += test");
    q += p;
    {
        int expect[5] = {1, 1, 2, 3, 4};
        assertEqual(
            q, Polynomial<int>(expect, expect + 5));
    }
    endTest();


    startTest("Operator += test2");
    p += q;
    {
        int expect[5] = {2, 1, 2, 3, 4};
        assertEqual(
            p, Polynomial<int>(expect, expect + 5));
    }
    endTest();


    startTest("Operator -= test");
    p -= q;
    {
        int expect[1] = {1};
        assertEqual(
            p, Polynomial<int>(expect, expect + 1));
    }
    endTest();


    startTest("Operator -= test 2");
    {
        assertEqual(t -= z, Polynomial<int>(0));
    }
    endTest();


    startTest("Operator += int test");
    p += (Polynomial<int>) 1;
    {
        int expect[1] = {2};
        assertEqual(
            p, Polynomial<int>(expect, expect + 1));
    }
    endTest();
    }



    {
    int a[2] = {0, 1};
    int b[4] = {1, 2, 3 ,4};


    {
    startTest("Multiplication 0");
    Polynomial<int> p(a, a + 2);
    Polynomial<int> q(b, b + 4);
    p *= q;

    int expect[5] = {0, 1, 2, 3, 4};
    assertEqual(
        p, Polynomial<int>(expect, expect + 5));
    endTest();
    }


    {
    startTest("Multiplication 1");
    Polynomial<int> p(a, a + 2);
    Polynomial<int> q(b, b + 4);
    q *= p;
    int expect[5] = {0, 1, 2, 3, 4};
    assertEqual(
        q, Polynomial<int>(expect, expect + 5));
    endTest();
    }



    {
    startTest("Multiplication by zero");
    Polynomial<int> p;
    Polynomial<int> q(b, b + 4);
    q *= p;
    assertEqual(q, Polynomial<int>(0));
    endTest();
    }



    {
    startTest("Multiplication by zero 2");
    Polynomial<int> p;
    Polynomial<int> q(b, b + 4);
    p *= q;
    assertEqual(p, Polynomial<int>(0));
    endTest();
    }




    {
    startTest("Operator *");
    Polynomial<int> p(a, a + 2);
    Polynomial<int> q(b, b + 4);

    int expect[5] = {0, 1, 2, 3, 4};
    assertEqual(
        p * q, Polynomial<int>(expect, expect + 5));
    endTest();
    }


    {
    startTest("Operator * 2");
    Polynomial<int> p(a, a + 2);
    Polynomial<int> q(b, b + 4);
    int expect[5] = {0, 1, 2, 3, 4};
    assertEqual(
        q * p, Polynomial<int>(expect, expect + 5));
    endTest();
    }



    {
    startTest("Operator * by 0");
    Polynomial<int> p;
    Polynomial<int> q(b, b + 4);
    assertEqual(q * p, Polynomial<int>(0));
    endTest();
    }



    {
    startTest("Operator * by 0 ver2");
    Polynomial<int> p;
    Polynomial<int> q(b, b + 4);
    assertEqual(p * q, Polynomial<int>(0));
    endTest();
    }
    }

    {
        int a[3] = {3, 2, 1};
        Polynomial<int> p(a, a + 3);

        startTest("Operator (0)");
        assertEqual(3, p(0));
        endTest();

        startTest("Operator (1)");
        assertEqual(6, p(1));
        endTest();

        startTest("Operator (3)");
        assertEqual(18, p(3));
        endTest();
    }

    {
        int a[4] = {-42, 0, -12, 1};
        int b[2] = {-3, 1};
        Polynomial<int> p(a, a + 4);
        Polynomial<int> q(b, b + 2);
        int e[3] = {-27, -9, 1};

        startTest("Operator /");
        assertEqual(p / q, Polynomial<int>(e, e + 3));
        endTest();
    }

    {
        int a[4] = {-42, 0, -12, 1};
        Polynomial<int> p(a, a + 4);
        Polynomial<int> q(1);
        int e[4] = {-42, 0, -12, 1};

        startTest("Operator / vol.2");
        assertEqual(p / q, Polynomial<int>(e, e + 4));
        endTest();
    }

    {
        int a[4] = {0, 0, 2, 2};
        Polynomial<int> p(a, a + 4);
        Polynomial<int> q(2);
        int e[4] = {0, 0, 1, 1};

        startTest("Operator / vol.3");
        assertEqual(p / q, Polynomial<int>(e, e + 4));
        endTest();
    }

    {
        int a[4] = {-42, 0, -12, 1};
        int b[2] = {-3, 1};
        Polynomial<int> p(a, a + 4);
        Polynomial<int> q(b, b + 2);
        int e[3] = {-27, -9, 1};

        startTest("Operator /=");
        assertEqual(p /= q, Polynomial<int>(e, e + 3));
        endTest();
    }

    {
        int a[4] = {-42, 0, -12, 1};
        Polynomial<int> p(a, a + 4);
        Polynomial<int> q(1);
        int e[4] = {-42, 0, -12, 1};

        startTest("Operator /= vol.2");
        assertEqual(p /= q, Polynomial<int>(e, e + 4));
        endTest();
    }

    {
        int a[4] = {0, 0, 2, 2};
        Polynomial<int> p(a, a + 4);
        Polynomial<int> q(2);
        int e[4] = {0, 0, 1, 1};

        startTest("Operator /= vol.3");
        assertEqual(p /= q, Polynomial<int>(e, e + 4));
        endTest();
    }

    {
        int a[4] = {0, 0, 2, 2};
        Polynomial<int> p(a, a + 4);
        int b[4] = {0, 0, 4, 5};
        Polynomial<int> q(b, b + 4);
        int c[1] = {2};
        Polynomial<int> expect(c, c + 1);

        startTest("Operator /= vol.4");
        assertEqual(q /= p, expect);
        endTest();
    }

    {
        int a[4] = {0, 0, 0, 1};
        Polynomial<int> p(a, a + 4);
        int b[3] = {0, 0, 2};
        Polynomial<int> q(b, b + 3);
        int c[1] = {0};
        Polynomial<int> expect(c, c + 1);

        startTest("Operator /= vol.5");
        assertEqual(p /= q, expect);
        endTest();
    }

    {
        int a[4] = {-42, 0, -12, 1};
        int b[2] = {-3, 1};
        Polynomial<int> p(a, a + 4);
        Polynomial<int> q(b, b + 2);
        int e[3] = {-27, -9, 1};

        startTest("Operator %=");
        assertEqual(p %= q, Polynomial<int>(-123));
        endTest();
    }

    {
        int a[4] = {-42, 0, -12, 1};
        int b[2] = {-3, 1};
        Polynomial<int> p(a, a + 4);
        Polynomial<int> q(b, b + 2);
        int e[3] = {-27, -9, 1};

        startTest("Operator %");
        assertEqual(p % q, Polynomial<int>(-123));
        endTest();
    }

    {
        int a[4] = {0, 0, 2, 2};
        Polynomial<int> p(a, a + 4);
        Polynomial<int> q(2);
        int e[1] = {0};

        startTest("Operator %= vol.2");
        assertEqual(p %= q, Polynomial<int>(e, e + 1));
        endTest();
    }

    {
        int a[4] = {0, 0, 4, 5};
        Polynomial<int> p(a, a + 4);
        int b[4] = {0, 0, 2, 2};
        Polynomial<int> q(b, b + 4);
        int c[4] = {0, 0, 0, 1};
        Polynomial<int> expect(c, c + 4);

        startTest("Operator %= vol.3");
        assertEqual(p %= q, expect);
        endTest();
    }

    {
        int a[3] = {0, 2, 2};
        Polynomial<int> p(a, a + 3);
        int b[4] = {0, 0, 4, 5};
        Polynomial<int> q(b, b + 4);
        int c[4] = {0, 2, 2};
        Polynomial<int> expect(c, c + 3);

        startTest("Operator %= vol.4");
        assertEqual(p %= q, expect);
        endTest();
    }

    {
        int a[4] = {0, 0, 2, 2};
        Polynomial<int> p(a, a + 4);
        int b[4] = {0, 0, 4, 4};
        Polynomial<int> q(b, b + 4);
        int c[4] = {0, 0, 2, 2};
        Polynomial<int> expect(c, c + 4);

        startTest("Operator , vol.0");
        assertEqual((p, q), expect);
        endTest();
    }

    {
        int a[4] = {0, 0, 2, 2};
        Polynomial<int> p(a, a + 4);
        int b[4] = {0, 0, 4, 5};
        Polynomial<int> q(b, b + 4);
        int c[4] = {0, 0, 1};
        Polynomial<int> expect(c, c + 3);

        startTest("Operator , vol.1");
        assertEqual((p, q), expect);
        endTest();
    }
    {
        int a[4] = {0, 0, 2, 2};
        Polynomial<int> p(a, a + 4);
        int b[4] = {0, 0, 4, 5};
        Polynomial<int> q(b, b + 4);
        int c[4] = {0, 0, 1};
        Polynomial<int> expect(c, c + 3);

        startTest("Operator , vol.1");
        assertEqual((p, q), expect);
        endTest();
    }

    {
        int a[3] = {0, 2, 2};
        Polynomial<int> p(a, a + 3);
        int b[4] = {0, 0, 4, 5};
        Polynomial<int> q(b, b + 4);
        int c[2] = {0, 1};
        Polynomial<int> expect(c, c + 2);

        startTest("Operator , vol.2");
        assertEqual((p, q), expect);
        endTest();
    }
    return 0;
}
void StringTokenizerTest::resetTest ()
{

	StringTokenizer st0("foo:bar", ':');

	// precondition
	assertEqual( st0.fString, "foo:bar" );
	t_assert( st0.fDelimiter == ':' );

	String token;
	bool ret;

	// first round
	ret = st0.NextToken(token);
	assertEqual("foo", token);
	assertEqual(true, ret);

	// second round
	ret = st0.NextToken(token);
	assertEqual("bar", token);
	assertEqual(true, ret);

	// third round
	ret = st0.NextToken(token);
	assertEqual("bar", token);
	assertEqual(false, ret);

	st0.Reset();

	// first round
	ret = st0.NextToken(token);
	assertEqual("foo", token);
	assertEqual(true, ret);

	// second round
	ret = st0.NextToken(token);
	assertEqual("bar", token);
	assertEqual(true, ret);

	// third round
	ret = st0.NextToken(token);
	assertEqual("bar", token);
	assertEqual(false, ret);

}
Exemple #23
0
int main()
{
	ipp_message *msg;
	ipp_card *As, *Ad, *Ah;
	ipp_card *Ks, *Kd, *Kh, *Kc;
	ipp_card *Qs, *Qh, *Qc;
	ipp_card *Jh, *Jc, *Jd;
	guint8 *result;

	ipp_player *player1, *player2, *player3, *player4;
	ipp_table *table;
	int rc, i;

	ipp_init();

	table = ipp_new_table();
	player1 = ipp_new_player();
	player2 = ipp_new_player();
	player3 = ipp_new_player();
	player4 = ipp_new_player();

	assertNotNull("Table should not be null.", table);
	assertNotNull("Player 1 should not be null.", player1);
	assertNotNull("Player 2 should not be null.", player2);
	assertNotNull("Player 3 should not be null.", player3);
	assertNotNull("Player 4 should not be null.", player4);
	assertEqual("Table shouldn't have any players", table->nplayers, 0);

	rc = ipp_add_player(table, player1);
	assertNotEqual("Should have been able to add player", rc, -1);
	assertEqual("Should have one player", table->nplayers, 1);

	rc = ipp_add_player(table, player2);
	assertNotEqual("Should have been able to add player", rc, -1);
	assertEqual("Should have two players", table->nplayers, 2);

	rc = ipp_add_player(table, player3);
	assertNotEqual("Should have been able to add player", rc, -1);
	assertEqual("Should have three players", table->nplayers, 3);

	rc = ipp_add_player(table, player4);
	assertNotEqual("Should have been able to add player", rc, -1);
	assertEqual("Should have four players", table->nplayers, 4);

	Jh = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Jh);
	Jh->rank = JACK;
	Jh->suit = HEARTS;

	Jc = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Jc);
	Jc->rank = JACK;
	Jc->suit = CLUBS;

	Jd = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Jd);
	Jd->rank = JACK;
	Jd->suit = DIAMONDS;

	Qh = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Qh);
	Qh->rank = QUEEN;
	Qh->suit = HEARTS;

	Qc = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Qc);
	Qc->rank = QUEEN;
	Qc->suit = CLUBS;

	Qs = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Qs);
	Qs->rank = QUEEN;
	Qs->suit = SPADES;

	Kh = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Kh);
	Kh->rank = KING;
	Kh->suit = HEARTS;

	Kc = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Kc);
	Kc->rank = KING;
	Kc->suit = CLUBS;

	Ks = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Ks);
	Ks->rank = KING;
	Ks->suit = SPADES;

	Kd = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Kd);
	Kd->rank = KING;
	Kd->suit = DIAMONDS;

	Ah = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Ah);
	Ah->rank = ACE;
	Ah->suit = HEARTS;

	As = ipp_new_card();
	assertNotNull("ipp_new_card() failed", As);
	As->rank = ACE;
	As->suit = SPADES;

	Ad = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Ad);
	Ad->rank = ACE;
	Ad->suit = DIAMONDS;

	table->board[0] = Ad;
	table->board[1] = Ah;
	table->board[2] = Kd;
	table->board[3] = Kh;
	table->board[4] = Kc;
	table->players[0]->hole[0] = Qs;
	table->players[0]->hole[1] = Qh;
	table->players[1]->hole[0] = As;
	table->players[1]->hole[1] = Ks;
	table->players[2]->hole[0] = Jh;
	table->players[2]->hole[1] = Jd;
	table->players[3]->hole[0] = Qc;
	table->players[3]->hole[1] = Jc;

	table->stage = SHOWDOWN;

	for (i = 0; i < 4; i++) {
		msg = ipp_best_combination(table, i);
		assertNotNull("ipp_best_combination() should have return an answer", msg);

		printf("Player #%d Hand => '%s'\n", i, msg->payload);

		ipp_free_message(msg);
	}

	result = NULL;

	result = ipp_rank_players(table);
	assertNotNull("ipp_rank_players() should have return an answer.", result);

	for (i = 0; i < HOLDEM_PLAYERS_PER_TABLE; i++) {
		int playerid;

		playerid = result[i];

		if (table->players[playerid]) {
			msg = ipp_best_combination(table, playerid);
			assertNotNull("ipp_best_combination() should have return an answer", msg);

			printf("(%d) Player #%d Hand => '%s'\n", i, playerid, msg->payload);

			ipp_free_message(msg);
		}
	}

	/*
	   (0) Player #1 Hand => 'FOUROFAKIND K A'
	   (1) Player #0 Hand => 'FULLHOUSE K Q'
	   (2) Player #2 Hand => 'FULLHOUSE K J'
	   (3) Player #3 Hand => 'THREEOFAKIND K Q J'
	 */

	assertEqual("Player #1 should be 1st", result[0], 1);
	assertEqual("Player #0 should be 2nd", result[1], 0);
	assertEqual("Player #2 should be 3rd", result[2], 2);
	assertEqual("Player #3 should be 4th", result[3], 3);

	ipp_free_table(table);	/* will also free players */
	free(result);

	ipp_exit();
	return PASS;
}
void StringTokenizerTest::constrMethods1 ()
{
	String token;
	bool ret;

	StringTokenizer st("0123450678901230456078901230456709012", '1' );
	assertEqual( st.fString, "0123450678901230456078901230456709012" );
	t_assert( st.fDelimiter == '1' );

	ret = st.NextToken(token);
	assertEqual("0", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("2345067890", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("23045607890", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("2304567090", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("2", token);
	assertEqual(true, ret);

	ret = st.NextToken(token);
	assertEqual("2", token);
	assertEqual(false, ret);

	ret = st.NextToken(token);
	assertEqual("2", token);
	assertEqual(false, ret);
}
Exemple #25
0
int main()
{
	ipp_message *msg;
	ipp_card *Kh;
	ipp_card *Kc;
	ipp_card *Ad, *Kd;
	ipp_card *As, *Ks, *Qs, *Js, *Ts, *_7s, *_6s;
	ipp_card *hand[5];

	ipp_init();

	Kh = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Kh);
	Kh->rank = KING;
	Kh->suit = HEARTS;

	Kc = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Kc);
	Kc->rank = KING;
	Kc->suit = CLUBS;

	Ad = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Ad);
	Ad->rank = ACE;
	Ad->suit = DIAMONDS;

	Kd = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Kd);
	Kd->rank = KING;
	Kd->suit = DIAMONDS;

	As = ipp_new_card();
	assertNotNull("ipp_new_card() failed", As);
	As->rank = ACE;
	As->suit = SPADES;

	Ks = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Ks);
	Ks->rank = KING;
	Ks->suit = SPADES;

	Qs = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Qs);
	Qs->rank = QUEEN;
	Qs->suit = SPADES;

	Js = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Js);
	Js->rank = JACK;
	Js->suit = SPADES;

	Ts = ipp_new_card();
	assertNotNull("ipp_new_card() failed", Js);
	Ts->rank = TEN;
	Ts->suit = SPADES;

	_7s = ipp_new_card();
	assertNotNull("ipp_new_card() failed", _7s);
	_7s->rank = SEVEN;
	_7s->suit = SPADES;

	_6s = ipp_new_card();
	assertNotNull("ipp_new_card() failed", _6s);
	_6s->rank = SIX;
	_6s->suit = SPADES;

	hand[0] = As;
	hand[1] = Ks;
	hand[2] = Qs;
	hand[3] = Js;
	hand[4] = Ts;

	msg = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msg);
	assertStringEqual("Didn't detect proper hand.", "STRAIGHTFLUSH A", msg->payload);
	assertEqual("Didn't detect proper hand.", msg->type, MSG_STRAIGHTFLUSH);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msg->payload), MSG_STRAIGHTFLUSH);
	ipp_free_message(msg);

	hand[0] = As;
	hand[1] = Kd;
	hand[2] = Qs;
	hand[3] = Js;
	hand[4] = Ts;

	msg = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msg);
	assertStringEqual("Didn't detect proper hand.", "STRAIGHT A", msg->payload);
	assertEqual("Didn't detect proper hand.", msg->type, MSG_STRAIGHT);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msg->payload), MSG_STRAIGHT);
	ipp_free_message(msg);

	hand[0] = As;
	hand[1] = Ks;
	hand[2] = Qs;
	hand[3] = Js;
	hand[4] = _7s;

	msg = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msg);
	assertStringEqual("Didn't detect proper hand.", "FLUSH A K Q J 7", msg->payload);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msg->payload), MSG_FLUSH);
	assertEqual("Didn't detect proper hand.", msg->type, MSG_FLUSH);
	ipp_free_message(msg);

	hand[0] = As;
	hand[1] = Kd;
	hand[2] = Ks;
	hand[3] = Js;
	hand[4] = _7s;

	msg = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msg);
	assertStringEqual("Didn't detect proper hand.", "ONEPAIR K A J 7", msg->payload);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msg->payload), MSG_ONEPAIR);
	assertEqual("Didn't detect proper hand.", msg->type, MSG_ONEPAIR);
	ipp_free_message(msg);

	hand[0] = As;
	hand[1] = Ks;
	hand[2] = Ad;
	hand[3] = Kd;
	hand[4] = _7s;

	msg = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msg);
	assertStringEqual("Didn't detect proper hand.", "TWOPAIR A K 7", msg->payload);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msg->payload), MSG_TWOPAIR);
	assertEqual("Didn't detect proper hand.", msg->type, MSG_TWOPAIR);
	ipp_free_message(msg);

	hand[0] = As;
	hand[1] = Ks;
	hand[2] = Ad;
	hand[3] = Kd;
	hand[4] = Kc;

	msg = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msg);
	assertStringEqual("Didn't detect proper hand.", "FULLHOUSE K A", msg->payload);
	assertEqual("Didn't detect proper hand.", msg->type, MSG_FULLHOUSE);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msg->payload), MSG_FULLHOUSE);
	ipp_free_message(msg);

	hand[0] = As;
	hand[1] = Ks;
	hand[2] = Js;
	hand[3] = Kd;
	hand[4] = Kc;

	msg = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msg);
	assertStringEqual("Didn't detect proper hand.", "THREEOFAKIND K A J", msg->payload);
	assertEqual("Didn't detect proper hand.", msg->type, MSG_THREEOFAKIND);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msg->payload), MSG_THREEOFAKIND);
	ipp_free_message(msg);

	hand[0] = Kh;
	hand[1] = Ks;
	hand[2] = Js;
	hand[3] = Kd;
	hand[4] = Kc;

	msg = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msg);
	assertStringEqual("Didn't detect proper hand.", "FOUROFAKIND K J", msg->payload);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msg->payload), MSG_FOUROFAKIND);
	ipp_free_message(msg);

	hand[0] = As;
	hand[1] = Kd;
	hand[2] = Js;
	hand[3] = _7s;
	hand[4] = _6s;

	msg = ipp_eval(hand);
	assertNotNull("ipp_eval() returned null", msg);
	assertStringEqual("Didn't detect proper hand.", "HIGHCARD A K J 7 6", msg->payload);
	assertEqual("Didn't detect proper hand.", ipp_validate_unknown_msg(msg->payload), MSG_HIGHCARD);
	ipp_free_message(msg);

	ipp_free_card(_6s);
	ipp_free_card(_7s);
	ipp_free_card(Ts);
	ipp_free_card(Js);
	ipp_free_card(Qs);
	ipp_free_card(Ks);
	ipp_free_card(As);
	ipp_free_card(Kd);
	ipp_free_card(Ad);
	ipp_free_card(Kc);
	ipp_free_card(Kh);

	ipp_exit();

	return PASS;
}
Exemple #26
0
void plainFunction()
{
	assertEqual(callbackCount++, 0, "Calling back plain functions");
}
void test1()
{
    const char s[] = "/test\0\0\0,fiT\0\0\0\0\0\0\0\0\0\0\0A";
    char *buffer = NewMessageBuffer( s, sizeof(s)-1 );

    // test argument iterator interface
    bool unexpectedExceptionCaught = false;
    try{
        ReceivedMessage m( ReceivedPacket(buffer, sizeof(s)-1) );

        assertEqual( std::strcmp( m.AddressPattern(), "/test" ), 0 );
        assertEqual( std::strcmp( m.TypeTags(), "fiT" ), 0 );
        
        ReceivedMessage::const_iterator i = m.ArgumentsBegin();
        ++i;
        ++i;
        ++i;
        assertEqual( i, m.ArgumentsEnd() );

        i = m.ArgumentsBegin();
        float f = (i++)->AsFloat();
        (void)f;
        int n = (i++)->AsInt32();
        (void)n;
        bool b = (i++)->AsBool();
        (void)b;
        
        i = m.ArgumentsBegin();
        bool exceptionThrown = false;
        try{
            int n = (i++)->AsInt32();
            (void)n;
        }catch( Exception& ){
            exceptionThrown = true;
        }
        assertEqual( exceptionThrown, true );

    }catch( Exception& e ){
        std::cout << "unexpected exception: " << e.what() << "\n";
        unexpectedExceptionCaught = true;
    }
    assertEqual( unexpectedExceptionCaught, false );


    // test argument stream interface
    unexpectedExceptionCaught = false;
    try{
        ReceivedMessage m( ReceivedPacket(buffer, sizeof(s)-1) );
        ReceivedMessageArgumentStream args = m.ArgumentStream();
        assertEqual( args.Eos(), false );

        float f;
        int32 n;
        bool b;
        args >> f >> n >> b;

        (void) f;
        (void) n;
        (void) b;
        
        assertEqual( args.Eos(), true );

    }catch( Exception& e ){
        std::cout << "unexpected exception: " << e.what() << "\n";
        unexpectedExceptionCaught = true;
    }
    assertEqual( unexpectedExceptionCaught, false );
}
Exemple #28
0
	void operator()()
	{
		assertEqual(data, 42, "Calling back functors 1/3");
		assertEqual(callbackCount++, 1, "Calling back functors 2/3");
	}
Exemple #29
0
UBool NormalizerConformanceTest::checkNorm(UNormalizationMode mode, int32_t options,
                                           const Normalizer2 *norm2,
                                           const UnicodeString &s, const UnicodeString &exp,
                                           int32_t field) {
    const char *modeString = kModeStrings[mode];
    char msg[20];
    snprintf(msg, sizeof(msg), kMessages[mode], field);
    UnicodeString out;
    UErrorCode errorCode = U_ZERO_ERROR;
    Normalizer::normalize(s, mode, options, out, errorCode);
    if (U_FAILURE(errorCode)) {
        dataerrln("Error running normalize UNORM_NF%s: %s", modeString, u_errorName(errorCode));
        return FALSE;
    }
    if (!assertEqual(modeString, "", s, out, exp, msg)) {
        return FALSE;
    }

    iterativeNorm(s, mode, options, out, +1);
    if (!assertEqual(modeString, "(+1)", s, out, exp, msg)) {
        return FALSE;
    }

    iterativeNorm(s, mode, options, out, -1);
    if (!assertEqual(modeString, "(-1)", s, out, exp, msg)) {
        return FALSE;
    }

    if (norm2 == nullptr || options != 0) {
        return TRUE;
    }

    std::string s8;
    s.toUTF8String(s8);
    std::string exp8;
    exp.toUTF8String(exp8);
    std::string out8;
    Edits edits;
    Edits *editsPtr = (mode == UNORM_NFC || mode == UNORM_NFKC) ? &edits : nullptr;
    StringByteSink<std::string> sink(&out8, exp8.length());
    norm2->normalizeUTF8(0, s8, sink, editsPtr, errorCode);
    if (U_FAILURE(errorCode)) {
        errln("Normalizer2.%s.normalizeUTF8(%s) failed: %s",
              modeString, s8.c_str(), u_errorName(errorCode));
        return FALSE;
    }
    if (out8 != exp8) {
        errln("Normalizer2.%s.normalizeUTF8(%s)=%s != %s",
              modeString, s8.c_str(), out8.c_str(), exp8.c_str());
        return FALSE;
    }
    if (editsPtr == nullptr) {
        return TRUE;
    }

    // Do the Edits cover the entire input & output?
    UBool pass = TRUE;
    pass &= assertEquals("edits.hasChanges()", (UBool)(s8 != out8), edits.hasChanges());
    pass &= assertEquals("edits.lengthDelta()",
                         (int32_t)(out8.length() - s8.length()), edits.lengthDelta());
    Edits::Iterator iter = edits.getCoarseIterator();
    while (iter.next(errorCode)) {}
    pass &= assertEquals("edits source length", s8.length(), iter.sourceIndex());
    pass &= assertEquals("edits destination length", out8.length(), iter.destinationIndex());
    return pass;
}
Exemple #30
0
void CollationIteratorTest::TestSetText(/* char* par */)
{
    CollationElementIterator *iter1 = en_us->createCollationElementIterator(test1);
    CollationElementIterator *iter2 = en_us->createCollationElementIterator(test2);
    UErrorCode status = U_ZERO_ERROR;

    // Run through the second iterator just to exercise it
    int32_t c = iter2->next(status);
    int32_t i = 0;

    while ( ++i < 10 && c != CollationElementIterator::NULLORDER)
    {
        if (U_FAILURE(status))
        {
            errln("iter2->next() returned an error.");
            delete iter2;
            delete iter1;
        }

        c = iter2->next(status);
    }

    // Now set it to point to the same string as the first iterator
    iter2->setText(test1, status);

    if (U_FAILURE(status))
    {
        errln("call to iter2->setText(test1) failed.");
    }
    else
    {
        assertEqual(*iter1, *iter2);
    }
    iter1->reset();
    //now use the overloaded setText(ChracterIterator&, UErrorCode) function to set the text
    CharacterIterator* chariter = new StringCharacterIterator(test1);
    iter2->setText(*chariter, status);
    if (U_FAILURE(status))
    {
        errln("call to iter2->setText(chariter(test1)) failed.");
    }
    else
    {
        assertEqual(*iter1, *iter2);
    }
   
    // test for an empty string
    UnicodeString empty("");
    iter1->setText(empty, status);
    if (U_FAILURE(status) 
        || iter1->next(status) != (int32_t)UCOL_NULLORDER) {
        errln("Empty string should have no CEs.");
    }
    ((StringCharacterIterator *)chariter)->setText(empty);
    iter1->setText(*chariter, status);
    if (U_FAILURE(status) 
        || iter1->next(status) != (int32_t)UCOL_NULLORDER) {
        errln("Empty string should have no CEs.");
    }
    delete chariter;
    delete iter2;
    delete iter1;
}