| // Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| import "dart:math"; |
| |
| import "package:test/test.dart"; |
| |
| import "package:characters/characters.dart"; |
| |
| import "src/unicode_tests.dart"; |
| import "src/unicode_grapheme_tests.dart"; |
| import "src/various_tests.dart"; |
| |
| Random random; |
| |
| void main([List<String> args]) { |
| // Ensure random seed is part of every test failure message, |
| // and that it can be reapplied for testing. |
| var seed = (args != null && args.isNotEmpty) |
| ? int.parse(args[0]) |
| : Random().nextInt(0x3FFFFFFF); |
| random = Random(seed); |
| group("[Random Seed: $seed]", tests); |
| group("index", () { |
| test("simple", () { |
| var flag = "\u{1F1E9}\u{1F1F0}"; |
| var string = "Hi $flag!"; // Regional Indications "DK". |
| expect(string.length, 8); |
| expect(gc(string).toList(), ["H", "i", " ", flag, "!"]); |
| |
| expect(gc(string).indexOf(gc("")), 0); |
| expect(gc(string).indexOf(gc(""), 3), 3); |
| expect(gc(string).indexOf(gc(""), 4), 7); |
| expect(gc(string).indexOf(gc(flag)), 3); |
| expect(gc(string).indexOf(gc(flag), 3), 3); |
| expect(gc(string).indexOf(gc(flag), 4), lessThan(0)); |
| |
| expect(gc(string).indexAfter(gc("")), 0); |
| expect(gc(string).indexAfter(gc(""), 3), 3); |
| expect(gc(string).indexAfter(gc(""), 4), 7); |
| expect(gc(string).indexAfter(gc(flag)), 7); |
| expect(gc(string).indexAfter(gc(flag), 7), 7); |
| expect(gc(string).indexAfter(gc(flag), 8), lessThan(0)); |
| |
| expect(gc(string).lastIndexOf(gc("")), string.length); |
| expect(gc(string).lastIndexOf(gc(""), 7), 7); |
| expect(gc(string).lastIndexOf(gc(""), 6), 3); |
| expect(gc(string).lastIndexOf(gc(""), 0), 0); |
| expect(gc(string).lastIndexOf(gc(flag)), 3); |
| expect(gc(string).lastIndexOf(gc(flag), 6), 3); |
| expect(gc(string).lastIndexOf(gc(flag), 2), lessThan(0)); |
| |
| expect(gc(string).lastIndexAfter(gc("")), string.length); |
| expect(gc(string).lastIndexAfter(gc(""), 7), 7); |
| expect(gc(string).lastIndexAfter(gc(""), 6), 3); |
| expect(gc(string).lastIndexAfter(gc(""), 0), 0); |
| expect(gc(string).lastIndexAfter(gc(flag)), 7); |
| expect(gc(string).lastIndexAfter(gc(flag), 7), 7); |
| expect(gc(string).lastIndexAfter(gc(flag), 6), lessThan(0)); |
| }); |
| test("multiple", () { |
| var flag = "\u{1F1E9}\u{1F1F0}"; // DK. |
| var revFlag = "\u{1F1F0}\u{1F1E9}"; // KD. |
| var string = "-${flag}-$flag$flag-"; |
| expect(gc(string).indexOf(gc(flag)), 1); |
| expect(gc(string).indexOf(gc(flag), 2), 6); |
| expect(gc(string).indexOf(gc(flag), 6), 6); |
| expect(gc(string).indexOf(gc(flag), 7), 10); |
| expect(gc(string).indexOf(gc(flag), 10), 10); |
| expect(gc(string).indexOf(gc(flag), 11), lessThan(0)); |
| |
| expect(gc(string).indexOf(gc(revFlag)), lessThan(0)); |
| }); |
| |
| test("nonBoundary", () { |
| // Composite pictogram example, from https://en.wikipedia.org/wiki/Zero-width_joiner. |
| var flag = "\u{1f3f3}"; // U+1F3F3, Flag, waving. Category Pictogram. |
| var white = "\ufe0f"; // U+FE0F, Variant selector 16. Category Extend. |
| var zwj = "\u200d"; // U+200D, ZWJ |
| var rainbow = "\u{1f308}"; // U+1F308, Rainbow. Category Pictogram |
| var flagRainbow = "$flag$white$zwj$rainbow"; |
| expect(gc(flagRainbow).length, 1); |
| for (var part in [flag, white, zwj, rainbow]) { |
| expect(gc(flagRainbow).indexOf(gc(part)), lessThan(0)); |
| expect(gc(flagRainbow).indexAfter(gc(part)), lessThan(0)); |
| expect(gc(flagRainbow).lastIndexOf(gc(part)), lessThan(0)); |
| expect(gc(flagRainbow).lastIndexAfter(gc(part)), lessThan(0)); |
| } |
| expect(gc(flagRainbow + flagRainbow).indexOf(gc(flagRainbow)), 0); |
| expect(gc(flagRainbow + flagRainbow).indexAfter(gc(flagRainbow)), 6); |
| expect(gc(flagRainbow + flagRainbow).lastIndexOf(gc(flagRainbow)), 6); |
| expect(gc(flagRainbow + flagRainbow).lastIndexAfter(gc(flagRainbow)), 12); |
| // 1 11 11 11 2 |
| // indices 0 67 90 12 34 67 3 |
| var partsAndWhole = |
| "$flagRainbow $flag $white $zwj $rainbow $flagRainbow"; |
| // Flag and rainbow are independent graphemes. |
| expect(gc(partsAndWhole).toList(), [ |
| flagRainbow, |
| " ", |
| flag, |
| " $white", // Other + Extend |
| " $zwj", // Other + ZWJ |
| " ", |
| rainbow, |
| " ", |
| flagRainbow |
| ]); |
| expect(gc(partsAndWhole).indexOf(gc(flag)), 7); |
| expect(gc(partsAndWhole).indexAfter(gc(flag)), 9); |
| expect(gc(partsAndWhole).lastIndexOf(gc(flag)), 7); |
| expect(gc(partsAndWhole).lastIndexAfter(gc(flag)), 9); |
| |
| expect(gc(partsAndWhole).indexOf(gc(rainbow)), 14); |
| expect(gc(partsAndWhole).indexAfter(gc(rainbow)), 16); |
| expect(gc(partsAndWhole).lastIndexOf(gc(rainbow)), 14); |
| expect(gc(partsAndWhole).lastIndexAfter(gc(rainbow)), 16); |
| |
| expect(gc(partsAndWhole).indexOf(gc(white)), lessThan(0)); |
| expect(gc(partsAndWhole).indexAfter(gc(white)), lessThan(0)); |
| expect(gc(partsAndWhole).lastIndexOf(gc(white)), lessThan(0)); |
| expect(gc(partsAndWhole).lastIndexAfter(gc(white)), lessThan(0)); |
| expect(gc(partsAndWhole).indexOf(gc(" $white")), 9); |
| expect(gc(partsAndWhole).indexAfter(gc(" $white")), 11); |
| expect(gc(partsAndWhole).lastIndexOf(gc(" $white")), 9); |
| expect(gc(partsAndWhole).lastIndexAfter(gc(" $white")), 11); |
| |
| expect(gc(partsAndWhole).indexOf(gc(zwj)), lessThan(0)); |
| expect(gc(partsAndWhole).indexAfter(gc(zwj)), lessThan(0)); |
| expect(gc(partsAndWhole).lastIndexOf(gc(zwj)), lessThan(0)); |
| expect(gc(partsAndWhole).lastIndexAfter(gc(zwj)), lessThan(0)); |
| expect(gc(partsAndWhole).indexOf(gc(" $zwj")), 11); |
| expect(gc(partsAndWhole).indexAfter(gc(" $zwj")), 13); |
| expect(gc(partsAndWhole).lastIndexOf(gc(" $zwj")), 11); |
| expect(gc(partsAndWhole).lastIndexAfter(gc(" $zwj")), 13); |
| }); |
| }); |
| } |
| |
| void tests() { |
| test("empty", () { |
| expectGC(gc(""), []); |
| }); |
| group("gc-ASCII", () { |
| for (var text in [ |
| "", |
| "A", |
| "123456abcdefab", |
| ]) { |
| test('"$text"', () { |
| expectGC(gc(text), charsOf(text)); |
| }); |
| } |
| test("CR+NL", () { |
| expectGC(gc("a\r\nb"), ["a", "\r\n", "b"]); |
| expectGC(gc("a\n\rb"), ["a", "\n", "\r", "b"]); |
| }); |
| }); |
| group("Non-ASCII single-code point", () { |
| for (var text in [ |
| "à la mode", |
| "rødgrød-æble-ål", |
| ]) { |
| test('"$text"', () { |
| expectGC(gc(text), charsOf(text)); |
| }); |
| } |
| }); |
| group("Combining marks", () { |
| var text = "a\u0300 la mode"; |
| test('"$text"', () { |
| expectGC(gc(text), ["a\u0300", " ", "l", "a", " ", "m", "o", "d", "e"]); |
| }); |
| var text2 = "æble-a\u030Al"; |
| test('"$text2"', () { |
| expectGC(gc(text2), ["æ", "b", "l", "e", "-", "a\u030A", "l"]); |
| }); |
| }); |
| |
| group("Regional Indicators", () { |
| test('"🇦🇩🇰🇾🇪🇸"', () { |
| // Andorra, Cayman Islands, Spain. |
| expectGC(gc("🇦🇩🇰🇾🇪🇸"), ["🇦🇩", "🇰🇾", "🇪🇸"]); |
| }); |
| test('"X🇦🇩🇰🇾🇪🇸"', () { |
| // Other, Andorra, Cayman Islands, Spain. |
| expectGC(gc("X🇦🇩🇰🇾🇪🇸"), ["X", "🇦🇩", "🇰🇾", "🇪🇸"]); |
| }); |
| test('"🇩🇰🇾🇪🇸"', () { |
| // Denmark, Yemen, unmatched S. |
| expectGC(gc("🇩🇰🇾🇪🇸"), ["🇩🇰", "🇾🇪", "🇸"]); |
| }); |
| test('"X🇩🇰🇾🇪🇸"', () { |
| // Other, Denmark, Yemen, unmatched S. |
| expectGC(gc("X🇩🇰🇾🇪🇸"), ["X", "🇩🇰", "🇾🇪", "🇸"]); |
| }); |
| }); |
| |
| group("Hangul", () { |
| // Individual characters found on Wikipedia. Not expected to make sense. |
| test('"읍쌍된밟"', () { |
| expectGC(gc("읍쌍된밟"), ["읍", "쌍", "된", "밟"]); |
| }); |
| }); |
| |
| group("Unicode test", () { |
| for (var gcs in splitTests) { |
| test("[${testDescription(gcs)}]", () { |
| expectGC(gc(gcs.join()), gcs); |
| }); |
| } |
| }); |
| |
| group("Emoji test", () { |
| for (var gcs in emojis) { |
| test("[${testDescription(gcs)}]", () { |
| expectGC(gc(gcs.join()), gcs); |
| }); |
| } |
| }); |
| |
| group("Zalgo test", () { |
| for (var gcs in zalgo) { |
| test("[${testDescription(gcs)}]", () { |
| expectGC(gc(gcs.join()), gcs); |
| }); |
| } |
| }); |
| } |
| |
| // Converts text with no multi-code-point grapheme clusters into |
| // list of grapheme clusters. |
| List<String> charsOf(String text) => |
| text.runes.map((r) => String.fromCharCode(r)).toList(); |
| |
| void expectGC(Characters actual, List<String> expected) { |
| var text = expected.join(); |
| |
| // Iterable operations. |
| expect(actual.string, text); |
| expect(actual.toString(), text); |
| expect(actual.toList(), expected); |
| expect(actual.length, expected.length); |
| if (expected.isNotEmpty) { |
| expect(actual.first, expected.first); |
| expect(actual.last, expected.last); |
| } else { |
| expect(() => actual.first, throwsStateError); |
| expect(() => actual.last, throwsStateError); |
| } |
| if (expected.length == 1) { |
| expect(actual.single, expected.single); |
| } else { |
| expect(() => actual.single, throwsStateError); |
| } |
| expect(actual.isEmpty, expected.isEmpty); |
| expect(actual.isNotEmpty, expected.isNotEmpty); |
| expect(actual.contains(""), false); |
| for (var char in expected) { |
| expect(actual.contains(char), true); |
| } |
| for (int i = 1; i < expected.length; i++) { |
| expect(actual.contains(expected[i - 1] + expected[i]), false); |
| } |
| expect(actual.skip(1).toList(), expected.skip(1).toList()); |
| expect(actual.take(1).toList(), expected.take(1).toList()); |
| expect(actual.skip(1).toString(), expected.skip(1).join()); |
| expect(actual.take(1).toString(), expected.take(1).join()); |
| |
| if (expected.isNotEmpty) { |
| expect(actual.skipLast(1).toList(), |
| expected.take(expected.length - 1).toList()); |
| expect(actual.takeLast(1).toList(), |
| expected.skip(expected.length - 1).toList()); |
| expect(actual.skipLast(1).toString(), |
| expected.take(expected.length - 1).join()); |
| expect(actual.takeLast(1).toString(), |
| expected.skip(expected.length - 1).join()); |
| |
| expect(actual.indexOf(gc(expected.first)), 0); |
| expect(actual.indexAfter(gc(expected.first)), expected.first.length); |
| expect(actual.lastIndexOf(gc(expected.last)), |
| text.length - expected.last.length); |
| expect(actual.lastIndexAfter(gc(expected.last)), text.length); |
| if (expected.length > 1) { |
| if (expected[0] != expected[1]) { |
| expect(actual.indexOf(gc(expected[1])), expected[0].length); |
| } |
| } |
| } |
| |
| expect(actual.getRange(1, 3).toString(), expected.take(3).skip(1).join()); |
| expect(actual.getRange(1, 3).toString(), expected.take(3).skip(1).join()); |
| |
| bool isEven(String s) => s.length.isEven; |
| |
| expect( |
| actual.skipWhile(isEven).toList(), expected.skipWhile(isEven).toList()); |
| expect( |
| actual.takeWhile(isEven).toList(), expected.takeWhile(isEven).toList()); |
| expect( |
| actual.skipWhile(isEven).toString(), expected.skipWhile(isEven).join()); |
| expect( |
| actual.takeWhile(isEven).toString(), expected.takeWhile(isEven).join()); |
| |
| expect(actual.skipLastWhile(isEven).toString(), |
| expected.toList().reversed.skipWhile(isEven).toList().reversed.join()); |
| expect(actual.takeLastWhile(isEven).toString(), |
| expected.toList().reversed.takeWhile(isEven).toList().reversed.join()); |
| |
| expect(actual.where(isEven).toString(), expected.where(isEven).join()); |
| |
| expect((actual + actual).toString(), actual.string + actual.string); |
| |
| List<int> accumulatedLengths = [0]; |
| for (int i = 0; i < expected.length; i++) { |
| accumulatedLengths.add(accumulatedLengths.last + expected[i].length); |
| } |
| |
| // Iteration. |
| var it = actual.iterator; |
| expect(it.start, 0); |
| expect(it.end, 0); |
| for (var i = 0; i < expected.length; i++) { |
| expect(it.moveNext(), true); |
| expect(it.start, accumulatedLengths[i]); |
| expect(it.end, accumulatedLengths[i + 1]); |
| expect(it.current, expected[i]); |
| |
| expect(actual.elementAt(i), expected[i]); |
| expect(actual.skip(i).first, expected[i]); |
| } |
| expect(it.moveNext(), false); |
| expect(it.start, accumulatedLengths.last); |
| expect(it.end, accumulatedLengths.last); |
| for (var i = expected.length - 1; i >= 0; i--) { |
| expect(it.movePrevious(), true); |
| expect(it.start, accumulatedLengths[i]); |
| expect(it.end, accumulatedLengths[i + 1]); |
| expect(it.current, expected[i]); |
| } |
| expect(it.movePrevious(), false); |
| expect(it.start, 0); |
| expect(it.end, 0); |
| |
| // GraphemeClusters operations. |
| expect(actual.toUpperCase().toString(), text.toUpperCase()); |
| expect(actual.toLowerCase().toString(), text.toLowerCase()); |
| |
| if (text.isNotEmpty) { |
| expect(actual.insertAt(1, gc("abc")).toString(), |
| text.replaceRange(1, 1, "abc")); |
| expect(actual.replaceSubstring(0, 1, gc("abc")).toString(), |
| text.replaceRange(0, 1, "abc")); |
| expect(actual.substring(0, 1).string, actual.string.substring(0, 1)); |
| } |
| |
| expect(actual.string, text); |
| |
| expect(actual.containsAll(gc("")), true); |
| expect(actual.containsAll(actual), true); |
| if (expected.isNotEmpty) { |
| int steps = min(5, expected.length); |
| for (int s = 0; s <= steps; s++) { |
| int i = expected.length * s ~/ steps; |
| expect(actual.startsWith(gc(expected.sublist(0, i).join())), true); |
| expect(actual.endsWith(gc(expected.sublist(i).join())), true); |
| for (int t = s + 1; t <= steps; t++) { |
| int j = expected.length * t ~/ steps; |
| int start = accumulatedLengths[i]; |
| int end = accumulatedLengths[j]; |
| var slice = expected.sublist(i, j).join(); |
| var gcs = gc(slice); |
| expect(actual.containsAll(gcs), true); |
| expect(actual.startsWith(gcs, start), true); |
| expect(actual.endsWith(gcs, end), true); |
| } |
| } |
| if (accumulatedLengths.last > expected.length) { |
| int i = expected.indexWhere((s) => s.length != 1); |
| assert(accumulatedLengths[i + 1] > accumulatedLengths[i] + 1); |
| expect( |
| actual.startsWith(gc(text.substring(0, accumulatedLengths[i] + 1))), |
| false); |
| expect(actual.endsWith(gc(text.substring(accumulatedLengths[i] + 1))), |
| false); |
| if (i > 0) { |
| expect( |
| actual.startsWith( |
| gc(text.substring(1, accumulatedLengths[i] + 1)), 1), |
| false); |
| } |
| if (i < expected.length - 1) { |
| int secondToLast = accumulatedLengths[expected.length - 1]; |
| expect( |
| actual.endsWith( |
| gc(text.substring(accumulatedLengths[i] + 1, secondToLast)), |
| secondToLast), |
| false); |
| } |
| } |
| } |
| |
| { |
| // Random walk back and forth. |
| var it = actual.iterator; |
| int pos = -1; |
| if (random.nextBool()) { |
| pos = expected.length; |
| it.reset(text.length); |
| } |
| int steps = 5 + random.nextInt(expected.length * 2 + 1); |
| bool lastMove = false; |
| while (true) { |
| bool back = false; |
| if (pos < 0) { |
| expect(lastMove, false); |
| expect(it.start, 0); |
| expect(it.end, 0); |
| } else if (pos >= expected.length) { |
| expect(lastMove, false); |
| expect(it.start, text.length); |
| expect(it.end, text.length); |
| back = true; |
| } else { |
| expect(lastMove, true); |
| expect(it.current, expected[pos]); |
| expect(it.start, accumulatedLengths[pos]); |
| expect(it.end, accumulatedLengths[pos + 1]); |
| back = random.nextBool(); |
| } |
| if (--steps < 0) break; |
| if (back) { |
| lastMove = it.movePrevious(); |
| pos -= 1; |
| } else { |
| lastMove = it.moveNext(); |
| pos += 1; |
| } |
| } |
| } |
| } |
| |
| Characters gc(String string) => Characters(string); |
