sprintf(err_buf, "fi_addr[%d] = FI_ADDR_NOTAVAIL", i);
goto fail;
}
}
}
testret = PASS;
fail:
if (av != NULL) {
fi_close(&av->fid);
}
return testret;
}
struct test_entry test_array_good[] = {
TEST_ENTRY(av_open_close),
TEST_ENTRY(av_good_sync),
TEST_ENTRY(av_good_vector_async),
TEST_ENTRY(av_zero_async),
TEST_ENTRY(av_good_2vector_async),
{ NULL, "" }
};
struct test_entry test_array_bad[] = {
TEST_ENTRY(av_bad_sync),
TEST_ENTRY(av_goodbad_vector_sync),
TEST_ENTRY(av_goodbad_vector_async),
TEST_ENTRY(av_goodbad_2vector_async),
{ NULL, "" }
};
int main()
{
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTBase64", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
/*
* Series of simple tests.
*/
static const struct
{
const char *pszText;
size_t cchText;
const char *pszEnc;
size_t cchEnc;
} g_aTests[] =
{
#define TEST_ENTRY(szText, szEnc) { szText, sizeof(szText) - 1, szEnc, sizeof(szEnc) - 1 }
TEST_ENTRY("Hey", "SGV5"),
TEST_ENTRY("Base64", "QmFzZTY0"),
TEST_ENTRY("Call me Ishmael.", "Q2FsbCBtZSBJc2htYWVsLg=="),
TEST_ENTRY(
"Man is distinguished, not only by his reason, but by this singular passion "
"from other animals, which is a lust of the mind, that by a perseverance of "
"delight in the continued and indefatigable generation of knowledge, exceeds "
"the short vehemence of any carnal pleasure." /* Thomas Hobbes's Leviathan */,
"TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1" MY_NL
"dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3" MY_NL
"aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFu" MY_NL
"Y2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxl" MY_NL
"IGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhl" MY_NL
"bWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4="
)
#undef TEST_ENTRY
};
for (unsigned i = 0; i < RT_ELEMENTS(g_aTests); i++)
{
RTTestSubF(hTest, "Test 1-%u", i);
tstBase64(g_aTests[i].pszText, g_aTests[i].cchText,
g_aTests[i].pszEnc, g_aTests[i].cchEnc,
1 /* fTextData */, 1 /* fNormalEnc */);
}
/*
* Try with some more junk in the encoding and different line length.
*/
RTTestSub(hTest, "Test 2");
static const char s_szText2[] =
"Man is distinguished, not only by his reason, but by this singular passion "
"from other animals, which is a lust of the mind, that by a perseverance of "
"delight in the continued and indefatigable generation of knowledge, exceeds "
"the short vehemence of any carnal pleasure."; /* Thomas Hobbes's Leviathan */
static const char s_szEnc2[] =
" TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz\r\n"
" IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg\n\r\t\t\t\v"
"dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu\n"
"\tdWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRo\n\r"
" ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=\n \n \r \n \t";
tstBase64(s_szText2, sizeof(s_szText2) - 1,
s_szEnc2, sizeof(s_szEnc2) - 1,
1 /* fTextData */, 0 /* fNormalEnc */);
/*
* Test for buffer overruns.
*/
RTTestSubF(hTest, "Test 3");
static uint8_t s_abData4[32768];
for (size_t i = 0; i < sizeof(s_abData4); i++)
s_abData4[i] = i % 256;
for (size_t cbSrc = 1; cbSrc <= sizeof(s_abData4); cbSrc++)
{
char szEnc[49152];
memset(szEnc, '\0', sizeof(szEnc));
size_t cchEnc = RTBase64EncodedLength(cbSrc);
if (cchEnc >= sizeof(szEnc))
RTTestIFailed("RTBase64EncodedLength(%zu) returned %zu bytes, too big\n", cbSrc, cchEnc);
size_t cchOut = 0;
rc = RTBase64Encode(s_abData4, cbSrc, szEnc, cchEnc, &cchOut);
if (rc != VERR_BUFFER_OVERFLOW)
RTTestIFailed("RTBase64Encode(,%zu,) has no buffer overflow with too small buffer -> %Rrc\n", cbSrc, rc);
rc = RTBase64Encode(s_abData4, cbSrc, szEnc, cchEnc + 1, &cchOut);
if (RT_FAILURE(rc))
RTTestIFailed("RTBase64Encode -> %Rrc\n", rc);
if (cchOut != cchEnc)
RTTestIFailed("RTBase64EncodedLength(%zu) returned %zu bytes, expected %zu.\n",
cbSrc, cchEnc, cchOut);
if (szEnc[cchOut + 1] != '\0')
RTTestIFailed("RTBase64Encode(,%zu,) returned string which is not zero terminated\n", cbSrc);
if (strlen(szEnc) != cchOut)
RTTestIFailed("RTBase64Encode(,%zu,) returned incorrect string, length %lu\n", cbSrc, cchOut);
}
/*
* Finally, a more extensive test.
*/
RTTestSub(hTest, "Test 4");
static uint8_t s_abData3[12*256];
for (unsigned i = 0; i < 256; i++)
{
unsigned j = i*12;
s_abData3[j + 0] = i; /* */
s_abData3[j + 1] = 0xff;
s_abData3[j + 2] = i;
s_abData3[j + 3] = 0xff; /* */
s_abData3[j + 4] = i;
s_abData3[j + 5] = 0xff;
s_abData3[j + 6] = i; /* */
s_abData3[j + 7] = 0x00;
s_abData3[j + 8] = i;
s_abData3[j + 9] = 0x00; /* */
s_abData3[j + 10]= i;
s_abData3[j + 11]= 0x00;
}
static const char s_szEnc3[] =
"AP8A/wD/AAAAAAAAAf8B/wH/AQABAAEAAv8C/wL/AgACAAIAA/8D/wP/AwADAAMA" MY_NL
"BP8E/wT/BAAEAAQABf8F/wX/BQAFAAUABv8G/wb/BgAGAAYAB/8H/wf/BwAHAAcA" MY_NL
"CP8I/wj/CAAIAAgACf8J/wn/CQAJAAkACv8K/wr/CgAKAAoAC/8L/wv/CwALAAsA" MY_NL
"DP8M/wz/DAAMAAwADf8N/w3/DQANAA0ADv8O/w7/DgAOAA4AD/8P/w//DwAPAA8A" MY_NL
"EP8Q/xD/EAAQABAAEf8R/xH/EQARABEAEv8S/xL/EgASABIAE/8T/xP/EwATABMA" MY_NL
"FP8U/xT/FAAUABQAFf8V/xX/FQAVABUAFv8W/xb/FgAWABYAF/8X/xf/FwAXABcA" MY_NL
"GP8Y/xj/GAAYABgAGf8Z/xn/GQAZABkAGv8a/xr/GgAaABoAG/8b/xv/GwAbABsA" MY_NL
"HP8c/xz/HAAcABwAHf8d/x3/HQAdAB0AHv8e/x7/HgAeAB4AH/8f/x//HwAfAB8A" MY_NL
"IP8g/yD/IAAgACAAIf8h/yH/IQAhACEAIv8i/yL/IgAiACIAI/8j/yP/IwAjACMA" MY_NL
"JP8k/yT/JAAkACQAJf8l/yX/JQAlACUAJv8m/yb/JgAmACYAJ/8n/yf/JwAnACcA" MY_NL
"KP8o/yj/KAAoACgAKf8p/yn/KQApACkAKv8q/yr/KgAqACoAK/8r/yv/KwArACsA" MY_NL
"LP8s/yz/LAAsACwALf8t/y3/LQAtAC0ALv8u/y7/LgAuAC4AL/8v/y//LwAvAC8A" MY_NL
"MP8w/zD/MAAwADAAMf8x/zH/MQAxADEAMv8y/zL/MgAyADIAM/8z/zP/MwAzADMA" MY_NL
"NP80/zT/NAA0ADQANf81/zX/NQA1ADUANv82/zb/NgA2ADYAN/83/zf/NwA3ADcA" MY_NL
"OP84/zj/OAA4ADgAOf85/zn/OQA5ADkAOv86/zr/OgA6ADoAO/87/zv/OwA7ADsA" MY_NL
"PP88/zz/PAA8ADwAPf89/z3/PQA9AD0APv8+/z7/PgA+AD4AP/8//z//PwA/AD8A" MY_NL
"QP9A/0D/QABAAEAAQf9B/0H/QQBBAEEAQv9C/0L/QgBCAEIAQ/9D/0P/QwBDAEMA" MY_NL
"RP9E/0T/RABEAEQARf9F/0X/RQBFAEUARv9G/0b/RgBGAEYAR/9H/0f/RwBHAEcA" MY_NL
"SP9I/0j/SABIAEgASf9J/0n/SQBJAEkASv9K/0r/SgBKAEoAS/9L/0v/SwBLAEsA" MY_NL
"TP9M/0z/TABMAEwATf9N/03/TQBNAE0ATv9O/07/TgBOAE4AT/9P/0//TwBPAE8A" MY_NL
"UP9Q/1D/UABQAFAAUf9R/1H/UQBRAFEAUv9S/1L/UgBSAFIAU/9T/1P/UwBTAFMA" MY_NL
"VP9U/1T/VABUAFQAVf9V/1X/VQBVAFUAVv9W/1b/VgBWAFYAV/9X/1f/VwBXAFcA" MY_NL
"WP9Y/1j/WABYAFgAWf9Z/1n/WQBZAFkAWv9a/1r/WgBaAFoAW/9b/1v/WwBbAFsA" MY_NL
"XP9c/1z/XABcAFwAXf9d/13/XQBdAF0AXv9e/17/XgBeAF4AX/9f/1//XwBfAF8A" MY_NL
"YP9g/2D/YABgAGAAYf9h/2H/YQBhAGEAYv9i/2L/YgBiAGIAY/9j/2P/YwBjAGMA" MY_NL
"ZP9k/2T/ZABkAGQAZf9l/2X/ZQBlAGUAZv9m/2b/ZgBmAGYAZ/9n/2f/ZwBnAGcA" MY_NL
"aP9o/2j/aABoAGgAaf9p/2n/aQBpAGkAav9q/2r/agBqAGoAa/9r/2v/awBrAGsA" MY_NL
"bP9s/2z/bABsAGwAbf9t/23/bQBtAG0Abv9u/27/bgBuAG4Ab/9v/2//bwBvAG8A" MY_NL
"cP9w/3D/cABwAHAAcf9x/3H/cQBxAHEAcv9y/3L/cgByAHIAc/9z/3P/cwBzAHMA" MY_NL
"dP90/3T/dAB0AHQAdf91/3X/dQB1AHUAdv92/3b/dgB2AHYAd/93/3f/dwB3AHcA" MY_NL
"eP94/3j/eAB4AHgAef95/3n/eQB5AHkAev96/3r/egB6AHoAe/97/3v/ewB7AHsA" MY_NL
"fP98/3z/fAB8AHwAff99/33/fQB9AH0Afv9+/37/fgB+AH4Af/9//3//fwB/AH8A" MY_NL
"gP+A/4D/gACAAIAAgf+B/4H/gQCBAIEAgv+C/4L/ggCCAIIAg/+D/4P/gwCDAIMA" MY_NL
"hP+E/4T/hACEAIQAhf+F/4X/hQCFAIUAhv+G/4b/hgCGAIYAh/+H/4f/hwCHAIcA" MY_NL
"iP+I/4j/iACIAIgAif+J/4n/iQCJAIkAiv+K/4r/igCKAIoAi/+L/4v/iwCLAIsA" MY_NL
"jP+M/4z/jACMAIwAjf+N/43/jQCNAI0Ajv+O/47/jgCOAI4Aj/+P/4//jwCPAI8A" MY_NL
"kP+Q/5D/kACQAJAAkf+R/5H/kQCRAJEAkv+S/5L/kgCSAJIAk/+T/5P/kwCTAJMA" MY_NL
"lP+U/5T/lACUAJQAlf+V/5X/lQCVAJUAlv+W/5b/lgCWAJYAl/+X/5f/lwCXAJcA" MY_NL
"mP+Y/5j/mACYAJgAmf+Z/5n/mQCZAJkAmv+a/5r/mgCaAJoAm/+b/5v/mwCbAJsA" MY_NL
"nP+c/5z/nACcAJwAnf+d/53/nQCdAJ0Anv+e/57/ngCeAJ4An/+f/5//nwCfAJ8A" MY_NL
"oP+g/6D/oACgAKAAof+h/6H/oQChAKEAov+i/6L/ogCiAKIAo/+j/6P/owCjAKMA" MY_NL
"pP+k/6T/pACkAKQApf+l/6X/pQClAKUApv+m/6b/pgCmAKYAp/+n/6f/pwCnAKcA" MY_NL
"qP+o/6j/qACoAKgAqf+p/6n/qQCpAKkAqv+q/6r/qgCqAKoAq/+r/6v/qwCrAKsA" MY_NL
"rP+s/6z/rACsAKwArf+t/63/rQCtAK0Arv+u/67/rgCuAK4Ar/+v/6//rwCvAK8A" MY_NL
"sP+w/7D/sACwALAAsf+x/7H/sQCxALEAsv+y/7L/sgCyALIAs/+z/7P/swCzALMA" MY_NL
"tP+0/7T/tAC0ALQAtf+1/7X/tQC1ALUAtv+2/7b/tgC2ALYAt/+3/7f/twC3ALcA" MY_NL
"uP+4/7j/uAC4ALgAuf+5/7n/uQC5ALkAuv+6/7r/ugC6ALoAu/+7/7v/uwC7ALsA" MY_NL
"vP+8/7z/vAC8ALwAvf+9/73/vQC9AL0Avv++/77/vgC+AL4Av/+//7//vwC/AL8A" MY_NL
"wP/A/8D/wADAAMAAwf/B/8H/wQDBAMEAwv/C/8L/wgDCAMIAw//D/8P/wwDDAMMA" MY_NL
"xP/E/8T/xADEAMQAxf/F/8X/xQDFAMUAxv/G/8b/xgDGAMYAx//H/8f/xwDHAMcA" MY_NL
"yP/I/8j/yADIAMgAyf/J/8n/yQDJAMkAyv/K/8r/ygDKAMoAy//L/8v/ywDLAMsA" MY_NL
"zP/M/8z/zADMAMwAzf/N/83/zQDNAM0Azv/O/87/zgDOAM4Az//P/8//zwDPAM8A" MY_NL
"0P/Q/9D/0ADQANAA0f/R/9H/0QDRANEA0v/S/9L/0gDSANIA0//T/9P/0wDTANMA" MY_NL
"1P/U/9T/1ADUANQA1f/V/9X/1QDVANUA1v/W/9b/1gDWANYA1//X/9f/1wDXANcA" MY_NL
"2P/Y/9j/2ADYANgA2f/Z/9n/2QDZANkA2v/a/9r/2gDaANoA2//b/9v/2wDbANsA" MY_NL
"3P/c/9z/3ADcANwA3f/d/93/3QDdAN0A3v/e/97/3gDeAN4A3//f/9//3wDfAN8A" MY_NL
"4P/g/+D/4ADgAOAA4f/h/+H/4QDhAOEA4v/i/+L/4gDiAOIA4//j/+P/4wDjAOMA" MY_NL
"5P/k/+T/5ADkAOQA5f/l/+X/5QDlAOUA5v/m/+b/5gDmAOYA5//n/+f/5wDnAOcA" MY_NL
"6P/o/+j/6ADoAOgA6f/p/+n/6QDpAOkA6v/q/+r/6gDqAOoA6//r/+v/6wDrAOsA" MY_NL
"7P/s/+z/7ADsAOwA7f/t/+3/7QDtAO0A7v/u/+7/7gDuAO4A7//v/+//7wDvAO8A" MY_NL
"8P/w//D/8ADwAPAA8f/x//H/8QDxAPEA8v/y//L/8gDyAPIA8//z//P/8wDzAPMA" MY_NL
"9P/0//T/9AD0APQA9f/1//X/9QD1APUA9v/2//b/9gD2APYA9//3//f/9wD3APcA" MY_NL
"+P/4//j/+AD4APgA+f/5//n/+QD5APkA+v/6//r/+gD6APoA+//7//v/+wD7APsA" MY_NL
"/P/8//z//AD8APwA/f/9//3//QD9AP0A/v/+//7//gD+AP4A/////////wD/AP8A";
tstBase64(s_abData3, sizeof(s_abData3),
s_szEnc3, sizeof(s_szEnc3) - 1,
0 /* fTextData */, 0 /* fNormalEnc */);
/*
* Summary.
*/
return RTTestSummaryAndDestroy(hTest);
}
ret = fi_close(&mr->fid);
if (ret) {
FT_UNIT_STRERR(err_buf, "fi_close failed", ret);
goto free;
}
}
testret = PASS;
free:
free(iov);
out:
return TEST_RET_VAL(ret, testret);
}
struct test_entry test_array[] = {
TEST_ENTRY(mr_reg, "Test fi_mr_reg across different access combinations"),
TEST_ENTRY(mr_regv, "Test fi_mr_regv across various buffer sizes"),
TEST_ENTRY(mr_regattr, "Test fi_mr_regattr across various buffer sizes"),
{ NULL, "" }
};
static void usage(void)
{
ft_unit_usage("mr_test", "Unit test for Memory Region (MR)");
}
int main(int argc, char **argv)
{
int op, ret;
int failed = 0;
}
/* TODO: once fi_tx_attr's size field meaning has been fixed to refer to
* queue depth instead of number of bytes, we can do a little basic
* sanity checking here */
testret = PASS;
fail:
ret = teardown_ep_fixture(ep);
if (ret != 0)
testret = FAIL;
return testret;
}
struct test_entry test_rx_size_left[] = {
TEST_ENTRY(rx_size_left_err),
TEST_ENTRY(rx_size_left),
{ NULL, "" }
};
struct test_entry test_tx_size_left[] = {
TEST_ENTRY(tx_size_left),
{ NULL, "" }
};
int run_test_set(void)
{
int failed;
failed = 0;
failed += run_tests(test_rx_size_left, err_buf);
if (ret != 0) {
sprintf(err_buf, "close(cq) = %d, %s", ret, fi_strerror(-ret));
goto fail;
}
cq = NULL;
}
pass:
testret = PASS;
fail:
cq = NULL;
return TEST_RET_VAL(ret, testret);
}
struct test_entry test_array[] = {
TEST_ENTRY(cq_open_close_sizes, "Test open and close of CQ for various sizes"),
TEST_ENTRY(cq_open_close_simultaneous, "Test opening several CQs at a time"),
{ NULL, "" }
};
static void usage(void)
{
ft_unit_usage("cq_test", "Unit test for Completion Queue (CQ)");
}
int main(int argc, char **argv)
{
int op, ret;
int failed;
hints = fi_allocinfo();
#include "bi_list_test.h"
#include "bi_list.h"
#include "bi_element.h"
#include "test_macros.h"
CU_TestInfo bi_list_tests[] = {
TEST_ENTRY(bi_list_test_push_back_to_empty),
TEST_ENTRY(bi_list_test_push_back_next),
TEST_ENTRY(bi_list_test_pop_back_empty),
TEST_ENTRY(bi_list_test_pop_back_last),
TEST_ENTRY(bi_list_test_pop_back_tail),
TEST_ENTRY(bi_list_test_back_empty),
TEST_ENTRY(bi_list_test_back),
TEST_ENTRY(bi_list_test_push_front_to_empty),
TEST_ENTRY(bi_list_test_push_front_next),
TEST_ENTRY(bi_list_test_pop_front_empty),
TEST_ENTRY(bi_list_test_pop_front_last),
TEST_ENTRY(bi_list_test_pop_front_head),
TEST_ENTRY(bi_list_test_front_empty),
TEST_ENTRY(bi_list_test_front),
TEST_ENTRY(bi_list_test_size_empty),
TEST_ENTRY(bi_list_test_size),
TEST_ENTRY(bi_list_test_insert_tail),
TEST_ENTRY(bi_list_test_insert),
TEST_ENTRY(bi_list_test_remove_last),
TEST_ENTRY(bi_list_test_remove_head),
TEST_ENTRY(bi_list_test_remove_tail),
TEST_ENTRY(bi_list_test_remove),
CU_TEST_INFO_NULL };
int bi_list_test_suite_init(void)
goto fail;
}
if (entry.context != eq) {
sprintf(err_buf, "fi_eq_sread: context mismatch: %p should be %p\n",
entry.context, eq);
goto fail;
}
testret = PASS;
fail:
FT_CLOSE_FID(eq);
return TEST_RET_VAL(ret, testret);
}
struct test_entry test_array[] = {
TEST_ENTRY(eq_open_close, "Test open and close of EQ for various sizes"),
TEST_ENTRY(eq_write_read_self, "Test writing and reading to EQ"),
TEST_ENTRY(eq_write_overflow, "Test writing # of entries that exceed EQ size"),
TEST_ENTRY(eq_wait_fd_poll, "Test polling on fd extracted from EQ"),
TEST_ENTRY(eq_wait_fd_sread, "Test EQ sread"),
TEST_ENTRY(eq_wait_read_peek, "Test EQ read with FI_PEEK"),
TEST_ENTRY(eq_wait_sread_peek, "Test EQ sread with FI_PEEK"),
{ NULL, "" }
};
static void usage(void)
{
ft_unit_usage("eq_test", "Unit test for Event Queue (EQ)");
}
int main(int argc, char **argv)
ret = fi_close(&(cntrs[i])->fid);
if (ret) {
FT_PRINTERR("fi_cntr_close", ret);
break;
}
}
if (i < cntr_cnt)
testret = FAIL;
free(cntrs);
return TEST_RET_VAL(ret, testret);
}
struct test_entry test_array[] = {
TEST_ENTRY(cntr_loop, "Test counter open/set/read/close operations"),
{ NULL, "" }
};
static void usage(void)
{
ft_unit_usage("cntr_test", "Unit test for counter (cntr)");
}
int main(int argc, char **argv)
{
int op, ret;
int failed = 0;
hints = fi_allocinfo();
if (!hints)
{cubics[18], 4, 0.999996241, 0, {0, 0}},
{lines[11], 2, 0.888889581, 0, {0, 0}},
{cubics[18], 4, 0.999996241, 1, {0, 0}},
};
struct SortSetTests {
const char* name;
const SortSet* set;
size_t count;
SkPoint startPt;
};
#define TEST_ENTRY(name) #name, name, SK_ARRAY_COUNT(name)
static const SortSetTests tests[] = {
{ TEST_ENTRY(set17), {0, 0}},
{ TEST_ENTRY(set16), {130.090179f,11417.5957f} },
// { TEST_ENTRY(set15), {0, 0}},
{ TEST_ENTRY(set14), {0, 0}},
// { TEST_ENTRY(set13), {0, 0}},
{ TEST_ENTRY(set12), {0, 0}},
{ TEST_ENTRY(set11), {0, 0}},
{ TEST_ENTRY(set10), {0, 0}},
{ TEST_ENTRY(set9), {0, 0}},
{ TEST_ENTRY(set6a), {3.55555558f,2.77777767f} },
{ TEST_ENTRY(set8a), {1.5f,1} },
{ TEST_ENTRY(set8), {0, 0}},
{ TEST_ENTRY(set7), {0, 0}},
{ TEST_ENTRY(set6a), {3.55555558f,2.77777767f} },
{ TEST_ENTRY(set6), {0, 0}},
{ TEST_ENTRY(set5a), {306,596} },
