static void check_icu_sortmap(void)
{
/* successful tests */
size_t en_1_len = 6;
const char *en_1_src[6] = {"z", "K", "a", "A", "Z", "k"};
const char *en_1_cck[6] = {"a", "A", "k", "K", "z", "Z"};
YAZ_CHECK(test_icu_sortmap("en", en_1_len, en_1_src, en_1_cck));
YAZ_CHECK(test_icu_sortmap("en_AU", en_1_len, en_1_src, en_1_cck));
YAZ_CHECK(test_icu_sortmap("en_CA", en_1_len, en_1_src, en_1_cck));
YAZ_CHECK(test_icu_sortmap("en_GB", en_1_len, en_1_src, en_1_cck));
YAZ_CHECK(test_icu_sortmap("en_US", en_1_len, en_1_src, en_1_cck));
/* successful tests */
{
size_t da_1_len = 6;
const char *da_1_src[6] = {"z", "å", "o", "æ", "a", "ø"};
const char *da_1_cck[6] = {"a", "o", "z", "æ", "ø", "å"};
YAZ_CHECK(test_icu_sortmap("da", da_1_len, da_1_src, da_1_cck));
YAZ_CHECK(test_icu_sortmap("da_DK", da_1_len, da_1_src, da_1_cck));
}
/* successful tests */
{
size_t de_1_len = 9;
const char *de_1_src[9] = {"u", "ä", "o", "t", "s", "ß", "ü", "ö", "a"};
const char *de_1_cck[9] = {"a","ä", "o", "ö", "s", "ß", "t", "u", "ü"};
YAZ_CHECK(test_icu_sortmap("de", de_1_len, de_1_src, de_1_cck));
YAZ_CHECK(test_icu_sortmap("de_AT", de_1_len, de_1_src, de_1_cck));
YAZ_CHECK(test_icu_sortmap("de_DE", de_1_len, de_1_src, de_1_cck));
}
}
static void tst_srw(void)
{
const char *charset = 0;
char *content_buf = 0;
int content_len;
int ret;
ODR o = odr_createmem(ODR_ENCODE);
Z_SOAP_Handler h[2] = {
{"http://www.loc.gov/zing/srw/", 0, (Z_SOAP_fun) yaz_srw_codec},
{0, 0, 0}
};
Z_SRW_PDU *sr = yaz_srw_get(o, Z_SRW_searchRetrieve_request);
Z_SOAP *p = (Z_SOAP *) odr_malloc(o, sizeof(*p));
YAZ_CHECK(o);
YAZ_CHECK(sr);
YAZ_CHECK(p);
#if 0
sr->u.request->query = "jordb" "\xe6" "r";
#else
sr->u.request->query = "jordbaer";
#endif
p->which = Z_SOAP_generic;
p->u.generic = (Z_SOAP_Generic *) odr_malloc(o, sizeof(*p->u.generic));
p->u.generic->no = 0;
p->u.generic->ns = 0;
p->u.generic->p = sr;
p->ns = "http://schemas.xmlsoap.org/soap/envelope/";
ret = z_soap_codec_enc(o, &p, &content_buf, &content_len, h, charset);
odr_destroy(o);
YAZ_CHECK(ret == 0); /* codec failed ? */
}
static void tst_convert2(void)
{
yaz_record_conv_t p = 0;
const char *marcxml_rec =
"<record xmlns=\"http://www.loc.gov/MARC21/slim\">\n"
" <leader>00080nam a22000498a 4500</leader>\n"
" <controlfield tag=\"001\"> 11224466 </controlfield>\n"
" <datafield tag=\"010\" ind1=\" \" ind2=\" \">\n"
" <subfield code=\"a\">københavn</subfield>\n"
" </datafield>\n"
"</record>\n";
const char *iso2709_rec =
"\x30\x30\x30\x37\x37\x6E\x61\x6D\x20\x61\x32\x32\x30\x30\x30\x34"
"\x39\x38\x61\x20\x34\x35\x30\x30\x30\x30\x31\x30\x30\x31\x33\x30"
"\x30\x30\x30\x30\x30\x31\x30\x30\x30\x31\x34\x30\x30\x30\x31\x33"
"\x1E\x20\x20\x20\x31\x31\x32\x32\x34\x34\x36\x36\x20\x1E\x20\x20"
"\x1F\x61\x6b\xb2\x62\x65\x6e\x68\x61\x76\x6e\x1E\x1D";
YAZ_CHECK(conv_configure_test("<backend>"
"<marc"
" inputcharset=\"utf-8\""
" outputcharset=\"marc-8\""
" inputformat=\"xml\""
" outputformat=\"marc\""
"/>"
"</backend>",
0, &p));
YAZ_CHECK(conv_convert_test_iter(p, marcxml_rec, iso2709_rec, 100));
yaz_record_conv_destroy(p);
}
/** \brief build a 100 level query */
void test1(void)
{
ODR odr = odr_createmem(ODR_ENCODE);
YAZ_PQF_Parser parser = yaz_pqf_create();
Z_RPNQuery *rpn_query;
char qstr[10000];
int i;
int ret;
YAZ_CHECK(odr);
YAZ_CHECK(parser);
*qstr = '\0';
for (i = 0; i<100; i++)
strcat(qstr, "@and 1 ");
strcat(qstr, "1");
rpn_query = yaz_pqf_parse (parser, odr, qstr);
YAZ_CHECK(rpn_query);
ret = z_RPNQuery(odr, &rpn_query, 0, 0);
YAZ_CHECK(ret);
yaz_pqf_destroy(parser);
odr_destroy(odr);
}
void tst(void)
{
#if YAZ_HAVE_XML2
xmlChar *buf_out;
int len_out;
xmlDocPtr doc;
xmlNodePtr top;
#if 0
const char *val = "jordb" "\xe6" "r"; /* makes xmlDocDumpMemory hang .. */
#else
const char *val = "jordbaer"; /* OK */
#endif
doc = xmlNewDoc(BAD_CAST "1.0");
YAZ_CHECK(doc);
top = xmlNewNode(0, BAD_CAST "top");
YAZ_CHECK(top);
xmlNewTextChild(top, 0, BAD_CAST "sub", BAD_CAST val);
xmlDocSetRootElement(doc, top);
xmlDocDumpMemory(doc, &buf_out, &len_out);
#if 0
printf("%*s", len_out, buf_out);
#endif
/* YAZ_HAVE_XML2 */
#endif
}
static void check_icu_chain(void)
{
const char *en_str
= "O Romeo, Romeo! wherefore art thou\t Romeo?";
UErrorCode status = U_ZERO_ERROR;
struct icu_chain *chain = 0;
const char *xml_str = "<icu locale=\"en\">"
"<transform rule=\"[:Control:] Any-Remove\"/>"
"<tokenize rule=\"l\"/>"
"<transform rule=\"[[:WhiteSpace:][:Punctuation:]] Remove\"/>"
"<display/>"
"<casemap rule=\"l\"/>"
"</icu>";
xmlDoc *doc = xmlParseMemory(xml_str, strlen(xml_str));
xmlNode *xml_node = xmlDocGetRootElement(doc);
YAZ_CHECK(xml_node);
chain = icu_chain_xml_config(xml_node, 0, &status);
xmlFreeDoc(doc);
YAZ_CHECK(chain);
if (!chain)
return;
YAZ_CHECK(icu_chain_assign_cstr(chain, en_str, &status));
while (icu_chain_next_token(chain, &status))
{
yaz_log(YLOG_LOG, "%d '%s' '%s'",
icu_chain_token_number(chain),
icu_chain_token_norm(chain),
icu_chain_token_display(chain));
}
YAZ_CHECK_EQ(icu_chain_token_number(chain), 7);
YAZ_CHECK(icu_chain_assign_cstr(chain, "what is this?", &status));
while (icu_chain_next_token(chain, &status))
{
yaz_log(YLOG_LOG, "%d '%s' '%s'",
icu_chain_token_number(chain),
icu_chain_token_norm(chain),
icu_chain_token_display(chain));
}
YAZ_CHECK_EQ(icu_chain_token_number(chain), 3);
icu_chain_destroy(chain);
}
int main(int argc, char **argv)
{
YAZ_CHECK_INIT(argc, argv);
YAZ_CHECK_LOG();
#if YAZ_HAVE_ICU
check_icu_casemap();
check_icu_sortmap();
check_icu_normalizer();
check_icu_tokenizer();
check_icu_chain();
check_chain_empty_token();
check_chain_empty_chain();
check_icu_iter1();
check_icu_iter2();
check_icu_iter3();
check_icu_iter4();
check_bug_1140();
check_norm();
u_cleanup();
#else /* YAZ_HAVE_ICU */
yaz_log(YLOG_LOG, "ICU unit tests omitted");
YAZ_CHECK(0 == 0);
#endif /* YAZ_HAVE_ICU */
YAZ_CHECK_TERM;
}
static void tst_configure(void)
{
YAZ_CHECK(conv_configure_test("<bad", "xmlParseMemory", 0));
YAZ_CHECK(conv_configure_test("<backend syntax='usmarc' name='F'>"
"<bad/></backend>",
"Element <backend>: "
"unsupported element <bad>", 0));
#if YAZ_HAVE_XSLT
YAZ_CHECK(conv_configure_test("<backend syntax='usmarc' name='F'>"
"<xslt stylesheet=\"test_record_conv.xsl\"/>"
"<marc"
" inputcharset=\"marc-8\""
" outputcharset=\"marc-8\""
"/>"
"</backend>",
"Element <marc>: attribute 'inputformat' "
"required", 0));
YAZ_CHECK(conv_configure_test("<backend syntax='usmarc' name='F'>"
"<xslt/>"
"</backend>",
"Element <xslt>: attribute 'stylesheet' "
"expected", 0));
#endif
YAZ_CHECK(conv_configure_test("<backend syntax='usmarc' name='F'>"
"<marc"
" inputcharset=\"utf-8\""
" outputcharset=\"marc-8\""
" inputformat=\"xml\""
" outputformat=\"marc\""
"/>"
"<xslt stylesheet=\"test_record_conv.xsl\"/>"
"</backend>",
#if YAZ_HAVE_XSLT
0
#else
"Element <backend>: unsupported element <xslt>"
#endif
, 0));
}
static void check_icu_normalizer(void)
{
YAZ_CHECK(test_icu_normalizer("[:Punctuation:] Any-Remove",
"Don't shoot!",
"Dont shoot"));
YAZ_CHECK(test_icu_normalizer("[:Control:] Any-Remove",
"Don't\n shoot!",
"Don't shoot!"));
YAZ_CHECK(test_icu_normalizer("[:Decimal_Number:] Any-Remove",
"This is 4 you!",
"This is you!"));
YAZ_CHECK(test_icu_normalizer("Lower; [:^Letter:] Remove",
"Don't shoot!",
"dontshoot"));
YAZ_CHECK(test_icu_normalizer("[:^Number:] Remove",
"Monday 15th of April",
"15"));
YAZ_CHECK(test_icu_normalizer("Lower;"
"[[:WhiteSpace:][:Punctuation:]] Remove",
" word4you? ",
"word4you"));
YAZ_CHECK(test_icu_normalizer("NFD; [:Nonspacing Mark:] Remove; NFC",
"à côté de l'alcôve ovoïde",
"a cote de l'alcove ovoide"));
}
static void test(void)
{
WRBUF w = wrbuf_alloc();
WRBUF_shptr_t t = 0;
YAZ_SHPTR_INIT(t, w);
YAZ_CHECK(t);
YAZ_SHPTR_INC(t);
YAZ_CHECK(t);
YAZ_SHPTR_DEC(t, wrbuf_destroy);
YAZ_CHECK(t);
YAZ_SHPTR_DEC(t, wrbuf_destroy);
YAZ_CHECK(!t);
}
/** \brief see if we can create and destroy without problems */
static void test_create_destroy(void)
{
int fd;
sel_thread_t p = sel_thread_create(work_handler, 0, &fd, 1);
YAZ_CHECK(p);
if (!p)
return;
sel_thread_destroy(p);
}
static void check_icu_iter4(void)
{
UErrorCode status = U_ZERO_ERROR;
struct icu_chain *chain = 0;
xmlNode *xml_node;
const char *xml_str = "<icu locale=\"en\">"
"<transform rule=\"[:Control:] Any-Remove\"/>"
"<tokenize rule=\"l\"/>"
"<tokenize rule=\"w\"/>"
"<transform rule=\"[[:WhiteSpace:][:Punctuation:]] Remove\"/>"
"<display/>"
"<casemap rule=\"l\"/>"
"<join rule=\"\"/>"
"</icu>";
xmlDoc *doc = xmlParseMemory(xml_str, strlen(xml_str));
YAZ_CHECK(doc);
if (!doc)
return;
xml_node = xmlDocGetRootElement(doc);
YAZ_CHECK(xml_node);
if (!xml_node)
return ;
chain = icu_chain_xml_config(xml_node, 1, &status);
xmlFreeDoc(doc);
YAZ_CHECK(chain);
if (!chain)
return;
YAZ_CHECK(test_iter(chain, "Adobe Acrobat Reader, 1991-1999.",
"[adobeacrobatreader19911999]"));
YAZ_CHECK(test_iter(chain, "Νόταρης, Γιάννης Σωτ",
"[νόταρηςγιάννηςσωτ]"));
// check_iter_threads(chain);
icu_chain_destroy(chain);
}
static void dconvert(int mandatory, const char *tmpcode)
{
int i;
int ret;
yaz_iconv_t cd;
for (i = 0; iso_8859_1_a[i]; i++)
{
size_t r;
char *inbuf = (char*) iso_8859_1_a[i];
size_t inbytesleft = strlen(inbuf);
char outbuf0[24];
char outbuf1[10];
char *outbuf = outbuf0;
size_t outbytesleft = sizeof(outbuf0);
cd = yaz_iconv_open(tmpcode, "ISO-8859-1");
YAZ_CHECK(cd || !mandatory);
if (!cd)
return;
r = yaz_iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
YAZ_CHECK(r != (size_t) (-1));
r = yaz_iconv(cd, 0, 0, &outbuf, &outbytesleft);
YAZ_CHECK(r != (size_t) (-1));
yaz_iconv_close(cd);
if (r == (size_t) (-1))
return;
cd = yaz_iconv_open("ISO-8859-1", tmpcode);
YAZ_CHECK(cd || !mandatory);
if (!cd)
return;
inbuf = outbuf0;
inbytesleft = sizeof(outbuf0) - outbytesleft;
outbuf = outbuf1;
outbytesleft = sizeof(outbuf1);
r = yaz_iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
YAZ_CHECK(r != (size_t) (-1));
r = yaz_iconv(cd, 0, 0, &outbuf, &outbytesleft);
if (r == (size_t)(-1))
{
fprintf(stderr, "failed\n");
}
YAZ_CHECK(r != (size_t) (-1));
if (r != (size_t)(-1))
{
ret = compare_buffers("dconvert", i,
strlen(iso_8859_1_a[i]), iso_8859_1_a[i],
sizeof(outbuf1) - outbytesleft, outbuf1);
YAZ_CHECK(ret);
}
yaz_iconv_close(cd);
}
}
static void tstwrbuf(void)
{
int step;
WRBUF wr = wrbuf_alloc();
YAZ_CHECK(wr);
wrbuf_destroy(wr);
wr = wrbuf_alloc();
YAZ_CHECK(wr);
for (step = 1; step < 65; step++)
{
int i, j, k;
int len;
char buf[64];
char *cp;
for (j = 1; j<step; j++)
{
for (i = 0; i<j; i++)
buf[i] = i+1;
buf[i] = '\0';
wrbuf_puts(wr, buf);
}
cp = wrbuf_buf(wr);
len = wrbuf_len(wr);
YAZ_CHECK(len == step * (step-1) / 2);
k = 0;
for (j = 1; j<step; j++)
for (i = 0; i<j; i++)
{
YAZ_CHECK(cp[k] == i+1);
k++;
}
wrbuf_rewind(wr);
}
wrbuf_destroy(wr);
}
static void tst_ucs4b_to_utf8(void)
{
yaz_iconv_t cd = yaz_iconv_open("UTF8", "UCS4");
YAZ_CHECK(cd);
if (!cd)
return;
YAZ_CHECK(tst_convert_l(
cd,
8,
"\x00\x00\xFF\x1F\x00\x00\x00o",
4,
"\xEF\xBC\x9F\x6F"));
YAZ_CHECK(tst_convert_l(
cd,
8,
"\x00\x00\xAE\x0E\x00\x00\xC0\xF4",
6,
"\xEA\xB8\x8E\xEC\x83\xB4"));
yaz_iconv_close(cd);
}
/** \brief build a circular referenced query */
void test2(void)
{
ODR odr = odr_createmem(ODR_ENCODE);
YAZ_PQF_Parser parser = yaz_pqf_create();
Z_RPNQuery *rpn_query;
int ret;
YAZ_CHECK(odr);
rpn_query = yaz_pqf_parse (parser, odr, "@and @and a b c");
YAZ_CHECK(rpn_query);
/* make the circular reference */
rpn_query->RPNStructure->u.complex->s1 = rpn_query->RPNStructure;
ret = z_RPNQuery(odr, &rpn_query, 0, 0); /* should fail */
YAZ_CHECK(!ret);
yaz_pqf_destroy(parser);
odr_destroy(odr);
}
static void *iter_thread(void *p)
{
struct icu_chain *chain = (struct icu_chain *) p;
int i;
for (i = 0; i < 1000; i++)
{
YAZ_CHECK(test_iter(chain, "Adobe Acrobat Reader, 1991-1999.",
"[adobe][acrobat][reader][1991][][1999][]"));
}
return 0;
}
static void check_chain_empty_chain(void)
{
UErrorCode status = U_ZERO_ERROR;
struct icu_chain *chain = 0;
const char *xml_str = "<icu locale=\"en\">"
"</icu>";
const char *src8 = "some 5487 weired !¤%&(/& sTuFf";
char *dest8 = 0;
xmlDoc *doc = xmlParseMemory(xml_str, strlen(xml_str));
xmlNode *xml_node = xmlDocGetRootElement(doc);
YAZ_CHECK(xml_node);
chain = icu_chain_xml_config(xml_node, 0, &status);
xmlFreeDoc(doc);
YAZ_CHECK(chain);
YAZ_CHECK(icu_chain_assign_cstr(
chain, src8,
&status));
while (icu_chain_next_token(chain, &status))
{
;
/* printf("%d '%s' '%s'\n",
icu_chain_token_number(chain),
icu_chain_token_norm(chain),
icu_chain_token_display(chain)); */
}
YAZ_CHECK_EQ(icu_chain_token_number(chain), 1);
dest8 = (char *) icu_chain_token_norm(chain);
YAZ_CHECK_EQ(strcmp(src8, dest8), 0);
icu_chain_destroy(chain);
}
static void check_icu_iter3(void)
{
UErrorCode status = U_ZERO_ERROR;
struct icu_chain *chain = 0;
xmlNode *xml_node;
const char *xml_str =
"<icu_chain id=\"sort\" locale=\"el\">\n"
"<transform rule=\"[:Control:] Any-Remove\"/>\n"
"<transform rule=\"[[:Control:][:WhiteSpace:][:Punctuation:]] Remove\"/>\n"
"<transform rule=\"NFD; [:Nonspacing Mark:] Remove; NFC\"/>\n"
"<casemap rule=\"l\"/>\n"
"<display/>\n"
"</icu_chain>\n";
xmlDoc *doc = xmlParseMemory(xml_str, strlen(xml_str));
YAZ_CHECK(doc);
if (!doc)
return;
xml_node = xmlDocGetRootElement(doc);
YAZ_CHECK(xml_node);
if (!xml_node)
return ;
chain = icu_chain_xml_config(xml_node, 1, &status);
xmlFreeDoc(doc);
YAZ_CHECK(chain);
if (!chain)
return;
YAZ_CHECK(test_iter(chain, "Adobe Acrobat Reader, 1991-1999.",
"[adobeacrobatreader19911999]"));
YAZ_CHECK(test_iter(chain, "Νόταρης, Γιάννης Σωτ",
"[νοταρηςγιαννηςσωτ]"));
icu_chain_destroy(chain);
}
static int test_icu_tokenizer(const char *locale, char action,
const char *src8cstr, int count)
{
int success = 1;
UErrorCode status = U_ZERO_ERROR;
struct icu_buf_utf16 *src16 = icu_buf_utf16_create(0);
struct icu_buf_utf16 *tkn16 = icu_buf_utf16_create(0);
struct icu_buf_utf8 *tkn8 = icu_buf_utf8_create(0);
struct icu_tokenizer *tokenizer = 0;
size_t org_start, org_len;
/* transforming to UTF16 */
icu_utf16_from_utf8_cstr(src16, src8cstr, &status);
icu_check_status(status);
/* set up tokenizer */
tokenizer = icu_tokenizer_create(locale, action, &status);
icu_check_status(status);
YAZ_CHECK(tokenizer);
/* attach text buffer to tokenizer */
icu_tokenizer_attach(tokenizer, src16, &status);
icu_check_status(status);
/* perform work on tokens */
while (icu_tokenizer_next_token(tokenizer, tkn16, &status,
&org_start, &org_len))
{
icu_check_status(status);
/* converting to UTF8 */
icu_utf16_to_utf8(tkn8, tkn16, &status);
}
if (count != icu_tokenizer_token_count(tokenizer))
{
success = 0;
yaz_log(YLOG_LOG, "Tokenizer '%s:%c' Error:", locale, action);
yaz_log(YLOG_LOG, " Input: '%s'", src8cstr);
yaz_log(YLOG_LOG, " Tokens: %d", icu_tokenizer_token_count(tokenizer));
yaz_log(YLOG_LOG, " Expected: %d", count);
}
icu_tokenizer_destroy(tokenizer);
icu_buf_utf16_destroy(src16);
icu_buf_utf16_destroy(tkn16);
icu_buf_utf8_destroy(tkn8);
return success;
}
static void check_icu_iter1(void)
{
UErrorCode status = U_ZERO_ERROR;
struct icu_chain *chain = 0;
xmlNode *xml_node;
yaz_icu_iter_t iter;
const char *xml_str = "<icu locale=\"en\">"
"<tokenize rule=\"w\"/>"
"<transform rule=\"[[:WhiteSpace:][:Punctuation:]] Remove\"/>"
"</icu>";
xmlDoc *doc = xmlParseMemory(xml_str, strlen(xml_str));
YAZ_CHECK(doc);
if (!doc)
return;
xml_node = xmlDocGetRootElement(doc);
YAZ_CHECK(xml_node);
if (!xml_node)
return ;
chain = icu_chain_xml_config(xml_node, 1, &status);
xmlFreeDoc(doc);
YAZ_CHECK(chain);
iter = icu_iter_create(chain);
icu_iter_first(iter, "a string with 15 tokens and 8 displays");
YAZ_CHECK(iter);
if (!iter)
return;
while (icu_iter_next(iter))
{
yaz_log(YLOG_LOG, "[%s]", icu_iter_get_norm(iter));
}
icu_iter_destroy(iter);
icu_chain_destroy(chain);
}
static int conv_convert_test(yaz_record_conv_t p,
const char *input_record,
const char *output_expect_record)
{
int ret = 0;
if (!p)
{
YAZ_CHECK(ret);
}
else
{
WRBUF output_record = wrbuf_alloc();
int r = yaz_record_conv_record(p, input_record, strlen(input_record),
output_record);
if (r)
{
if (output_expect_record)
{
printf("yaz_record_conv error=%s\n",
yaz_record_conv_get_error(p));
ret = 0;
}
else
ret = 1;
}
else
{
if (!output_expect_record)
{
ret = 0;
}
else if (strcmp(output_expect_record, wrbuf_cstr(output_record)))
{
ret = 0;
printf("got-output_record len=%ld: %s\n",
(long) wrbuf_len(output_record),
wrbuf_cstr(output_record));
printf("output_expect_record len=%ld %s\n",
(long) strlen(output_expect_record),
output_expect_record);
}
else
{
ret = 1;
}
}
wrbuf_destroy(output_record);
}
return ret;
}
static void tst(void)
{
YAZ_CHECK(expect_pqf("a", "@attrset Bib-1 a", YAZ_PQF_ERROR_NONE));
YAZ_CHECK(expect_pqf("@attr 1=4 a", "@attrset Bib-1 @attr 1=4 a", YAZ_PQF_ERROR_NONE));
YAZ_CHECK(expect_pqf("a b", "", YAZ_PQF_ERROR_EXTRA));
YAZ_CHECK(expect_pqf("@and a", "", YAZ_PQF_ERROR_MISSING));
YAZ_CHECK(expect_pqf("@attr p=q a", "", YAZ_PQF_ERROR_BAD_INTEGER));
YAZ_CHECK(expect_pqf("@prox 0 0 0 0 k 0 a b",
"@attrset Bib-1 @prox 0 0 0 0 k 0 a b",
YAZ_PQF_ERROR_NONE));
YAZ_CHECK(expect_pqf("@prox 0 0 0 0 3 0 a b", "",
YAZ_PQF_ERROR_PROXIMITY));
}
static void check_chain_empty_token(void)
{
UErrorCode status = U_ZERO_ERROR;
struct icu_chain *chain = 0;
const char *xml_str = "<icu locale=\"en\">"
"<tokenize rule=\"w\"/>"
"<transform rule=\"[[:WhiteSpace:][:Punctuation:]] Remove\"/>"
"</icu>";
xmlDoc *doc = xmlParseMemory(xml_str, strlen(xml_str));
xmlNode *xml_node = xmlDocGetRootElement(doc);
YAZ_CHECK(xml_node);
chain = icu_chain_xml_config(xml_node, 0, &status);
xmlFreeDoc(doc);
YAZ_CHECK(chain);
YAZ_CHECK(icu_chain_assign_cstr(
chain, "a string with 15 tokenss and 8 displays",
&status));
while (icu_chain_next_token(chain, &status))
{
;
/* printf("%d '%s' '%s'\n",
icu_chain_token_number(chain),
icu_chain_token_norm(chain),
icu_chain_token_display(chain)); */
}
YAZ_CHECK_EQ(icu_chain_token_number(chain), 15);
icu_chain_destroy(chain);
}
static void tst_convert4(void)
{
NMEM nmem = nmem_create();
int ret;
const char *opacxml_rec =
"<opacRecord>\n"
" <bibliographicRecord>\n"
"<record xmlns=\"http://www.loc.gov/MARC21/slim\">\n"
" <leader>00077nam a22000498a 4500</leader>\n"
" <controlfield tag=\"001\"> 11224466 </controlfield>\n"
" <datafield tag=\"010\" ind1=\" \" ind2=\" \">\n"
" <subfield code=\"a\">k" "\xc3" "\xb8" /* oslash in UTF_8 */
"benhavn</subfield>\n"
" </datafield>\n"
"</record>\n"
" </bibliographicRecord>\n"
" <holdings>\n"
" <holding>\n"
" <shelvingLocation>Sprague Library hidden basement</shelvingLocation>\n"
" <callNumber>E98.L7L44 1976 </callNumber>\n"
" <volumes/>\n"
" </holding>\n"
" </holdings>\n"
" </opacRecord>\n"
;
Z_OPACRecord *opac = 0;
yaz_marc_t mt = yaz_marc_create();
ret = yaz_xml_to_opac(mt, opacxml_rec, strlen(opacxml_rec),
&opac, 0 /* iconv */, nmem, 0);
YAZ_CHECK(ret);
YAZ_CHECK(opac);
yaz_marc_destroy(mt);
nmem_destroy(nmem);
}
static void tst(void)
{
yaz_timing_t t = yaz_timing_create();
double real, user, sys;
int i = 0;
double x = 0;
YAZ_CHECK(t);
if (!t)
return;
#ifdef WIN32
Sleep(10);
#endif
for (i = 0; i<5000000; i++)
x += i;
YAZ_CHECK_EQ(i, 5000000);
yaz_log(YLOG_LOG, "i=%d x=%f", i, x);
yaz_timing_stop(t);
real = yaz_timing_get_real(t);
YAZ_CHECK(real == -1.0 || real >= 0.0);
user = yaz_timing_get_user(t);
YAZ_CHECK(user == -1.0 || user >= 0.0);
sys = yaz_timing_get_sys(t);
YAZ_CHECK(sys == -1.0 || sys >= 0.0);
yaz_log(YLOG_LOG, "real=%f user=%f sys=%f", real, user, sys);
yaz_timing_destroy(&t);
YAZ_CHECK(!t);
}
static void check_icu_tokenizer(void)
{
const char *en_str
= "O Romeo, Romeo! wherefore art thou Romeo?";
YAZ_CHECK(test_icu_tokenizer("en", 's', en_str, 2));
YAZ_CHECK(test_icu_tokenizer("en", 'l', en_str, 7));
YAZ_CHECK(test_icu_tokenizer("en", 'w', en_str, 16));
YAZ_CHECK(test_icu_tokenizer("en", 'c', en_str, 41));
{
const char *da_str
= "Blåbærtærte. Denne kage stammer fra Finland. "
"Den er med blåbær, men alle sommerens forskellige bær kan bruges.";
YAZ_CHECK(test_icu_tokenizer("da", 's', da_str, 3));
YAZ_CHECK(test_icu_tokenizer("dar", 'l', da_str, 17));
YAZ_CHECK(test_icu_tokenizer("da", 'w', da_str, 37));
YAZ_CHECK(test_icu_tokenizer("da", 'c', da_str, 110));
}
}
static void tst1(void)
{
cql_transform_t ct = cql_transform_create();
YAZ_CHECK(compare(ct, "abc", "abc"));
YAZ_CHECK(compare(ct, "\"a b c\"", "\"a b c\""));
YAZ_CHECK(compare(ct, "@and a b", "a and b"));
YAZ_CHECK(compare(ct, "@attr 1=field abc", "field=abc"));
YAZ_CHECK(compare(ct, "@attr 1=4 abc", 0)); /* should fail */
cql_transform_define_pattern(ct, "index.title", "1=4");
YAZ_CHECK(compare(ct, "@attr 1=4 abc", "title=abc"));
cql_transform_define_pattern(ct, "index.foo", "1=bar");
YAZ_CHECK(compare(ct, "@attr 1=bar abc", "foo=abc"));
cql_transform_close(ct);
}
/** brief use the fd for something */
static void test_for_real_work(int no_threads)
{
int thread_fd;
sel_thread_t p = sel_thread_create(work_handler, work_destroy,
&thread_fd, no_threads);
YAZ_CHECK(p);
if (p)
{
iochan_man_t chan_man = iochan_man_create(10);
IOCHAN chan = iochan_create(thread_fd, iochan_handler,
EVENT_INPUT|EVENT_TIMEOUT, "test_chan");
iochan_settimeout(chan, 1);
iochan_setdata(chan, p);
iochan_add(chan_man, chan);
iochan_man_events(chan_man);
sel_thread_destroy(p);
iochan_man_destroy(&chan_man);
}
}
static void tst_configure(void)
{
YAZ_CHECK(conv_configure_test("<bad", "xmlParseMemory", 0));
YAZ_CHECK(conv_configure_test("<backend syntax='usmarc' name='F'>"
"<bad/></backend>",
"Element <backend>: expected <marc> or "
"<xslt> element, got <bad>", 0));
#if YAZ_HAVE_XSLT
YAZ_CHECK(conv_configure_test("<backend syntax='usmarc' name='F'>"
"<xslt stylesheet=\"tst_record_conv.xsl\"/>"
"<marc"
" inputcharset=\"marc-8\""
" outputcharset=\"marc-8\""
"/>"
"</backend>",
"Element <marc>: attribute 'inputformat' "
"required", 0));
YAZ_CHECK(conv_configure_test("<backend syntax='usmarc' name='F'>"
"<xslt/>"
"</backend>",
"Element <xslt>: attribute 'stylesheet' "
"expected", 0));
YAZ_CHECK(conv_configure_test("<backend syntax='usmarc' name='F'>"
"<marc"
" inputcharset=\"utf-8\""
" outputcharset=\"marc-8\""
" inputformat=\"xml\""
" outputformat=\"marc\""
"/>"
"<xslt stylesheet=\"tst_record_conv.xsl\"/>"
"</backend>",
0, 0));
#else
YAZ_CHECK(conv_configure_test("<backend syntax='usmarc' name='F'>"
"<xslt stylesheet=\"tst_record_conv.xsl\"/>"
"</backend>",
"xslt unsupported."
" YAZ compiled without XSLT support", 0));
#endif
}
