commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From a...@apache.org
Subject cvs commit: jakarta-commons/lang/src/test/org/apache/commons/lang EntitiesTest.java StringEscapeUtilsTest.java
Date Sat, 24 May 2003 04:35:07 GMT
alex        2003/05/23 21:35:07

  Modified:    lang/src/java/org/apache/commons/lang Entities.java
                        StringEscapeUtils.java
               lang/src/test/org/apache/commons/lang
                        StringEscapeUtilsTest.java
  Added:       lang/src/test/org/apache/commons/lang EntitiesTest.java
  Log:
  refactoring Entities object in preparation for optimization
  add unit tests for Entities class
  move escape and unescape methods into Entities class
  
  Revision  Changes    Path
  1.5       +262 -173  jakarta-commons/lang/src/java/org/apache/commons/lang/Entities.java
  
  Index: Entities.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/Entities.java,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- Entities.java	6 May 2003 22:10:40 -0000	1.4
  +++ Entities.java	24 May 2003 04:35:06 -0000	1.5
  @@ -56,8 +56,6 @@
   import java.util.HashMap;
   import java.util.Map;
   
  -//todo: unit test and make public
  -
   /**
    * <p>Provides HTML and XML entity utilities.</p>
    *
  @@ -74,18 +72,18 @@
    */
   class Entities {
   
  -    static private Object[][] basic = {
  +    static private String[][] basic = {
           {"quot", "34"}, // " - double-quote
           {"amp", "38"}, // & - ampersand
           {"lt", "60"}, // < - less-than
           {"gt", "62"}, // > - greater-than
       };
   
  -    static private Object[][] apos = {
  +    static private String[][] apos = {
           {"apos", "39"}, // XML apostrophe
       };
   
  -    static private Object[][] iso8859_1 = {
  +    static private String[][] iso8859_1 = {
           {"nbsp", "160"}, // non-breaking space
           {"iexcl", "161"}, //inverted exclamation mark
           {"cent", "162"}, //cent sign
  @@ -185,189 +183,189 @@
       };
   
       // http://www.w3.org/TR/REC-html40/sgml/entities.html
  -    static Object[][] html40 = {
  +    static String[][] html40 = {
   // <!-- Latin Extended-B -->
  -        {"fnof", "402"},  //latin small f with hook = function= florin, U+0192 ISOtech
-->
  +        {"fnof", "402"}, //latin small f with hook = function= florin, U+0192 ISOtech -->
   // <!-- Greek -->
  -        {"Alpha", "913"},  //greek capital letter alpha, U+0391 -->
  -        {"Beta", "914"},  //greek capital letter beta, U+0392 -->
  -        {"Gamma", "915"},  //greek capital letter gamma,U+0393 ISOgrk3 -->
  -        {"Delta", "916"},  //greek capital letter delta,U+0394 ISOgrk3 -->
  -        {"Epsilon", "917"},  //greek capital letter epsilon, U+0395 -->
  -        {"Zeta", "918"},  //greek capital letter zeta, U+0396 -->
  -        {"Eta", "919"},  //greek capital letter eta, U+0397 -->
  -        {"Theta", "920"},  //greek capital letter theta,U+0398 ISOgrk3 -->
  -        {"Iota", "921"},  //greek capital letter iota, U+0399 -->
  -        {"Kappa", "922"},  //greek capital letter kappa, U+039A -->
  -        {"Lambda", "923"},  //greek capital letter lambda,U+039B ISOgrk3 -->
  -        {"Mu", "924"},  //greek capital letter mu, U+039C -->
  -        {"Nu", "925"},  //greek capital letter nu, U+039D -->
  -        {"Xi", "926"},  //greek capital letter xi, U+039E ISOgrk3 -->
  -        {"Omicron", "927"},  //greek capital letter omicron, U+039F -->
  -        {"Pi", "928"},  //greek capital letter pi, U+03A0 ISOgrk3 -->
  -        {"Rho", "929"},  //greek capital letter rho, U+03A1 -->
  +        {"Alpha", "913"}, //greek capital letter alpha, U+0391 -->
  +        {"Beta", "914"}, //greek capital letter beta, U+0392 -->
  +        {"Gamma", "915"}, //greek capital letter gamma,U+0393 ISOgrk3 -->
  +        {"Delta", "916"}, //greek capital letter delta,U+0394 ISOgrk3 -->
  +        {"Epsilon", "917"}, //greek capital letter epsilon, U+0395 -->
  +        {"Zeta", "918"}, //greek capital letter zeta, U+0396 -->
  +        {"Eta", "919"}, //greek capital letter eta, U+0397 -->
  +        {"Theta", "920"}, //greek capital letter theta,U+0398 ISOgrk3 -->
  +        {"Iota", "921"}, //greek capital letter iota, U+0399 -->
  +        {"Kappa", "922"}, //greek capital letter kappa, U+039A -->
  +        {"Lambda", "923"}, //greek capital letter lambda,U+039B ISOgrk3 -->
  +        {"Mu", "924"}, //greek capital letter mu, U+039C -->
  +        {"Nu", "925"}, //greek capital letter nu, U+039D -->
  +        {"Xi", "926"}, //greek capital letter xi, U+039E ISOgrk3 -->
  +        {"Omicron", "927"}, //greek capital letter omicron, U+039F -->
  +        {"Pi", "928"}, //greek capital letter pi, U+03A0 ISOgrk3 -->
  +        {"Rho", "929"}, //greek capital letter rho, U+03A1 -->
   // <!-- there is no Sigmaf, and no U+03A2 character either -->
  -        {"Sigma", "931"},  //greek capital letter sigma,U+03A3 ISOgrk3 -->
  -        {"Tau", "932"},  //greek capital letter tau, U+03A4 -->
  -        {"Upsilon", "933"},  //greek capital letter upsilon,U+03A5 ISOgrk3 -->
  -        {"Phi", "934"},  //greek capital letter phi,U+03A6 ISOgrk3 -->
  -        {"Chi", "935"},  //greek capital letter chi, U+03A7 -->
  -        {"Psi", "936"},  //greek capital letter psi,U+03A8 ISOgrk3 -->
  -        {"Omega", "937"},  //greek capital letter omega,U+03A9 ISOgrk3 -->
  -        {"alpha", "945"},  //greek small letter alpha,U+03B1 ISOgrk3 -->
  -        {"beta", "946"},  //greek small letter beta, U+03B2 ISOgrk3 -->
  -        {"gamma", "947"},  //greek small letter gamma,U+03B3 ISOgrk3 -->
  -        {"delta", "948"},  //greek small letter delta,U+03B4 ISOgrk3 -->
  -        {"epsilon", "949"},  //greek small letter epsilon,U+03B5 ISOgrk3 -->
  -        {"zeta", "950"},  //greek small letter zeta, U+03B6 ISOgrk3 -->
  -        {"eta", "951"},  //greek small letter eta, U+03B7 ISOgrk3 -->
  -        {"theta", "952"},  //greek small letter theta,U+03B8 ISOgrk3 -->
  -        {"iota", "953"},  //greek small letter iota, U+03B9 ISOgrk3 -->
  -        {"kappa", "954"},  //greek small letter kappa,U+03BA ISOgrk3 -->
  -        {"lambda", "955"},  //greek small letter lambda,U+03BB ISOgrk3 -->
  -        {"mu", "956"},  //greek small letter mu, U+03BC ISOgrk3 -->
  -        {"nu", "957"},  //greek small letter nu, U+03BD ISOgrk3 -->
  -        {"xi", "958"},  //greek small letter xi, U+03BE ISOgrk3 -->
  -        {"omicron", "959"},  //greek small letter omicron, U+03BF NEW -->
  -        {"pi", "960"},  //greek small letter pi, U+03C0 ISOgrk3 -->
  -        {"rho", "961"},  //greek small letter rho, U+03C1 ISOgrk3 -->
  -        {"sigmaf", "962"},  //greek small letter final sigma,U+03C2 ISOgrk3 -->
  -        {"sigma", "963"},  //greek small letter sigma,U+03C3 ISOgrk3 -->
  -        {"tau", "964"},  //greek small letter tau, U+03C4 ISOgrk3 -->
  -        {"upsilon", "965"},  //greek small letter upsilon,U+03C5 ISOgrk3 -->
  -        {"phi", "966"},  //greek small letter phi, U+03C6 ISOgrk3 -->
  -        {"chi", "967"},  //greek small letter chi, U+03C7 ISOgrk3 -->
  -        {"psi", "968"},  //greek small letter psi, U+03C8 ISOgrk3 -->
  -        {"omega", "969"},  //greek small letter omega,U+03C9 ISOgrk3 -->
  -        {"thetasym", "977"},  //greek small letter theta symbol,U+03D1 NEW -->
  -        {"upsih", "978"},  //greek upsilon with hook symbol,U+03D2 NEW -->
  -        {"piv", "982"},  //greek pi symbol, U+03D6 ISOgrk3 -->
  +        {"Sigma", "931"}, //greek capital letter sigma,U+03A3 ISOgrk3 -->
  +        {"Tau", "932"}, //greek capital letter tau, U+03A4 -->
  +        {"Upsilon", "933"}, //greek capital letter upsilon,U+03A5 ISOgrk3 -->
  +        {"Phi", "934"}, //greek capital letter phi,U+03A6 ISOgrk3 -->
  +        {"Chi", "935"}, //greek capital letter chi, U+03A7 -->
  +        {"Psi", "936"}, //greek capital letter psi,U+03A8 ISOgrk3 -->
  +        {"Omega", "937"}, //greek capital letter omega,U+03A9 ISOgrk3 -->
  +        {"alpha", "945"}, //greek small letter alpha,U+03B1 ISOgrk3 -->
  +        {"beta", "946"}, //greek small letter beta, U+03B2 ISOgrk3 -->
  +        {"gamma", "947"}, //greek small letter gamma,U+03B3 ISOgrk3 -->
  +        {"delta", "948"}, //greek small letter delta,U+03B4 ISOgrk3 -->
  +        {"epsilon", "949"}, //greek small letter epsilon,U+03B5 ISOgrk3 -->
  +        {"zeta", "950"}, //greek small letter zeta, U+03B6 ISOgrk3 -->
  +        {"eta", "951"}, //greek small letter eta, U+03B7 ISOgrk3 -->
  +        {"theta", "952"}, //greek small letter theta,U+03B8 ISOgrk3 -->
  +        {"iota", "953"}, //greek small letter iota, U+03B9 ISOgrk3 -->
  +        {"kappa", "954"}, //greek small letter kappa,U+03BA ISOgrk3 -->
  +        {"lambda", "955"}, //greek small letter lambda,U+03BB ISOgrk3 -->
  +        {"mu", "956"}, //greek small letter mu, U+03BC ISOgrk3 -->
  +        {"nu", "957"}, //greek small letter nu, U+03BD ISOgrk3 -->
  +        {"xi", "958"}, //greek small letter xi, U+03BE ISOgrk3 -->
  +        {"omicron", "959"}, //greek small letter omicron, U+03BF NEW -->
  +        {"pi", "960"}, //greek small letter pi, U+03C0 ISOgrk3 -->
  +        {"rho", "961"}, //greek small letter rho, U+03C1 ISOgrk3 -->
  +        {"sigmaf", "962"}, //greek small letter final sigma,U+03C2 ISOgrk3 -->
  +        {"sigma", "963"}, //greek small letter sigma,U+03C3 ISOgrk3 -->
  +        {"tau", "964"}, //greek small letter tau, U+03C4 ISOgrk3 -->
  +        {"upsilon", "965"}, //greek small letter upsilon,U+03C5 ISOgrk3 -->
  +        {"phi", "966"}, //greek small letter phi, U+03C6 ISOgrk3 -->
  +        {"chi", "967"}, //greek small letter chi, U+03C7 ISOgrk3 -->
  +        {"psi", "968"}, //greek small letter psi, U+03C8 ISOgrk3 -->
  +        {"omega", "969"}, //greek small letter omega,U+03C9 ISOgrk3 -->
  +        {"thetasym", "977"}, //greek small letter theta symbol,U+03D1 NEW -->
  +        {"upsih", "978"}, //greek upsilon with hook symbol,U+03D2 NEW -->
  +        {"piv", "982"}, //greek pi symbol, U+03D6 ISOgrk3 -->
   // <!-- General Punctuation -->
  -        {"bull", "8226"},  //bullet = black small circle,U+2022 ISOpub  -->
  +        {"bull", "8226"}, //bullet = black small circle,U+2022 ISOpub  -->
   // <!-- bullet is NOT the same as bullet operator, U+2219 -->
  -        {"hellip", "8230"},  //horizontal ellipsis = three dot leader,U+2026 ISOpub  -->
  -        {"prime", "8242"},  //prime = minutes = feet, U+2032 ISOtech -->
  -        {"Prime", "8243"},  //double prime = seconds = inches,U+2033 ISOtech -->
  -        {"oline", "8254"},  //overline = spacing overscore,U+203E NEW -->
  -        {"frasl", "8260"},  //fraction slash, U+2044 NEW -->
  +        {"hellip", "8230"}, //horizontal ellipsis = three dot leader,U+2026 ISOpub  -->
  +        {"prime", "8242"}, //prime = minutes = feet, U+2032 ISOtech -->
  +        {"Prime", "8243"}, //double prime = seconds = inches,U+2033 ISOtech -->
  +        {"oline", "8254"}, //overline = spacing overscore,U+203E NEW -->
  +        {"frasl", "8260"}, //fraction slash, U+2044 NEW -->
   // <!-- Letterlike Symbols -->
  -        {"weierp", "8472"},  //script capital P = power set= Weierstrass p, U+2118 ISOamso
-->
  -        {"image", "8465"},  //blackletter capital I = imaginary part,U+2111 ISOamso -->
  -        {"real", "8476"},  //blackletter capital R = real part symbol,U+211C ISOamso -->
  -        {"trade", "8482"},  //trade mark sign, U+2122 ISOnum -->
  -        {"alefsym", "8501"},  //alef symbol = first transfinite cardinal,U+2135 NEW -->
  +        {"weierp", "8472"}, //script capital P = power set= Weierstrass p, U+2118 ISOamso
-->
  +        {"image", "8465"}, //blackletter capital I = imaginary part,U+2111 ISOamso -->
  +        {"real", "8476"}, //blackletter capital R = real part symbol,U+211C ISOamso -->
  +        {"trade", "8482"}, //trade mark sign, U+2122 ISOnum -->
  +        {"alefsym", "8501"}, //alef symbol = first transfinite cardinal,U+2135 NEW -->
   // <!-- alef symbol is NOT the same as hebrew letter alef,U+05D0 although the same glyph
could be used to depict both characters -->
   // <!-- Arrows -->
  -        {"larr", "8592"},  //leftwards arrow, U+2190 ISOnum -->
  -        {"uarr", "8593"},  //upwards arrow, U+2191 ISOnum-->
  -        {"rarr", "8594"},  //rightwards arrow, U+2192 ISOnum -->
  -        {"darr", "8595"},  //downwards arrow, U+2193 ISOnum -->
  -        {"harr", "8596"},  //left right arrow, U+2194 ISOamsa -->
  -        {"crarr", "8629"},  //downwards arrow with corner leftwards= carriage return, U+21B5
NEW -->
  -        {"lArr", "8656"},  //leftwards double arrow, U+21D0 ISOtech -->
  +        {"larr", "8592"}, //leftwards arrow, U+2190 ISOnum -->
  +        {"uarr", "8593"}, //upwards arrow, U+2191 ISOnum-->
  +        {"rarr", "8594"}, //rightwards arrow, U+2192 ISOnum -->
  +        {"darr", "8595"}, //downwards arrow, U+2193 ISOnum -->
  +        {"harr", "8596"}, //left right arrow, U+2194 ISOamsa -->
  +        {"crarr", "8629"}, //downwards arrow with corner leftwards= carriage return, U+21B5
NEW -->
  +        {"lArr", "8656"}, //leftwards double arrow, U+21D0 ISOtech -->
   // <!-- ISO 10646 does not say that lArr is the same as the 'is implied by' arrowbut
also does not have any other character for that function. So ? lArr canbe used for 'is implied
by' as ISOtech suggests -->
  -        {"uArr", "8657"},  //upwards double arrow, U+21D1 ISOamsa -->
  -        {"rArr", "8658"},  //rightwards double arrow,U+21D2 ISOtech -->
  +        {"uArr", "8657"}, //upwards double arrow, U+21D1 ISOamsa -->
  +        {"rArr", "8658"}, //rightwards double arrow,U+21D2 ISOtech -->
   // <!-- ISO 10646 does not say this is the 'implies' character but does not have another
character with this function so ?rArr can be used for 'implies' as ISOtech suggests -->
  -        {"dArr", "8659"},  //downwards double arrow, U+21D3 ISOamsa -->
  -        {"hArr", "8660"},  //left right double arrow,U+21D4 ISOamsa -->
  +        {"dArr", "8659"}, //downwards double arrow, U+21D3 ISOamsa -->
  +        {"hArr", "8660"}, //left right double arrow,U+21D4 ISOamsa -->
   // <!-- Mathematical Operators -->
  -        {"forall", "8704"},  //for all, U+2200 ISOtech -->
  -        {"part", "8706"},  //partial differential, U+2202 ISOtech  -->
  -        {"exist", "8707"},  //there exists, U+2203 ISOtech -->
  -        {"empty", "8709"},  //empty set = null set = diameter,U+2205 ISOamso -->
  -        {"nabla", "8711"},  //nabla = backward difference,U+2207 ISOtech -->
  -        {"isin", "8712"},  //element of, U+2208 ISOtech -->
  -        {"notin", "8713"},  //not an element of, U+2209 ISOtech -->
  -        {"ni", "8715"},  //contains as member, U+220B ISOtech -->
  +        {"forall", "8704"}, //for all, U+2200 ISOtech -->
  +        {"part", "8706"}, //partial differential, U+2202 ISOtech  -->
  +        {"exist", "8707"}, //there exists, U+2203 ISOtech -->
  +        {"empty", "8709"}, //empty set = null set = diameter,U+2205 ISOamso -->
  +        {"nabla", "8711"}, //nabla = backward difference,U+2207 ISOtech -->
  +        {"isin", "8712"}, //element of, U+2208 ISOtech -->
  +        {"notin", "8713"}, //not an element of, U+2209 ISOtech -->
  +        {"ni", "8715"}, //contains as member, U+220B ISOtech -->
   // <!-- should there be a more memorable name than 'ni'? -->
  -        {"prod", "8719"},  //n-ary product = product sign,U+220F ISOamsb -->
  +        {"prod", "8719"}, //n-ary product = product sign,U+220F ISOamsb -->
   // <!-- prod is NOT the same character as U+03A0 'greek capital letter pi' thoughthe
same glyph might be used for both -->
  -        {"sum", "8721"},  //n-ary sumation, U+2211 ISOamsb -->
  +        {"sum", "8721"}, //n-ary sumation, U+2211 ISOamsb -->
   // <!-- sum is NOT the same character as U+03A3 'greek capital letter sigma'though the
same glyph might be used for both -->
  -        {"minus", "8722"},  //minus sign, U+2212 ISOtech -->
  -        {"lowast", "8727"},  //asterisk operator, U+2217 ISOtech -->
  -        {"radic", "8730"},  //square root = radical sign,U+221A ISOtech -->
  -        {"prop", "8733"},  //proportional to, U+221D ISOtech -->
  -        {"infin", "8734"},  //infinity, U+221E ISOtech -->
  -        {"ang", "8736"},  //angle, U+2220 ISOamso -->
  -        {"and", "8743"},  //logical and = wedge, U+2227 ISOtech -->
  -        {"or", "8744"},  //logical or = vee, U+2228 ISOtech -->
  -        {"cap", "8745"},  //intersection = cap, U+2229 ISOtech -->
  -        {"cup", "8746"},  //union = cup, U+222A ISOtech -->
  -        {"int", "8747"},  //integral, U+222B ISOtech -->
  -        {"there4", "8756"},  //therefore, U+2234 ISOtech -->
  -        {"sim", "8764"},  //tilde operator = varies with = similar to,U+223C ISOtech -->
  +        {"minus", "8722"}, //minus sign, U+2212 ISOtech -->
  +        {"lowast", "8727"}, //asterisk operator, U+2217 ISOtech -->
  +        {"radic", "8730"}, //square root = radical sign,U+221A ISOtech -->
  +        {"prop", "8733"}, //proportional to, U+221D ISOtech -->
  +        {"infin", "8734"}, //infinity, U+221E ISOtech -->
  +        {"ang", "8736"}, //angle, U+2220 ISOamso -->
  +        {"and", "8743"}, //logical and = wedge, U+2227 ISOtech -->
  +        {"or", "8744"}, //logical or = vee, U+2228 ISOtech -->
  +        {"cap", "8745"}, //intersection = cap, U+2229 ISOtech -->
  +        {"cup", "8746"}, //union = cup, U+222A ISOtech -->
  +        {"int", "8747"}, //integral, U+222B ISOtech -->
  +        {"there4", "8756"}, //therefore, U+2234 ISOtech -->
  +        {"sim", "8764"}, //tilde operator = varies with = similar to,U+223C ISOtech -->
   // <!-- tilde operator is NOT the same character as the tilde, U+007E,although the same
glyph might be used to represent both  -->
  -        {"cong", "8773"},  //approximately equal to, U+2245 ISOtech -->
  -        {"asymp", "8776"},  //almost equal to = asymptotic to,U+2248 ISOamsr -->
  -        {"ne", "8800"},  //not equal to, U+2260 ISOtech -->
  -        {"equiv", "8801"},  //identical to, U+2261 ISOtech -->
  -        {"le", "8804"},  //less-than or equal to, U+2264 ISOtech -->
  -        {"ge", "8805"},  //greater-than or equal to,U+2265 ISOtech -->
  -        {"sub", "8834"},  //subset of, U+2282 ISOtech -->
  -        {"sup", "8835"},  //superset of, U+2283 ISOtech -->
  +        {"cong", "8773"}, //approximately equal to, U+2245 ISOtech -->
  +        {"asymp", "8776"}, //almost equal to = asymptotic to,U+2248 ISOamsr -->
  +        {"ne", "8800"}, //not equal to, U+2260 ISOtech -->
  +        {"equiv", "8801"}, //identical to, U+2261 ISOtech -->
  +        {"le", "8804"}, //less-than or equal to, U+2264 ISOtech -->
  +        {"ge", "8805"}, //greater-than or equal to,U+2265 ISOtech -->
  +        {"sub", "8834"}, //subset of, U+2282 ISOtech -->
  +        {"sup", "8835"}, //superset of, U+2283 ISOtech -->
   // <!-- note that nsup, 'not a superset of, U+2283' is not covered by the Symbol font
encoding and is not included. Should it be, for symmetry?It is in ISOamsn  --> <!ENTITY
nsub", "8836"},  //not a subset of, U+2284 ISOamsn -->
  -        {"sube", "8838"},  //subset of or equal to, U+2286 ISOtech -->
  -        {"supe", "8839"},  //superset of or equal to,U+2287 ISOtech -->
  -        {"oplus", "8853"},  //circled plus = direct sum,U+2295 ISOamsb -->
  -        {"otimes", "8855"},  //circled times = vector product,U+2297 ISOamsb -->
  -        {"perp", "8869"},  //up tack = orthogonal to = perpendicular,U+22A5 ISOtech -->
  -        {"sdot", "8901"},  //dot operator, U+22C5 ISOamsb -->
  +        {"sube", "8838"}, //subset of or equal to, U+2286 ISOtech -->
  +        {"supe", "8839"}, //superset of or equal to,U+2287 ISOtech -->
  +        {"oplus", "8853"}, //circled plus = direct sum,U+2295 ISOamsb -->
  +        {"otimes", "8855"}, //circled times = vector product,U+2297 ISOamsb -->
  +        {"perp", "8869"}, //up tack = orthogonal to = perpendicular,U+22A5 ISOtech -->
  +        {"sdot", "8901"}, //dot operator, U+22C5 ISOamsb -->
   // <!-- dot operator is NOT the same character as U+00B7 middle dot -->
   // <!-- Miscellaneous Technical -->
  -        {"lceil", "8968"},  //left ceiling = apl upstile,U+2308 ISOamsc  -->
  -        {"rceil", "8969"},  //right ceiling, U+2309 ISOamsc  -->
  -        {"lfloor", "8970"},  //left floor = apl downstile,U+230A ISOamsc  -->
  -        {"rfloor", "8971"},  //right floor, U+230B ISOamsc  -->
  -        {"lang", "9001"},  //left-pointing angle bracket = bra,U+2329 ISOtech -->
  +        {"lceil", "8968"}, //left ceiling = apl upstile,U+2308 ISOamsc  -->
  +        {"rceil", "8969"}, //right ceiling, U+2309 ISOamsc  -->
  +        {"lfloor", "8970"}, //left floor = apl downstile,U+230A ISOamsc  -->
  +        {"rfloor", "8971"}, //right floor, U+230B ISOamsc  -->
  +        {"lang", "9001"}, //left-pointing angle bracket = bra,U+2329 ISOtech -->
   // <!-- lang is NOT the same character as U+003C 'less than' or U+2039 'single left-pointing
angle quotation mark' -->
  -        {"rang", "9002"},  //right-pointing angle bracket = ket,U+232A ISOtech -->
  +        {"rang", "9002"}, //right-pointing angle bracket = ket,U+232A ISOtech -->
   // <!-- rang is NOT the same character as U+003E 'greater than' or U+203A 'single right-pointing
angle quotation mark' -->
   // <!-- Geometric Shapes -->
  -        {"loz", "9674"},  //lozenge, U+25CA ISOpub -->
  +        {"loz", "9674"}, //lozenge, U+25CA ISOpub -->
   // <!-- Miscellaneous Symbols -->
  -        {"spades", "9824"},  //black spade suit, U+2660 ISOpub -->
  +        {"spades", "9824"}, //black spade suit, U+2660 ISOpub -->
   // <!-- black here seems to mean filled as opposed to hollow -->
  -        {"clubs", "9827"},  //black club suit = shamrock,U+2663 ISOpub -->
  -        {"hearts", "9829"},  //black heart suit = valentine,U+2665 ISOpub -->
  -        {"diams", "9830"},  //black diamond suit, U+2666 ISOpub -->
  +        {"clubs", "9827"}, //black club suit = shamrock,U+2663 ISOpub -->
  +        {"hearts", "9829"}, //black heart suit = valentine,U+2665 ISOpub -->
  +        {"diams", "9830"}, //black diamond suit, U+2666 ISOpub -->
   
   // <!-- Latin Extended-A -->
  -        {"OElig", "338"},  //  -- latin capital ligature OE,U+0152 ISOlat2 -->
  -        {"oelig", "339"},  //  -- latin small ligature oe, U+0153 ISOlat2 -->
  +        {"OElig", "338"}, //  -- latin capital ligature OE,U+0152 ISOlat2 -->
  +        {"oelig", "339"}, //  -- latin small ligature oe, U+0153 ISOlat2 -->
   // <!-- ligature is a misnomer, this is a separate character in some languages -->
  -        {"Scaron", "352"},  //  -- latin capital letter S with caron,U+0160 ISOlat2 -->
  -        {"scaron", "353"},  //  -- latin small letter s with caron,U+0161 ISOlat2 -->
  -        {"Yuml", "376"},  //  -- latin capital letter Y with diaeresis,U+0178 ISOlat2 -->
  +        {"Scaron", "352"}, //  -- latin capital letter S with caron,U+0160 ISOlat2 -->
  +        {"scaron", "353"}, //  -- latin small letter s with caron,U+0161 ISOlat2 -->
  +        {"Yuml", "376"}, //  -- latin capital letter Y with diaeresis,U+0178 ISOlat2 -->
   // <!-- Spacing Modifier Letters -->
  -        {"circ", "710"},  //  -- modifier letter circumflex accent,U+02C6 ISOpub -->
  -        {"tilde", "732"},  //small tilde, U+02DC ISOdia -->
  +        {"circ", "710"}, //  -- modifier letter circumflex accent,U+02C6 ISOpub -->
  +        {"tilde", "732"}, //small tilde, U+02DC ISOdia -->
   // <!-- General Punctuation -->
  -        {"ensp", "8194"},  //en space, U+2002 ISOpub -->
  -        {"emsp", "8195"},  //em space, U+2003 ISOpub -->
  -        {"thinsp", "8201"},  //thin space, U+2009 ISOpub -->
  -        {"zwnj", "8204"},  //zero width non-joiner,U+200C NEW RFC 2070 -->
  -        {"zwj", "8205"},  //zero width joiner, U+200D NEW RFC 2070 -->
  -        {"lrm", "8206"},  //left-to-right mark, U+200E NEW RFC 2070 -->
  -        {"rlm", "8207"},  //right-to-left mark, U+200F NEW RFC 2070 -->
  -        {"ndash", "8211"},  //en dash, U+2013 ISOpub -->
  -        {"mdash", "8212"},  //em dash, U+2014 ISOpub -->
  -        {"lsquo", "8216"},  //left single quotation mark,U+2018 ISOnum -->
  -        {"rsquo", "8217"},  //right single quotation mark,U+2019 ISOnum -->
  -        {"sbquo", "8218"},  //single low-9 quotation mark, U+201A NEW -->
  -        {"ldquo", "8220"},  //left double quotation mark,U+201C ISOnum -->
  -        {"rdquo", "8221"},  //right double quotation mark,U+201D ISOnum -->
  -        {"bdquo", "8222"},  //double low-9 quotation mark, U+201E NEW -->
  -        {"dagger", "8224"},  //dagger, U+2020 ISOpub -->
  -        {"Dagger", "8225"},  //double dagger, U+2021 ISOpub -->
  -        {"permil", "8240"},  //per mille sign, U+2030 ISOtech -->
  -        {"lsaquo", "8249"},  //single left-pointing angle quotation mark,U+2039 ISO proposed
-->
  +        {"ensp", "8194"}, //en space, U+2002 ISOpub -->
  +        {"emsp", "8195"}, //em space, U+2003 ISOpub -->
  +        {"thinsp", "8201"}, //thin space, U+2009 ISOpub -->
  +        {"zwnj", "8204"}, //zero width non-joiner,U+200C NEW RFC 2070 -->
  +        {"zwj", "8205"}, //zero width joiner, U+200D NEW RFC 2070 -->
  +        {"lrm", "8206"}, //left-to-right mark, U+200E NEW RFC 2070 -->
  +        {"rlm", "8207"}, //right-to-left mark, U+200F NEW RFC 2070 -->
  +        {"ndash", "8211"}, //en dash, U+2013 ISOpub -->
  +        {"mdash", "8212"}, //em dash, U+2014 ISOpub -->
  +        {"lsquo", "8216"}, //left single quotation mark,U+2018 ISOnum -->
  +        {"rsquo", "8217"}, //right single quotation mark,U+2019 ISOnum -->
  +        {"sbquo", "8218"}, //single low-9 quotation mark, U+201A NEW -->
  +        {"ldquo", "8220"}, //left double quotation mark,U+201C ISOnum -->
  +        {"rdquo", "8221"}, //right double quotation mark,U+201D ISOnum -->
  +        {"bdquo", "8222"}, //double low-9 quotation mark, U+201E NEW -->
  +        {"dagger", "8224"}, //dagger, U+2020 ISOpub -->
  +        {"Dagger", "8225"}, //double dagger, U+2021 ISOpub -->
  +        {"permil", "8240"}, //per mille sign, U+2030 ISOtech -->
  +        {"lsaquo", "8249"}, //single left-pointing angle quotation mark,U+2039 ISO proposed
-->
   // <!-- lsaquo is proposed but not yet ISO standardized -->
  -        {"rsaquo", "8250"},  //single right-pointing angle quotation mark,U+203A ISO proposed
-->
  +        {"rsaquo", "8250"}, //single right-pointing angle quotation mark,U+203A ISO proposed
-->
   // <!-- rsaquo is proposed but not yet ISO standardized -->
  -        {"euro", "8364"},   //  -- euro sign, U+20AC NEW -->
  -     };
  +        {"euro", "8364"}, //  -- euro sign, U+20AC NEW -->
  +    };
   
       public static Entities XML;
       public static Entities HTML32;
  @@ -392,28 +390,119 @@
           HTML40.addEntities(html40);
       }
   
  -    //todo: refactor into a bi-di map object (or look for one and use it)
  -    private Map mapNameToValue;
  -    private Map mapValueToName;
  -
  -    private Entities() {
  -        mapNameToValue = new HashMap();
  -        mapValueToName = new HashMap();
  +    static class IntMap {
  +        private Map mapNameToValue = new HashMap();
  +        private Map mapValueToName = new HashMap();
  +
  +        public void add(String name, int value) {
  +            mapNameToValue.put(name, new Integer(value));
  +            mapValueToName.put(new Integer(value), name);
  +        }
  +
  +        private String name(int value) {
  +            return (String) mapValueToName.get(new Integer(value));
  +        }
  +
  +        private int value(String name) {
  +            Object value = mapNameToValue.get(name);
  +            if (value == null)
  +                return -1;
  +            return ((Integer) value).intValue();
  +        }
       }
   
  -    private void addEntities(Object[][] entityArray) {
  -        //todo: analyze whether it's more efficient to use strings or integers as the value
  +    IntMap map = new IntMap();
  +
  +    public void addEntities(String[][] entityArray) {
           for (int i = 0; i < entityArray.length; ++i) {
  -            mapNameToValue.put(entityArray[i][0], new Integer((String) entityArray[i][1]));
  -            mapValueToName.put(new Integer((String) entityArray[i][1]), entityArray[i][0]);
  +            addEntity(entityArray[i][0], Integer.parseInt(entityArray[i][1]));
           }
       }
   
  +    public void addEntity(String name, int value) {
  +        map.add(name, value);
  +    }
  +
       public String entityName(int value) {
  -        return (String) mapValueToName.get(new Integer(value));
  +        return map.name(value);
       }
   
  -    public Integer entityValue(String name) {
  -        return (Integer) mapNameToValue.get(name);
  +
  +    public int entityValue(String name) {
  +        return map.value(name);
  +    }
  +
  +    /**
  +     * Escapes the characters in a <code>String</code>.
  +     * For example, if you have called addEntity("foo", 0xA1),
  +     * escape("\u00A1") will return "&foo;"
  +     *
  +     * @param str The <code>String</code> to escape.
  +     * @return A new escaped <code>String</code>.
  +     */
  +    public String escape(String str) {
  +        StringBuffer buf = new StringBuffer(str.length() * 2);
  +        int i;
  +        for (i = 0; i < str.length(); ++i) {
  +            char ch = str.charAt(i);
  +            String entityName = this.entityName(ch);
  +            if (entityName == null) {
  +                if (((int) ch) > 0x7F) {
  +                    int intValue = ((int) ch);
  +                    buf.append("&#");
  +                    buf.append(intValue);
  +                    buf.append(';');
  +                } else {
  +                    buf.append(ch);
  +                }
  +            } else {
  +                buf.append('&');
  +                buf.append(entityName);
  +                buf.append(';');
  +            }
  +        }
  +        return buf.toString();
       }
  +
  +    /**
  +     * Unescapes the entities in a <code>String</code>.
  +     * For example, if you have called addEntity("foo", 0xA1),
  +     * unescape("&foo;") will return "\u00A1"
  +     *
  +     * @param str The <code>String</code> to escape.
  +     * @return A new escaped <code>String</code>.
  +     */
  +    public String unescape(String str) {
  +        StringBuffer buf = new StringBuffer(str.length());
  +        int i;
  +        for (i = 0; i < str.length(); ++i) {
  +            char ch = str.charAt(i);
  +            if (ch == '&') {
  +                int semi = str.indexOf(';', i + 1);
  +                if (semi == -1) {
  +                    buf.append(ch);
  +                    continue;
  +                }
  +                String entityName = str.substring(i + 1, semi);
  +                int entityValue;
  +                if (entityName.charAt(0) == '#') {
  +                    entityValue = Integer.parseInt(entityName.substring(1));
  +                } else {
  +                    entityValue = this.entityValue(entityName);
  +                }
  +                if (entityValue == -1) {
  +                    buf.append('&');
  +                    buf.append(entityName);
  +                    buf.append(';');
  +                } else {
  +                    buf.append((char) (entityValue));
  +                }
  +                i = semi;
  +            } else {
  +                buf.append(ch);
  +            }
  +        }
  +        return buf.toString();
  +    }
  +
   }
  
  
  
  1.12      +3 -59     jakarta-commons/lang/src/java/org/apache/commons/lang/StringEscapeUtils.java
  
  Index: StringEscapeUtils.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/StringEscapeUtils.java,v
  retrieving revision 1.11
  retrieving revision 1.12
  diff -u -r1.11 -r1.12
  --- StringEscapeUtils.java	18 May 2003 00:10:38 -0000	1.11
  +++ StringEscapeUtils.java	24 May 2003 04:35:06 -0000	1.12
  @@ -461,68 +461,12 @@
           return unescapeEntities(str, Entities.XML);
       }
   
  -    /**
  -     * Escapes the characters in a <code>String</code> using the the given
<code>Entities</code>.
  -     * 
  -     * @param str The <code>String</code> to escape.
  -     * @param entities The <code>Entities</code> to escape the <code>String</code>
with.
  -     * @return A new escaped <code>String</code>.
  -     */
       private static String escapeEntities(String str, Entities entities) {
  -        StringBuffer buf = new StringBuffer(str.length() * 2);
  -        int i;
  -        for (i = 0; i < str.length(); ++i) {
  -            char ch = str.charAt(i);
  -            String entity = entities.entityName(ch);
  -            if (entity == null) {
  -                if (((int) ch) > 0x7F) {
  -                    int intValue = ((int) ch);
  -                    buf.append("&#");
  -                    buf.append(intValue);
  -                    buf.append(';');
  -                } else {
  -                    buf.append(ch);
  -                }
  -            } else {
  -                buf.append('&');
  -                buf.append(entity);
  -                buf.append(';');
  -            }
  -        }
  -        return buf.toString();
  +        return entities.escape(str);
       }
   
       private static String unescapeEntities(String str, Entities entities) {
  -        StringBuffer buf = new StringBuffer(str.length());
  -        int i;
  -        for (i = 0; i < str.length(); ++i) {
  -            char ch = str.charAt(i);
  -            if (ch == '&') {
  -                int semi = str.indexOf(';', i + 1);
  -                if (semi == -1) {
  -                    buf.append(ch);
  -                    continue;
  -                }
  -                String entity = str.substring(i + 1, semi);
  -                Integer iso;
  -                if (entity.charAt(0) == '#') {
  -                    iso = new Integer(entity.substring(1));
  -                } else {
  -                    iso = entities.entityValue(entity);
  -                }
  -                if (iso == null) {
  -                    buf.append('&');
  -                    buf.append(entity);
  -                    buf.append(';');
  -                } else {
  -                    buf.append((char) (iso.intValue()));
  -                }
  -                i = semi;
  -            } else {
  -                buf.append(ch);
  -            }
  -        }
  -        return buf.toString();
  +        return entities.unescape(str);
       }
   
   }
  
  
  
  1.7       +1 -8      jakarta-commons/lang/src/test/org/apache/commons/lang/StringEscapeUtilsTest.java
  
  Index: StringEscapeUtilsTest.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/test/org/apache/commons/lang/StringEscapeUtilsTest.java,v
  retrieving revision 1.6
  retrieving revision 1.7
  diff -u -r1.6 -r1.7
  --- StringEscapeUtilsTest.java	16 May 2003 22:08:31 -0000	1.6
  +++ StringEscapeUtilsTest.java	24 May 2003 04:35:07 -0000	1.7
  @@ -161,13 +161,6 @@
       // HTML and XML
       //--------------------------------------------------------------
   
  -    public void testEntitiesObject() throws Exception
  -    {
  -        assertEquals("gt", Entities.XML.entityName('>'));
  -        assertEquals(new Integer('>'), Entities.XML.entityValue("gt"));
  -        assertEquals(null, Entities.XML.entityValue("xyzzy"));
  -    }
  -
       String[][] htmlEscapes = {
           {"no escaping", "plain text", "plain text"},
           {"no escaping", "plain text", "plain text"},
  
  
  
  1.1                  jakarta-commons/lang/src/test/org/apache/commons/lang/EntitiesTest.java
  
  Index: EntitiesTest.java
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2002-2003 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution, if
   *    any, must include the following acknowlegement:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowlegement may appear in the software itself,
   *    if and wherever such third-party acknowlegements normally appear.
   *
   * 4. The names "The Jakarta Project", "Commons", and "Apache Software
   *    Foundation" must not be used to endorse or promote products derived
   *    from this software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache"
   *    nor may "Apache" appear in their names without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  package org.apache.commons.lang;
  
  import java.io.IOException;
  
  import junit.framework.Test;
  import junit.framework.TestCase;
  import junit.framework.TestSuite;
  import junit.textui.TestRunner;
  
  /**
   * Unit tests for {@link StringEscapeUtils}.
   *
   * @author of original StringUtilsTest.testEscape = ?
   * @author <a href="mailto:alex@purpletech.com">Alexander Day Chaffee</a>
   * @version $Id: EntitiesTest.java,v 1.1 2003/05/24 04:35:07 alex Exp $
   */
  public class EntitiesTest extends TestCase
  {
  
      Entities entities;
  
      public void setUp()
      {
          entities = new Entities();
          entities.addEntity("foo", 161);
          entities.addEntity("bar", 162);
      }
  
      public void testEscapeNamedEntity() throws Exception
      {
          assertEquals("&foo;", entities.escape("\u00A1"));
          assertEquals("x&foo;", entities.escape("x\u00A1"));
          assertEquals("&foo;x", entities.escape("\u00A1x"));
          assertEquals("x&foo;x", entities.escape("x\u00A1x"));
          assertEquals("&foo;&bar;", entities.escape("\u00A1\u00A2"));
      }
  
      public void testUnescapeNamedEntity() throws Exception
      {
          assertEquals("\u00A1", entities.unescape("&foo;"));
          assertEquals("x\u00A1", entities.unescape("x&foo;"));
          assertEquals("\u00A1x", entities.unescape("&foo;x"));
          assertEquals("x\u00A1x", entities.unescape("x&foo;x"));
          assertEquals("\u00A1\u00A2", entities.unescape("&foo;&bar;"));
      }
  
      public void testUnescapeUnknownEntity() throws Exception
      {
          assertEquals("&zzzz;", entities.unescape("&zzzz;"));
      }
  
      public void testAddEntitiesArray() throws Exception
      {
          String[][] array = {{"foo", "100"}, {"bar", "101"}};
          Entities e = new Entities();
          e.addEntities(array);
          assertEquals("foo", e.entityName(100));
          assertEquals("bar", e.entityName(101));
          assertEquals(100, e.entityValue("foo"));
          assertEquals(101, e.entityValue("bar"));
      }
  
      public void testEntitiesXmlObject() throws Exception
      {
          assertEquals("gt", Entities.XML.entityName('>'));
          assertEquals((int) '>', Entities.XML.entityValue("gt"));
          assertEquals(-1, Entities.XML.entityValue("xyzzy"));
      }
  }
  
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org


Mime
View raw message