The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

778 lines
34KB

  1. /*
  2. ==============================================================================
  3. This file is part of the JUCE library.
  4. Copyright (c) 2013 - Raw Material Software Ltd.
  5. Permission is granted to use this software under the terms of either:
  6. a) the GPL v2 (or any later version)
  7. b) the Affero GPL v3
  8. Details of these licenses can be found at: www.gnu.org/licenses
  9. JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  10. WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  11. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  12. ------------------------------------------------------------------------------
  13. To release a closed-source product which uses JUCE, commercial licenses are
  14. available: visit www.juce.com for more information.
  15. ==============================================================================
  16. */
  17. namespace
  18. {
  19. //==========================================================================
  20. template <typename CharPointerType>
  21. class OSCPatternMatcherImpl
  22. {
  23. typedef CharPointerType CharPtr;
  24. public:
  25. //==========================================================================
  26. static bool match (CharPtr pattern, CharPtr patternEnd, CharPtr target, CharPtr targetEnd)
  27. {
  28. if (pattern == patternEnd)
  29. return matchTerminator (target, targetEnd);
  30. const juce_wchar c = pattern.getAndAdvance();
  31. switch (c)
  32. {
  33. case '?': return matchAnyChar (pattern, patternEnd, target, targetEnd);
  34. case '*': return matchAnyOrNoChars (pattern, patternEnd, target, targetEnd);
  35. case '{': return matchInsideStringSet (pattern, patternEnd, target, targetEnd);
  36. case '[': return matchInsideCharSet (pattern, patternEnd, target, targetEnd);
  37. default: return matchChar (c, pattern, patternEnd, target, targetEnd);
  38. }
  39. }
  40. private:
  41. //==========================================================================
  42. static bool matchTerminator (CharPtr target, CharPtr targetEnd)
  43. {
  44. return target == targetEnd;
  45. }
  46. //==========================================================================
  47. static bool matchChar (juce_wchar c, CharPtr pattern, CharPtr patternEnd, CharPtr target, CharPtr targetEnd)
  48. {
  49. if (target == targetEnd || c != target.getAndAdvance())
  50. return false;
  51. return match (pattern, patternEnd, target, targetEnd);
  52. }
  53. //==========================================================================
  54. static bool matchAnyChar (CharPtr pattern, CharPtr patternEnd, CharPtr target, CharPtr targetEnd)
  55. {
  56. if (target == targetEnd)
  57. return false;
  58. return match (pattern, patternEnd, ++target, targetEnd);
  59. }
  60. //==========================================================================
  61. static bool matchAnyOrNoChars (CharPtr pattern, CharPtr patternEnd, CharPtr target, CharPtr targetEnd)
  62. {
  63. if (target == targetEnd)
  64. return pattern == patternEnd;
  65. if (match (pattern, patternEnd, target, targetEnd))
  66. return true;
  67. return matchAnyOrNoChars (pattern, patternEnd, ++target, targetEnd);
  68. }
  69. //==========================================================================
  70. static bool matchInsideStringSet (CharPtr pattern, CharPtr patternEnd, CharPtr target, CharPtr targetEnd)
  71. {
  72. if (pattern == patternEnd)
  73. return false;
  74. // Note: in case this code is ever moved into the more generic CharPointerFunctions,
  75. // the next two lines probably will not compile as soon as this class is used with a
  76. // Char template type parameter that is not the same type as String::Char.
  77. StringArray set;
  78. String currentElement;
  79. while (pattern != patternEnd)
  80. {
  81. const juce_wchar c = pattern.getAndAdvance();
  82. switch (c)
  83. {
  84. case '}':
  85. set.add (currentElement);
  86. currentElement.clear();
  87. return matchStringSet (set, pattern, patternEnd, target, targetEnd);
  88. case ',':
  89. set.add (currentElement);
  90. currentElement.clear();
  91. continue;
  92. default:
  93. currentElement += c;
  94. continue;
  95. }
  96. }
  97. return false;
  98. }
  99. //==========================================================================
  100. static bool matchStringSet (const StringArray& set, CharPtr pattern,
  101. CharPtr patternEnd, CharPtr target, CharPtr targetEnd)
  102. {
  103. if (set.size() == 0)
  104. return match (pattern, patternEnd, target, targetEnd);
  105. for (const String* str = set.begin(); str != set.end(); ++str)
  106. if (str->getCharPointer().compareUpTo (target, str->length()) == 0)
  107. if (match (pattern, patternEnd, target + str->length(), targetEnd))
  108. return true;
  109. return false;
  110. }
  111. //==========================================================================
  112. static bool matchInsideCharSet (CharPtr pattern, CharPtr patternEnd,
  113. CharPtr target, CharPtr targetEnd)
  114. {
  115. if (pattern == patternEnd)
  116. return false;
  117. Array<juce_wchar> set;
  118. bool setIsNegated = false;
  119. while (pattern != patternEnd)
  120. {
  121. const juce_wchar c = pattern.getAndAdvance();
  122. switch (c)
  123. {
  124. case ']':
  125. return matchCharSet (set, setIsNegated, pattern, patternEnd, target, targetEnd);
  126. case '-':
  127. if (! addCharRangeToSet (set, pattern, patternEnd, target, targetEnd))
  128. return false;
  129. break;
  130. case '!':
  131. if (set.size() == 0 && setIsNegated == false)
  132. {
  133. setIsNegated = true;
  134. break;
  135. }
  136. // else = special case: fall through to default and treat '!' as a non-special character.
  137. default:
  138. set.add (c);
  139. break;
  140. }
  141. }
  142. return false;
  143. }
  144. //==========================================================================
  145. static bool matchCharSet (const Array<juce_wchar>& set, bool setIsNegated,
  146. CharPtr pattern, CharPtr patternEnd, CharPtr target, CharPtr targetEnd)
  147. {
  148. if (set.size() == 0)
  149. return match (pattern, patternEnd, target, targetEnd);
  150. if (target == targetEnd)
  151. return false;
  152. return setIsNegated ? matchCharSetNegated (set, pattern, patternEnd, target, targetEnd)
  153. : matchCharSetNotNegated (set, pattern, patternEnd, target, targetEnd);
  154. }
  155. //==========================================================================
  156. static bool matchCharSetNegated (const Array<juce_wchar>& set, CharPtr pattern,
  157. CharPtr patternEnd, CharPtr target, CharPtr targetEnd)
  158. {
  159. for (juce_wchar* c = set.begin(); c != set.end(); ++c)
  160. if (*target == *c)
  161. return false;
  162. return match (pattern, patternEnd, target + 1, targetEnd);
  163. }
  164. //==========================================================================
  165. static bool matchCharSetNotNegated (const Array<juce_wchar>& set, CharPtr pattern,
  166. CharPtr patternEnd, CharPtr target, CharPtr targetEnd)
  167. {
  168. for (juce_wchar* c = set.begin(); c != set.end(); ++c)
  169. if (*target == *c)
  170. if (match (pattern, patternEnd, target + 1, targetEnd))
  171. return true;
  172. return false;
  173. }
  174. //==========================================================================
  175. static bool addCharRangeToSet (Array<juce_wchar>& set, CharPtr pattern,
  176. CharPtr /*patternEnd*/, CharPtr target, CharPtr targetEnd)
  177. {
  178. if (target == targetEnd)
  179. return false;
  180. juce_wchar rangeStart = set.getLast();
  181. juce_wchar rangeEnd = pattern.getAndAdvance();
  182. if (rangeEnd == ']')
  183. {
  184. set.add ('-'); // special case: '-' has no special meaning at the end.
  185. return true;
  186. }
  187. if (rangeEnd == ',' || rangeEnd == '{' || rangeEnd == '}' || set.size() == 0)
  188. return false;
  189. while (rangeEnd > rangeStart)
  190. set.add (++rangeStart);
  191. return true;
  192. }
  193. };
  194. //==============================================================================
  195. static bool matchOscPattern (const String& pattern, const String& target)
  196. {
  197. return OSCPatternMatcherImpl<String::CharPointerType>::match (pattern.getCharPointer(),
  198. pattern.getCharPointer().findTerminatingNull(),
  199. target.getCharPointer(),
  200. target.getCharPointer().findTerminatingNull());
  201. }
  202. //==============================================================================
  203. template <typename OSCAddressType> struct OSCAddressTokeniserTraits;
  204. template <> struct OSCAddressTokeniserTraits<OSCAddress> { static const char* getDisallowedChars() { return " #*,?/[]{}"; } };
  205. template <> struct OSCAddressTokeniserTraits<OSCAddressPattern> { static const char* getDisallowedChars() { return " #/"; } };
  206. //==============================================================================
  207. template <typename OSCAddressType>
  208. struct OSCAddressTokeniser
  209. {
  210. typedef OSCAddressTokeniserTraits<OSCAddressType> Traits;
  211. //==============================================================================
  212. static bool isPrintableASCIIChar (juce_wchar c) noexcept
  213. {
  214. return c >= ' ' && c <= '~';
  215. }
  216. static bool isDisallowedChar (juce_wchar c) noexcept
  217. {
  218. return CharPointer_ASCII (Traits::getDisallowedChars()).indexOf (c, false) >= 0;
  219. }
  220. static bool containsOnlyAllowedPrintableASCIIChars (const String& string) noexcept
  221. {
  222. for (String::CharPointerType charPtr (string.getCharPointer()); ! charPtr.isEmpty();)
  223. {
  224. juce_wchar c = charPtr.getAndAdvance();
  225. if (! isPrintableASCIIChar (c) || isDisallowedChar (c))
  226. return false;
  227. }
  228. return true;
  229. }
  230. //==============================================================================
  231. static StringArray tokenise (const String& address)
  232. {
  233. if (address.isEmpty())
  234. throw OSCFormatError ("OSC format error: address string cannot be empty.");
  235. if (! address.startsWithChar ('/'))
  236. throw OSCFormatError ("OSC format error: address string must start with a forward slash.");
  237. StringArray oscSymbols;
  238. oscSymbols.addTokens (address, "/", StringRef());
  239. oscSymbols.removeEmptyStrings (false);
  240. for (String* token = oscSymbols.begin(); token != oscSymbols.end(); ++token)
  241. if (! containsOnlyAllowedPrintableASCIIChars (*token))
  242. throw OSCFormatError ("OSC format error: encountered characters not allowed in address string.");
  243. return oscSymbols;
  244. }
  245. };
  246. } // namespace
  247. //==============================================================================
  248. OSCAddress::OSCAddress (const String& address)
  249. : oscSymbols (OSCAddressTokeniser<OSCAddress>::tokenise (address)),
  250. asString (address.trimCharactersAtEnd ("/"))
  251. {
  252. }
  253. OSCAddress::OSCAddress (const char* address)
  254. : oscSymbols (OSCAddressTokeniser<OSCAddress>::tokenise (String (address))),
  255. asString (String (address).trimCharactersAtEnd ("/"))
  256. {
  257. }
  258. //==============================================================================
  259. bool OSCAddress::operator== (const OSCAddress& other) const noexcept
  260. {
  261. return asString == other.asString;
  262. }
  263. bool OSCAddress::operator!= (const OSCAddress& other) const noexcept
  264. {
  265. return ! operator== (other);
  266. }
  267. //==============================================================================
  268. String OSCAddress::toString() const noexcept
  269. {
  270. return asString;
  271. }
  272. //==============================================================================
  273. OSCAddressPattern::OSCAddressPattern (const String& address)
  274. : oscSymbols (OSCAddressTokeniser<OSCAddressPattern>::tokenise (address)),
  275. asString (address.trimCharactersAtEnd ("/")),
  276. wasInitialisedWithWildcards (asString.containsAnyOf ("*?{}[]"))
  277. {
  278. }
  279. OSCAddressPattern::OSCAddressPattern (const char* address)
  280. : oscSymbols (OSCAddressTokeniser<OSCAddressPattern>::tokenise (String (address))),
  281. asString (String (address).trimCharactersAtEnd ("/")),
  282. wasInitialisedWithWildcards (asString.containsAnyOf ("*?{}[]"))
  283. {
  284. }
  285. //==============================================================================
  286. bool OSCAddressPattern::operator== (const OSCAddressPattern& other) const noexcept
  287. {
  288. return asString == other.asString;
  289. }
  290. bool OSCAddressPattern::operator!= (const OSCAddressPattern& other) const noexcept
  291. {
  292. return ! operator== (other);
  293. }
  294. //==============================================================================
  295. bool OSCAddressPattern::matches (const OSCAddress& address) const noexcept
  296. {
  297. if (! containsWildcards())
  298. return asString == address.asString;
  299. if (oscSymbols.size() != address.oscSymbols.size())
  300. return false;
  301. for (int i = 0; i < oscSymbols.size(); ++i)
  302. if (! matchOscPattern (oscSymbols[i], address.oscSymbols[i]))
  303. return false;
  304. return true;
  305. }
  306. //==============================================================================
  307. String OSCAddressPattern::toString() const noexcept
  308. {
  309. return asString;
  310. }
  311. //==============================================================================
  312. //==============================================================================
  313. #if JUCE_UNIT_TESTS
  314. class OSCAddressTests : public UnitTest
  315. {
  316. public:
  317. OSCAddressTests() : UnitTest ("OSCAddress class") {}
  318. void runTest()
  319. {
  320. beginTest ("construction and parsing");
  321. {
  322. expectThrowsType (OSCAddress (""), OSCFormatError);
  323. expectThrowsType (OSCAddress ("noleadingslash"), OSCFormatError);
  324. expectThrowsType (OSCAddress ("/notallowedchar "), OSCFormatError);
  325. expectThrowsType (OSCAddress ("/notallowedchar#"), OSCFormatError);
  326. expectThrowsType (OSCAddress ("/notallowedchar*"), OSCFormatError);
  327. expectThrowsType (OSCAddress ("/notallowedchar,"), OSCFormatError);
  328. expectThrowsType (OSCAddress ("/notallowedchar?"), OSCFormatError);
  329. expectThrowsType (OSCAddress ("/notallowedchar["), OSCFormatError);
  330. expectThrowsType (OSCAddress ("/notallowedchar]"), OSCFormatError);
  331. expectThrowsType (OSCAddress ("/notallowedchar{"), OSCFormatError);
  332. expectThrowsType (OSCAddress ("/notallowedchar}andsomemorechars"), OSCFormatError);
  333. expectThrowsType (OSCAddress (String::fromUTF8 ("/nonasciicharacter\xc3\xbc""blabla")), OSCFormatError);
  334. expectThrowsType (OSCAddress ("/nonprintableasciicharacter\t"), OSCFormatError);
  335. expectDoesNotThrow (OSCAddress ("/"));
  336. expectDoesNotThrow (OSCAddress ("/a"));
  337. expectDoesNotThrow (OSCAddress ("/a/"));
  338. expectDoesNotThrow (OSCAddress ("/a/bcd/"));
  339. expectDoesNotThrow (OSCAddress ("/abcd/efgh/ijkLMNOPq/666r/s"));
  340. expectDoesNotThrow (OSCAddress ("/allowedprintablecharacters!$%&()+-.^_`|~"));
  341. expectDoesNotThrow (OSCAddress ("/additonalslashes//will///be////ignored"));
  342. }
  343. beginTest ("conversion to/from String");
  344. {
  345. OSCAddress address ("/this/is/a/very/long/address/");
  346. expectEquals (address.toString(), String ("/this/is/a/very/long/address"));
  347. }
  348. }
  349. };
  350. static OSCAddressTests OSCAddressUnitTests;
  351. //==============================================================================
  352. class OSCAddressPatternTests : public UnitTest
  353. {
  354. public:
  355. OSCAddressPatternTests() : UnitTest ("OSCAddressPattern class") {}
  356. void runTest()
  357. {
  358. beginTest ("construction and parsing");
  359. {
  360. expectThrowsType (OSCAddressPattern (""), OSCFormatError);
  361. expectThrowsType (OSCAddressPattern ("noleadingslash"), OSCFormatError);
  362. expectThrowsType (OSCAddressPattern ("/notallowedchar "), OSCFormatError);
  363. expectThrowsType (OSCAddressPattern ("/notallowedchar#andsomemorechars"), OSCFormatError);
  364. expectThrowsType (OSCAddressPattern (String::fromUTF8 ("/nonasciicharacter\xc3\xbc""blabla")), OSCFormatError);
  365. expectThrowsType (OSCAddressPattern ("/nonprintableasciicharacter\t"), OSCFormatError);
  366. expectDoesNotThrow (OSCAddressPattern ("/"));
  367. expectDoesNotThrow (OSCAddressPattern ("/a"));
  368. expectDoesNotThrow (OSCAddressPattern ("/a/"));
  369. expectDoesNotThrow (OSCAddressPattern ("/a/bcd/"));
  370. expectDoesNotThrow (OSCAddressPattern ("/abcd/efgh/ijkLMNOPq/666r/s"));
  371. expectDoesNotThrow (OSCAddressPattern ("/allowedprintablecharacters!$%&()+-.:;<=>@^_`|~"));
  372. expectDoesNotThrow (OSCAddressPattern ("/additonalslashes//will///be////ignored"));
  373. }
  374. beginTest ("construction and parsing - with wildcards");
  375. {
  376. expectDoesNotThrow (OSCAddressPattern ("/foo/b?r/"));
  377. expectDoesNotThrow (OSCAddressPattern ("/?????"));
  378. expectDoesNotThrow (OSCAddressPattern ("/foo/b*r"));
  379. expectDoesNotThrow (OSCAddressPattern ("/**"));
  380. expectDoesNotThrow (OSCAddressPattern ("/?/b/*c"));
  381. }
  382. beginTest ("construction and parsing - with match expressions");
  383. {
  384. expectDoesNotThrow (OSCAddressPattern ("/{}"));
  385. expectDoesNotThrow (OSCAddressPattern ("/{foo}"));
  386. expectDoesNotThrow (OSCAddressPattern ("/{foo,bar,baz}"));
  387. expectDoesNotThrow (OSCAddressPattern ("/[]"));
  388. expectDoesNotThrow (OSCAddressPattern ("/[abcde]"));
  389. expectDoesNotThrow (OSCAddressPattern ("/[a-e]"));
  390. expectDoesNotThrow (OSCAddressPattern ("/foo/[a-z]x{foo,bar}/*BAZ42/"));
  391. /* Note: if malformed expressions are used, e.g. "bracenotclosed{" or "{a-e}" or "[-foo]",
  392. this should not throw at construction time. Instead it should simply fail any pattern match later.
  393. So there is no need to test for those.
  394. The reason is that we do not actually parse the expressions now, but only during matching.
  395. */
  396. }
  397. beginTest ("equality comparison");
  398. {
  399. {
  400. OSCAddressPattern lhs ("/test/1");
  401. OSCAddressPattern rhs ("/test/1");
  402. expect (lhs == rhs);
  403. expect (! (lhs != rhs));
  404. }
  405. {
  406. OSCAddressPattern lhs ("/test/1");
  407. OSCAddressPattern rhs ("/test/1/");
  408. expect (lhs == rhs);
  409. expect (! (lhs != rhs));
  410. }
  411. {
  412. OSCAddressPattern lhs ("/test/1");
  413. OSCAddressPattern rhs ("/test/2");
  414. expect (! (lhs == rhs));
  415. expect (lhs != rhs);
  416. }
  417. }
  418. beginTest ("basic string matching");
  419. {
  420. /* Note: the actual expression matching is tested in OSCPatternMatcher, so here we just
  421. do some basic tests and check if the matching works with multi-part addresses.
  422. */
  423. {
  424. OSCAddressPattern pattern ("/foo/bar");
  425. expect (! pattern.containsWildcards());
  426. OSCAddress address ("/foo/bar");
  427. expect (pattern.matches (address));
  428. }
  429. {
  430. OSCAddressPattern pattern ("/foo/bar/");
  431. expect (! pattern.containsWildcards());
  432. OSCAddress address ("/foo/bar");
  433. expect (pattern.matches (address));
  434. }
  435. {
  436. OSCAddressPattern pattern ("/");
  437. expect (! pattern.containsWildcards());
  438. OSCAddress address ("/");
  439. expect (pattern.matches (address));
  440. }
  441. {
  442. OSCAddressPattern pattern ("/foo/bar");
  443. expect (! pattern.containsWildcards());
  444. expect (! pattern.matches (OSCAddress ("/foo/baz")));
  445. expect (! pattern.matches (OSCAddress ("/foo/bar/baz")));
  446. expect (! pattern.matches (OSCAddress ("/foo")));
  447. }
  448. }
  449. beginTest ("string matching with wildcards");
  450. {
  451. OSCAddressPattern pattern ("/*/*put/slider[0-9]");
  452. expect (pattern.containsWildcards());
  453. expect (pattern.matches (OSCAddress ("/mypatch/input/slider0")));
  454. expect (pattern.matches (OSCAddress ("/myotherpatch/output/slider9")));
  455. expect (! pattern.matches (OSCAddress ("/myotherpatch/output/slider10")));
  456. expect (! pattern.matches (OSCAddress ("/output/slider9")));
  457. expect (! pattern.matches (OSCAddress ("/myotherpatch/output/slider9/position")));
  458. }
  459. beginTest ("conversion to/from String");
  460. {
  461. {
  462. OSCAddressPattern ap ("/this/is/a/very/long/address/");
  463. expectEquals (ap.toString(), String ("/this/is/a/very/long/address"));
  464. }
  465. {
  466. OSCAddressPattern ap ("/*/*put/{fader,slider,knob}[0-9]/ba?/");
  467. expectEquals (ap.toString(), String ("/*/*put/{fader,slider,knob}[0-9]/ba?"));
  468. }
  469. }
  470. }
  471. };
  472. static OSCAddressPatternTests OSCAddressPatternUnitTests;
  473. //==============================================================================
  474. class OSCPatternMatcherTests : public UnitTest
  475. {
  476. public:
  477. OSCPatternMatcherTests() : UnitTest ("OSCAddress class / pattern matching") {}
  478. void runTest()
  479. {
  480. beginTest ("basic string matching");
  481. {
  482. expect (matchOscPattern ("", ""));
  483. expect (! matchOscPattern ("", "x"));
  484. expect (! matchOscPattern ("x", ""));
  485. expect (matchOscPattern ("foo", "foo"));
  486. expect (! matchOscPattern ("foo", "bar"));
  487. expect (! matchOscPattern ("ooooo", "oooooo"));
  488. }
  489. beginTest ("string matching with '?' wildcard");
  490. {
  491. expect (matchOscPattern ("?", "x"));
  492. expect (! matchOscPattern ("?", ""));
  493. expect (! matchOscPattern ("?", "xx"));
  494. expect (! matchOscPattern ("b?r", "br"));
  495. expect (matchOscPattern ("b?r", "bar"));
  496. expect (! matchOscPattern ("b?r", "baar"));
  497. expect (matchOscPattern ("f???o", "fabco"));
  498. expect (! matchOscPattern ("f???o", "fabo"));
  499. }
  500. beginTest ("string matching with '*' wildcard");
  501. {
  502. expect (matchOscPattern ("*", ""));
  503. expect (matchOscPattern ("*", "x"));
  504. expect (matchOscPattern ("*", "foo"));
  505. expect (matchOscPattern ("*c", "aaaaaaabc"));
  506. expect (matchOscPattern ("*c", "aaaaaaabbbcccc"));
  507. expect (! matchOscPattern ("*c", "aaaaaaabbbcccca"));
  508. expect (matchOscPattern ("c*", "ccccbbbbaaaa"));
  509. expect (! matchOscPattern ("c*", "accccbbbaaaa"));
  510. expect (matchOscPattern ("f*o", "fo"));
  511. expect (matchOscPattern ("f*o", "fuo"));
  512. expect (matchOscPattern ("f*o", "fuvwxyzo"));
  513. expect (matchOscPattern ("*reallyreallylongstringstringstring", "reallyreallylongstringstringstrNOT"
  514. "reallyreallylongstringstringstrNOT"
  515. "reallyreallylongstringstringstrNOT"
  516. "reallyreallylongstringstringstrNOT"
  517. "reallyreallylongstringstringstrNOT"
  518. "reallyreallylongstringstringstring"));
  519. }
  520. beginTest ("string matching with '{..., ...}' pattern");
  521. {
  522. expect (matchOscPattern ("{}", ""));
  523. expect (! matchOscPattern ("{}", "x"));
  524. expect (matchOscPattern ("{abcde}", "abcde"));
  525. expect (matchOscPattern ("{abcde,f}", "f"));
  526. expect (! matchOscPattern ("{abcde,f}", "ff"));
  527. expect (matchOscPattern ("a{bcd}e", "abcde"));
  528. expect (matchOscPattern ("a{bcd,bce}e", "abcde"));
  529. expect (! matchOscPattern ("a{bce,bcf}e", "abcde"));
  530. expect (! matchOscPattern ("a{bce,bcf}e", "ae"));
  531. expect (matchOscPattern ("a{bce,,bcf}e", "ae"));
  532. expect (matchOscPattern ("a{bcd,bcd,bcd}e", "abcde"));
  533. expect (matchOscPattern ("aaa{bc,def,ghij,klmnopqrstu}eee", "aaaghijeee"));
  534. expect (matchOscPattern ("{a,b,c}bcde", "abcde"));
  535. expect (! matchOscPattern ("{abc}bcde", "abcde"));
  536. expect (matchOscPattern ("bcde{a,b,c}", "bcdea"));
  537. expect (! matchOscPattern ("bcde{abc}", "bcdea"));
  538. expect (matchOscPattern ("f{o,}o", "fo"));
  539. expect (matchOscPattern ("f{,,,,,}o", "fo"));
  540. expect (matchOscPattern ("foo{b,ba,bar}x", "foobarx"));
  541. expect (matchOscPattern ("a{bc,de}fg{hij,klm}{n}{}", "adefghijn"));
  542. // should fail gracefully in case of wrong syntax:
  543. expect (! matchOscPattern ("not{closing", "notclosing"));
  544. expect (! matchOscPattern ("not}opening", "notopening"));
  545. expect (! matchOscPattern ("{{nested}}", "nested"));
  546. expect (! matchOscPattern ("{a-c}bcde", "abcde"));
  547. expect (! matchOscPattern ("bcde{a-c}", "abcde"));
  548. }
  549. beginTest ("string matching with '[...]' pattern");
  550. {
  551. // using [] for a set of chars:
  552. expect (matchOscPattern ("[]", ""));
  553. expect (! matchOscPattern ("[]", "x"));
  554. expect (! matchOscPattern ("[abcde]", "abcde"));
  555. expect (matchOscPattern ("[abcde]", "a"));
  556. expect (matchOscPattern ("[abcde]", "b"));
  557. expect (matchOscPattern ("[abcde]", "c"));
  558. expect (matchOscPattern ("[abcde]", "d"));
  559. expect (matchOscPattern ("[abcde]", "e"));
  560. expect (! matchOscPattern ("[abcde]", "f"));
  561. expect (matchOscPattern ("f[oo]", "fo"));
  562. expect (! matchOscPattern ("f[oo]", "foo"));
  563. expect (matchOscPattern ("fooba[rxz]foo", "foobarfoo"));
  564. expect (matchOscPattern ("fooba[rxz]foo", "foobaxfoo"));
  565. expect (matchOscPattern ("fooba[rxz]foo", "foobazfoo"));
  566. expect (! matchOscPattern ("fooba[rxz]foo", "foobasfoo"));
  567. expect (matchOscPattern ("foo[abc]foo[defgh]foo[i]foo[]foo", "foobfoohfooifoofoo"));
  568. // using [] for a range of chars:
  569. expect (matchOscPattern ("fooba[r-z]foo", "foobarfoo"));
  570. expect (matchOscPattern ("fooba[r-z]foo", "foobaxfoo"));
  571. expect (matchOscPattern ("fooba[r-z]foo", "foobazfoo"));
  572. expect (matchOscPattern ("fooba[r-z]foo", "foobasfoo"));
  573. expect (! matchOscPattern ("fooba[r-z]foo", "foobaRfoo"));
  574. expect (! matchOscPattern ("foo[1-8]bar", "foo0bar"));
  575. expect (matchOscPattern ("foo[1-8]bar", "foo1bar"));
  576. expect (matchOscPattern ("foo[1-8]bar", "foo6bar"));
  577. expect (matchOscPattern ("foo[1-8]bar", "foo8bar"));
  578. expect (! matchOscPattern ("foo[1-8]bar", "foo9bar"));
  579. // special case: '-' does not have a special meaning if it is at the end of the set.
  580. expect (matchOscPattern ("foo[abc-]bar", "fooabar"));
  581. expect (matchOscPattern ("foo[abc-]bar", "foo-bar"));
  582. expect (matchOscPattern ("foo[-]bar", "foo-bar"));
  583. // mixing both set and range:
  584. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]b[a-b]r", "fooabar"));
  585. expect (! matchOscPattern ("foo[ae-iko-uz1-8D-FX]b[a-a]r", "foobbar"));
  586. expect (! matchOscPattern ("foo[ae-iko-uz1-8D-FX]b[aaaa-aaaa-aaaa]r", "foodbar"));
  587. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "fooebar"));
  588. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "foogbar"));
  589. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "fooibar"));
  590. expect (! matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "foojbar"));
  591. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "fookbar"));
  592. expect (! matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "foolbar"));
  593. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "fooobar"));
  594. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "foopbar"));
  595. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "fooubar"));
  596. expect (! matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "fooybar"));
  597. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "foozbar"));
  598. expect (! matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "foo0bar"));
  599. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "foo1bar"));
  600. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "foo5bar"));
  601. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "foo8bar"));
  602. expect (! matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "foo9bar"));
  603. expect (! matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "fooCbar"));
  604. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "fooDbar"));
  605. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "fooEbar"));
  606. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "fooFbar"));
  607. expect (! matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "fooGbar"));
  608. expect (matchOscPattern ("foo[ae-iko-uz1-8D-FX]bar", "fooXbar"));
  609. expect (! matchOscPattern ("foo[ae-iko-uz1-8D-FX]ba[Rr]", "fooZbar"));
  610. expect (! matchOscPattern ("foo[ae-iko-uz1-8D-FX]ba[Rr]", "foobar"));
  611. expect (! matchOscPattern ("foo[ae-iko-uz1-8D-FX]ba[Rr]", "fooFXbar"));
  612. // using [!...] for a negated set or range of chars:
  613. expect (! matchOscPattern ("fooba[!rxz]foo", "foobarfoo"));
  614. expect (! matchOscPattern ("fooba[!rxz]foo", "foobaxfoo"));
  615. expect (! matchOscPattern ("fooba[!rxz]foo", "foobazfoo"));
  616. expect (matchOscPattern ("fooba[!rxz]foo", "foobasfoo"));
  617. expect (! matchOscPattern ("fooba[!r-z]foo", "foobarfoo"));
  618. expect (! matchOscPattern ("fooba[!r-z]foo", "foobaxfoo"));
  619. expect (! matchOscPattern ("fooba[!r-z]foo", "foobazfoo"));
  620. expect (! matchOscPattern ("fooba[!r-z]foo", "foobasfoo"));
  621. expect (matchOscPattern ("fooba[!r-z]foo", "foobaRfoo"));
  622. // special case: '!' does not have a special meaning if it is not the first char in the set.
  623. expect (matchOscPattern ("foo[ab!c]bar", "fooabar"));
  624. expect (matchOscPattern ("foo[ab!c]bar", "foo!bar"));
  625. expect (! matchOscPattern ("foo[ab!c]bar", "fooxbar"));
  626. expect (! matchOscPattern ("foo[!!]bar", "foo!bar"));
  627. expect (matchOscPattern ("foo[!!]bar", "fooxbar"));
  628. expect (! matchOscPattern ("foo[!!]bar", "foobar"));
  629. // should fail gracefully in case of wrong syntax:
  630. expect (! matchOscPattern ("notclosin[g", "notclosing"));
  631. expect (! matchOscPattern ("n]otopening", "notopening"));
  632. expect (! matchOscPattern ("[[nested]]", "nested"));
  633. expect (! matchOscPattern ("norangestar[-t]", "norangestart"));
  634. expect (! matchOscPattern ("norangestar[-t]", "norangestar-"));
  635. }
  636. beginTest ("string matching combining patterns");
  637. {
  638. expect (matchOscPattern ("*ea*ll[y-z0-9X-Zvwx]??m[o-q]l[e]x{fat,mat,pat}te{}r*?", "reallycomplexpattern"));
  639. }
  640. }
  641. };
  642. static OSCPatternMatcherTests OSCPatternMatcherUnitTests;
  643. #endif // JUCE_UNIT_TESTS