/basex-core/src/test/java/org/basex/query/func/ValidateModuleTest.java

https://github.com/JensErat/basex · Java · 247 lines · 166 code · 21 blank · 60 comment · 0 complexity · 27f35d73e70f9154f7f7912c0f909d23 MD5 · raw file 

    

  1. package org.basex.query.func;
    2. 

  2. 

  3. import static org.basex.query.QueryError.*;
    4. 

  4. import static org.basex.query.func.Function.*;
    5. 

  5. 

  6. import org.basex.query.*;
    7. 

  7. import org.junit.*;
    8. 

  8. 

  9. /**
    10. 

  10.  * This class tests the functions of the Validation Module.
    11. 

  11.  *
    12. 

  12.  * @author BaseX Team 2005-16, BSD License
    13. 

  13.  * @author Christian Gruen
    14. 

  14.  */
    15. 

  15. public final class ValidateModuleTest extends AdvancedQueryTest {
    16. 

  16.   /** Test file. */
    17. 

  17.   private static final String DIR = "src/test/resources/";
    18. 

  18.   /** Test file. */
    19. 

  19.   private static final String FILE = DIR + "validate.xml";
    20. 

  20.   /** Test file. */
    21. 

  21.   private static final String XSD = DIR + "validate.xsd";
    22. 

  22.   /** Test file. */
    23. 

  23.   private static final String DTD = DIR + "validate.dtd";
    24. 

  24.   /** Test file. */
    25. 

  25.   private static final String INPUT = DIR + "input.xml";
    26. 

  26. 

  27.   /** Test method. */
    28. 

  28.   @Test
    29. 

  29.   public void xsd() {
    30. 

  30.     // specify arguments as file paths
    31. 

  31.     query(_VALIDATE_XSD.args(FILE, XSD), "");
    32. 

  32.     // specify arguments as document nodes
    33. 

  33.     query(_VALIDATE_XSD.args(DOC.args(FILE), DOC.args(XSD)), "");
    34. 

  34.     // specify arguments as file contents
    35. 

  35.     query(_VALIDATE_XSD.args(_FILE_READ_TEXT.args(FILE), _FILE_READ_TEXT.args(XSD)), "");
    36. 

  36.     // specify version
    37. 

  37.     query(_VALIDATE_XSD.args(FILE, XSD, "1.0"), "");
    38. 

  38.     // specify main-memory fragments as arguments
    39. 

  39.     query(
    40. 

  40.       "let $doc := <root/> " +
    41. 

  41.       "let $schema := <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'> " +
    42. 

  42.       "<xs:element name='root'/> " +
    43. 

  43.       "</xs:schema> " +
    44. 

  44.       "return validate:xsd($doc, $schema)", "");
    45. 

  45. 

  46.     // invalid arguments
    47. 

  47.     error(_VALIDATE_XSD.args("unknown"), WHICHRES_X);
    48. 

  48.     error(_VALIDATE_XSD.args(FILE, "unknown.xsd"), WHICHRES_X);
    49. 

  49.     error(_VALIDATE_XSD.args(FILE, XSD, "0.99"), BXVA_XSDVERSION_X);
    50. 

  50.     error(_VALIDATE_XSD.args(FILE), BXVA_FAIL_X);
    51. 

  51.     error(
    52. 

  52.       "let $doc := <root/> " +
    53. 

  53.       "let $schema := <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'> " +
    54. 

  54.       "<xs:element name='unknown'/> " +
    55. 

  55.       "</xs:schema> " +
    56. 

  56.       "return validate:xsd($doc, $schema)", BXVA_FAIL_X);
    57. 

  57.   }
    58. 

  58. 

  59.   /** Test method. */
    60. 

  60.   @Test
    61. 

  61.   public void xsdInfo() {
    62. 

  62.     // specify arguments as file paths
    63. 

  63.     query(_VALIDATE_XSD_INFO.args(FILE, XSD), "");
    64. 

  64.     // specify arguments as document nodes
    65. 

  65.     query(_VALIDATE_XSD_INFO.args(DOC.args(FILE), DOC.args(XSD)), "");
    66. 

  66.     // specify arguments as file contents
    67. 

  67.     query(_VALIDATE_XSD_INFO.args(_FILE_READ_TEXT.args(FILE),
    68. 

  68.         _FILE_READ_TEXT.args(XSD)), "");
    69. 

  69.     // specify version
    70. 

  70.     query(_VALIDATE_XSD_INFO.args(FILE, XSD, "1.0"), "");
    71. 

  71.     // specify main-memory fragments as arguments
    72. 

  72.     query(
    73. 

  73.       "let $doc := <root/> " +
    74. 

  74.       "let $schema := <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'> " +
    75. 

  75.       "<xs:element name='root'/> " +
    76. 

  76.       "</xs:schema> " +
    77. 

  77.       "return " + _VALIDATE_XSD_INFO.args("$doc", "$schema"), "");
    78. 

  78. 

  79.     // returned error
    80. 

  80.     query(EXISTS.args(_VALIDATE_XSD_INFO.args(FILE)), "true");
    81. 

  81.     query(EXISTS.args(
    82. 

  82.       "let $doc := <root/> " +
    83. 

  83.       "let $schema := <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'> " +
    84. 

  84.       "<xs:element name='unknown'/> " +
    85. 

  85.       "</xs:schema> " +
    86. 

  86.       "return " + _VALIDATE_XSD_INFO.args("$doc", "$schema")), "true");
    87. 

  87. 

  88.     // invalid arguments
    89. 

  89.     error(_VALIDATE_XSD_INFO.args("unknown"), WHICHRES_X);
    90. 

  90.     error(_VALIDATE_XSD_INFO.args(FILE, "unknown.xsd"), WHICHRES_X);
    91. 

  91.     error(_VALIDATE_XSD_INFO.args(FILE, XSD, "0.99"), BXVA_XSDVERSION_X);
    92. 

  92.   }
    93. 

  93. 

  94.   /** Test method. */
    95. 

  95.   @Test
    96. 

  96.   public void xsdReport() {
    97. 

  97.     // check XML result
    98. 

  98.     query(_VALIDATE_XSD_REPORT.args(FILE, XSD), "<report>\n<status>valid</status>\n</report>");
    99. 

  99.     // specify arguments as file paths
    100. 

  100.     query(_VALIDATE_XSD_REPORT.args(FILE, XSD) + "//status/string()", "valid");
    101. 

  101.     // specify arguments as document nodes
    102. 

  102.     query(_VALIDATE_XSD_REPORT.args(DOC.args(FILE), DOC.args(XSD)) + "//status/string()", "valid");
    103. 

  103.     // specify arguments as file contents
    104. 

  104.     query(_VALIDATE_XSD_REPORT.args(_FILE_READ_TEXT.args(FILE), _FILE_READ_TEXT.args(XSD)) +
    105. 

  105.         "//status/string()", "valid");
    106. 

  106.     // check XML result
    107. 

  107.     query(_VALIDATE_XSD_REPORT.args(FILE, XSD, "1.0"),
    108. 

  108.         "<report>\n<status>valid</status>\n</report>");
    109. 

  109.     // specify main-memory fragments as arguments
    110. 

  110.     query(
    111. 

  111.       "let $doc := <root/> " +
    112. 

  112.       "let $schema := <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'> " +
    113. 

  113.       "                 <xs:element name='root'/> " +
    114. 

  114.       "               </xs:schema> " +
    115. 

  115.       "return " + _VALIDATE_XSD_REPORT.args("$doc", "$schema") + "//status/string()", "valid");
    116. 

  116. 

  117.     // returned error
    118. 

  118.     query(_VALIDATE_XSD_REPORT.args(FILE) + "//status/string()", "invalid");
    119. 

  119.     query(
    120. 

  120.       "let $doc := <root/> " +
    121. 

  121.       "let $schema := <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'> " +
    122. 

  122.       "                 <xs:element name='unknown'/> " +
    123. 

  123.       "               </xs:schema> " +
    124. 

  124.       "return " + _VALIDATE_XSD_REPORT.args("$doc", "$schema") + "//status/string()", "invalid");
    125. 

  125. 

  126.     // check XML result
    127. 

  127.     query(
    128. 

  128.       "let $doc := <root/> " +
    129. 

  129.       "let $schema := <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'> " +
    130. 

  130.       "                 <xs:element name='unknown'/> " +
    131. 

  131.       "               </xs:schema> " +
    132. 

  132.       "let $report := " + _VALIDATE_XSD_REPORT.args("$doc", "$schema") +
    133. 

  133.       "return $report update (" +
    134. 

  134.       "  delete node .//message/text()," +
    135. 

  135.       "  for $a in .//@* return replace value of node $a with ''" +
    136. 

  136.       ")",
    137. 

  137.       "<report>\n<status>invalid</status>\n" +
    138. 

  138.       "<message level=\"\" line=\"\" column=\"\"/>\n" +
    139. 

  139.       "</report>");
    140. 

  140.     // check URL attribute
    141. 

  141.     query(EXISTS.args(_VALIDATE_XSD_REPORT.args(INPUT, XSD) + "//@url"), "true");
    142. 

  142. 

  143.     // invalid arguments
    144. 

  144.     error(_VALIDATE_XSD_REPORT.args("unknown"), WHICHRES_X);
    145. 

  145.     error(_VALIDATE_XSD_REPORT.args(FILE, "unknown.xsd"), WHICHRES_X);
    146. 

  146.     error(_VALIDATE_XSD_REPORT.args(FILE, XSD, "0.99"), BXVA_XSDVERSION_X);
    147. 

  147.   }
    148. 

  148. 

  149.   /** Test method. */
    150. 

  150.   @Test
    151. 

  151.   public void dtd() {
    152. 

  152.     // specify arguments as file paths
    153. 

  153.     query(_VALIDATE_DTD.args(FILE, DTD), "");
    154. 

  154.     // specify document as document nodes
    155. 

  155.     query(_VALIDATE_DTD.args(DOC.args(FILE), DTD), "");
    156. 

  156.     // specify arguments as file contents
    157. 

  157.     query(_VALIDATE_DTD.args(_FILE_READ_TEXT.args(FILE),
    158. 

  158.         _FILE_READ_TEXT.args(DTD)), "");
    159. 

  159.     // specify main-memory fragments as arguments
    160. 

  160.     query(
    161. 

  161.       "let $doc := <root/> " +
    162. 

  162.       "let $dtd := '<!ELEMENT root (#PCDATA)>' " +
    163. 

  163.       "return validate:dtd($doc, $dtd) ", "");
    164. 

  164. 

  165.     // invalid arguments
    166. 

  166.     error(_VALIDATE_DTD.args("unknown"), WHICHRES_X);
    167. 

  167.     error(_VALIDATE_DTD.args(FILE, "unknown.dtd"), WHICHRES_X);
    168. 

  168.     error(_VALIDATE_DTD.args(FILE), BXVA_FAIL_X);
    169. 

  169.     error(
    170. 

  170.       "let $doc := <root/> " +
    171. 

  171.       "let $dtd := '<!ELEMENT unknown (#PCDATA)>' " +
    172. 

  172.       "return validate:dtd($doc, $dtd) ", BXVA_FAIL_X);
    173. 

  173.   }
    174. 

  174. 

  175.   /** Test method. */
    176. 

  176.   @Test
    177. 

  177.   public void dtdInfo() {
    178. 

  178.     // specify arguments as file paths
    179. 

  179.     query(_VALIDATE_DTD_INFO.args(FILE, DTD), "");
    180. 

  180.     // specify document as document nodes
    181. 

  181.     query(_VALIDATE_DTD_INFO.args(DOC.args(FILE), DTD), "");
    182. 

  182.     // specify arguments as file contents
    183. 

  183.     query(_VALIDATE_DTD_INFO.args(_FILE_READ_TEXT.args(FILE),
    184. 

  184.         _FILE_READ_TEXT.args(DTD)), "");
    185. 

  185.     // specify main-memory fragments as arguments
    186. 

  186.     query(
    187. 

  187.       "let $doc := <root/> " +
    188. 

  188.       "let $dtd := '<!ELEMENT root (#PCDATA)>' " +
    189. 

  189.       "return " + _VALIDATE_DTD_INFO.args("$doc", "$dtd"), "");
    190. 

  190. 

  191.     // returned error
    192. 

  192.     query(EXISTS.args(_VALIDATE_DTD_INFO.args(FILE)), "true");
    193. 

  193.     query(EXISTS.args(
    194. 

  194.       "let $doc := <root/> " +
    195. 

  195.       "let $dtd := '<!ELEMENT unknown (#PCDATA)>' " +
    196. 

  196.       "return " + _VALIDATE_DTD_INFO.args("$doc", "$dtd")), "true");
    197. 

  197. 

  198.     // invalid arguments
    199. 

  199.     error(_VALIDATE_DTD_INFO.args("unknown"), WHICHRES_X);
    200. 

  200.     error(_VALIDATE_DTD_INFO.args(FILE, "unknown.dtd"), WHICHRES_X);
    201. 

  201.   }
    202. 

  202. 

  203.   /** Test method. */
    204. 

  204.   @Test
    205. 

  205.   public void dtdReport() {
    206. 

  206.     // check XML result
    207. 

  207.     query(_VALIDATE_DTD_REPORT.args(FILE, DTD), "<report>\n<status>valid</status>\n</report>");
    208. 

  208.     // specify arguments as file paths
    209. 

  209.     query(_VALIDATE_DTD_REPORT.args(FILE, DTD) + "//status/string()", "valid");
    210. 

  210.     // specify document as document nodes
    211. 

  211.     query(_VALIDATE_DTD_REPORT.args(DOC.args(FILE), DTD) + "//status/string()", "valid");
    212. 

  212.     // specify arguments as file contents
    213. 

  213.     query(_VALIDATE_DTD_REPORT.args(_FILE_READ_TEXT.args(FILE), _FILE_READ_TEXT.args(DTD)) +
    214. 

  214.         "//status/string()", "valid");
    215. 

  215.     // specify main-memory fragments as arguments
    216. 

  216.     query(
    217. 

  217.       "let $doc := <root/> " +
    218. 

  218.       "let $dtd := '<!ELEMENT root (#PCDATA)>' " +
    219. 

  219.       "return " + _VALIDATE_DTD_REPORT.args("$doc", "$dtd") + "//status/string()", "valid");
    220. 

  220. 

  221.     // returned error
    222. 

  222.     query(_VALIDATE_DTD_REPORT.args(FILE) + "//status/string()", "invalid");
    223. 

  223.     query(
    224. 

  224.       "let $doc := <root/> " +
    225. 

  225.       "let $dtd := '<!ELEMENT unknown (#PCDATA)>' " +
    226. 

  226.       "return " + _VALIDATE_DTD_REPORT.args("$doc", "$dtd") + "//status/string()", "invalid");
    227. 

  227. 

  228.     // check XML result
    229. 

  229.     query(
    230. 

  230.       "let $doc := <root/> " +
    231. 

  231.       "let $schema := '<!ELEMENT unknown (#PCDATA)>' " +
    232. 

  232.       "let $report := " + _VALIDATE_DTD_REPORT.args("$doc", "$schema") +
    233. 

  233.       "return $report update (" +
    234. 

  234.       "  delete node .//message/text()," +
    235. 

  235.       "  for $a in .//@* return replace value of node $a with ''" +
    236. 

  236.       ")",
    237. 

  237.       "<report>\n<status>invalid</status>\n" +
    238. 

  238.       "<message level=\"\" line=\"\" column=\"\"/>\n" +
    239. 

  239.       "</report>");
    240. 

  240.     // check URL attribute
    241. 

  241.     query(EXISTS.args(_VALIDATE_DTD_REPORT.args(INPUT, DTD) + "//@url"), "true");
    242. 

  242. 

  243.     // invalid arguments
    244. 

  244.     error(_VALIDATE_DTD_REPORT.args("unknown"), WHICHRES_X);
    245. 

  245.     error(_VALIDATE_DTD_REPORT.args(FILE, "unknown.dtd"), WHICHRES_X);
    246. 

  246.   }
    247. 

  247. }
    248.