test/tst_record_conv.c

   1 /*
   2  * Copyright (C) 2005-2006, Index Data ApS
   3  * See the file LICENSE for details.
   4  *
   5  * $Id: tst_record_conv.c,v 1.2 2006-05-03 13:04:46 adam Exp $
   6  *
   7  */
   8 #include <yaz/record_conv.h>
   9 #include <yaz/test.h>
  10 #include <yaz/wrbuf.h>
  11 #include <string.h>
  12
  13 #if HAVE_XML2
  14
  15 #include <libxml/parser.h>
  16 #include <libxml/tree.h>
  17
  18 yaz_record_conv_t conv_configure(const char *xmlstring, WRBUF w)
  19 {
  20     xmlDocPtr doc = xmlParseMemory(xmlstring, strlen(xmlstring));
  21     if (!doc)
  22     {
  23         wrbuf_printf(w, "xmlParseMemory");
  24         return 0;
  25     }
  26     else
  27     {
  28         xmlNodePtr ptr = xmlDocGetRootElement(doc);
  29         yaz_record_conv_t p = yaz_record_conv_create();
  30
  31         if (p)
  32         {
  33             const char *srcdir = getenv("srcdir");
  34             if (srcdir)
  35                 yaz_record_conv_set_path(p, srcdir);
  36         }
  37         if (!ptr)
  38         {
  39             wrbuf_printf(w, "xmlDocGetRootElement");
  40             yaz_record_conv_destroy(p);
  41             p = 0;
  42         }
  43         else if (!p)
  44         {
  45             wrbuf_printf(w, "yaz_record_conv_create");
  46         }
  47         else
  48         {
  49             int r = yaz_record_conv_configure(p, ptr);
  50
  51             if (r)
  52             {
  53                 wrbuf_puts(w, yaz_record_conv_get_error(p));
  54                 yaz_record_conv_destroy(p);
  55                 p = 0;
  56             }
  57         }
  58         xmlFreeDoc(doc);
  59         return p;
  60     }
  61 }
  62
  63 int conv_configure_test(const char *xmlstring, const char *expect_error,
  64                         yaz_record_conv_t *pt)
  65 {
  66     WRBUF w = wrbuf_alloc();
  67     int ret;
  68
  69     yaz_record_conv_t p = conv_configure(xmlstring, w);
  70
  71     if (!p)
  72     {
  73         if (expect_error && !strcmp(wrbuf_buf(w), expect_error))
  74             ret = 1;
  75         else
  76         {
  77             ret = 0;
  78             printf("%.*s\n", wrbuf_len(w), wrbuf_buf(w));
  79         }
  80     }
  81     else
  82     {
  83         if (expect_error)
  84         {
  85             ret = 0;
  86             yaz_record_conv_destroy(p);
  87         }
  88         else
  89         {
  90             if (pt)
  91                 *pt = p;
  92             else
  93                 yaz_record_conv_destroy(p);
  94             ret = 1;
  95         }
  96     }
  97     wrbuf_free(w, 1);
  98     return ret;
  99 }
 100
 101 static void tst_configure()
 102 {
 103     YAZ_CHECK(conv_configure_test("<bad", "xmlParseMemory", 0));
 104     YAZ_CHECK(conv_configure_test("<bad/>", "Missing 'convert' element", 0));
 105     YAZ_CHECK(conv_configure_test("<convert/>", 0, 0));
 106     YAZ_CHECK(conv_configure_test("<convert><bad/></convert>",
 107                                   "Bad element 'bad'."
 108                                   "Expected marc, xslt, ..", 0));
 109     YAZ_CHECK(conv_configure_test("<convert>"
 110                                   "<xslt stylesheet=\"tst_record_conv.xsl\"/>"
 111                                   "<marc"
 112                                   " inputcharset=\"marc-8\""
 113                                   " outputcharset=\"marc-8\""
 114                                   "/>"
 115                                   "</convert>",
 116                                   "Attribute 'inputformat' required", 0));
 117     YAZ_CHECK(conv_configure_test("<convert>"
 118                                   "<xslt stylesheet=\"tst_record_conv.xsl\"/>"
 119                                   "<marc"
 120                                   " inputcharset=\"utf-8\""
 121                                   " outputcharset=\"marc-8\""
 122                                   " inputformat=\"xml\""
 123                                   " outputformat=\"marc\""
 124                                   "/>"
 125                                   "</convert>",
 126                                   0, 0));
 127 }
 128
 129 static int conv_convert_test(yaz_record_conv_t p,
 130                              const char *input_record,
 131                              const char *output_expect_record)
 132 {
 133     int ret = 0;
 134     if (!p)
 135     {
 136         YAZ_CHECK(ret);
 137     }
 138     else
 139     {
 140         WRBUF output_record = wrbuf_alloc();
 141         int r = yaz_record_conv_record(p, input_record, output_record);
 142         if (r)
 143         {
 144             if (output_expect_record)
 145             {
 146                 printf("yaz_record_conv error=%s\n",
 147                        yaz_record_conv_get_error(p));
 148                 ret = 0;
 149             }
 150             else
 151                 ret = 1;
 152         }
 153         else
 154         {
 155             if (!output_expect_record)
 156             {
 157                 ret = 0;
 158             }
 159             else if (strlen(output_expect_record) != wrbuf_len(output_record))
 160             {
 161                 int expect_len = strlen(output_expect_record);
 162                 ret = 0;
 163                 printf("output_record expect-len=%d got-len=%d\n", expect_len,
 164                        wrbuf_len(output_record));
 165                 printf("got-output_record = %.*s\n",
 166                        wrbuf_len(output_record), wrbuf_buf(output_record));
 167                 printf("output_expect_record = %s\n",
 168                        output_expect_record);
 169             }
 170             else if (memcmp(output_expect_record, wrbuf_buf(output_record),
 171                             strlen(output_expect_record)))
 172             {
 173                 ret = 0;
 174                 printf("got-output_record = %.*s\n",
 175                        wrbuf_len(output_record), wrbuf_buf(output_record));
 176                 printf("output_expect_record = %s\n",
 177                        output_expect_record);
 178             }
 179             else
 180             {
 181                 ret = 1;
 182             }
 183         }
 184         wrbuf_free(output_record, 1);
 185     }
 186     return ret;
 187 }
 188
 189 static void tst_convert()
 190 {
 191     yaz_record_conv_t p = 0;
 192     const char *marcxml_rec =
 193         "<record xmlns=\"http://www.loc.gov/MARC21/slim\">\n"
 194         "  <leader>00080nam a22000498a 4500</leader>\n"
 195         "  <controlfield tag=\"001\">   11224466 </controlfield>\n"
 196         "  <datafield tag=\"010\" ind1=\" \" ind2=\" \">\n"
 197         "    <subfield code=\"a\">   11224466 </subfield>\n"
 198         "  </datafield>\n"
 199         "</record>\n";
 200     const char *iso2709_rec =
 201         "\x30\x30\x30\x38\x30\x6E\x61\x6D\x20\x61\x32\x32\x30\x30\x30\x34"
 202         "\x39\x38\x61\x20\x34\x35\x30\x30\x30\x30\x31\x30\x30\x31\x33\x30"
 203         "\x30\x30\x30\x30\x30\x31\x30\x30\x30\x31\x37\x30\x30\x30\x31\x33"
 204         "\x1E\x20\x20\x20\x31\x31\x32\x32\x34\x34\x36\x36\x20\x1E\x20\x20"
 205         "\x1F\x61\x20\x20\x20\x31\x31\x32\x32\x34\x34\x36\x36\x20\x1E\x1D";
 206
 207     YAZ_CHECK(conv_configure_test("<convert>"
 208                                   "<marc"
 209                                   " inputcharset=\"utf-8\""
 210                                   " outputcharset=\"marc-8\""
 211                                   " inputformat=\"xml\""
 212                                   " outputformat=\"marc\""
 213                                   "/>"
 214                                   "</convert>",
 215                                   0, &p));
 216     YAZ_CHECK(conv_convert_test(p, marcxml_rec, iso2709_rec));
 217
 218     YAZ_CHECK(conv_configure_test("<convert>"
 219                                   "<marc"
 220                                   " outputcharset=\"utf-8\""
 221                                   " inputcharset=\"marc-8\""
 222                                   " outputformat=\"marcxml\""
 223                                   " inputformat=\"marc\""
 224                                   "/>"
 225                                   "</convert>",
 226                                   0, &p));
 227     YAZ_CHECK(conv_convert_test(p, iso2709_rec, marcxml_rec));
 228
 229
 230     YAZ_CHECK(conv_configure_test("<convert>"
 231                                   "<xslt stylesheet=\"tst_record_conv.xsl\"/>"
 232                                   "<xslt stylesheet=\"tst_record_conv.xsl\"/>"
 233                                   "<marc"
 234                                   " inputcharset=\"utf-8\""
 235                                   " outputcharset=\"marc-8\""
 236                                   " inputformat=\"xml\""
 237                                   " outputformat=\"marc\""
 238                                   "/>"
 239                                   "<marc"
 240                                   " outputcharset=\"utf-8\""
 241                                   " inputcharset=\"marc-8\""
 242                                   " outputformat=\"marcxml\""
 243                                   " inputformat=\"marc\""
 244                                   "/>"
 245                                   "</convert>",
 246                                   0, &p));
 247     YAZ_CHECK(conv_convert_test(p, marcxml_rec, marcxml_rec));
 248
 249
 250
 251     YAZ_CHECK(conv_configure_test("<convert>"
 252                                   "<xslt stylesheet=\"tst_record_conv.xsl\"/>"
 253                                   "<xslt stylesheet=\"tst_record_conv.xsl\"/>"
 254                                   "<marc"
 255                                   " outputcharset=\"marc-8\""
 256                                   " inputformat=\"xml\""
 257                                   " outputformat=\"marc\""
 258                                   "/>"
 259                                   "<marc"
 260                                   " inputcharset=\"marc-8\""
 261                                   " outputformat=\"marcxml\""
 262                                   " inputformat=\"marc\""
 263                                   "/>"
 264                                   "</convert>",
 265                                   0, &p));
 266     YAZ_CHECK(conv_convert_test(p, marcxml_rec, marcxml_rec));
 267
 268 }
 269
 270 #endif
 271
 272 int main(int argc, char **argv)
 273 {
 274     YAZ_CHECK_INIT(argc, argv);
 275 #if HAVE_XML2
 276     tst_configure();
 277     tst_convert();
 278 #endif
 279     YAZ_CHECK_TERM;
 280 }
 281
 282 /*
 283  * Local variables:
 284  * c-basic-offset: 4
 285  * indent-tabs-mode: nil
 286  * End:
 287  * vim: shiftwidth=4 tabstop=8 expandtab
 288  */
 289