mirror of
https://github.com/dart-lang/sdk
synced 2024-11-02 09:43:08 +00:00
3867d84ca5
-Spit string_test into string_test and string_static_test -Added various MissingCompileTimeError entries in status files for tests which throw exceptions on configurations that haven't implemented Dart 2.0 -Switched var -> dynamic in symbol_operator_test BUG= R=jcollins@google.com, rnystrom@google.com Review-Url: https://codereview.chromium.org/2983253002 .
478 lines
14 KiB
Dart
478 lines
14 KiB
Dart
// Copyright (c) 2011, 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 "package:expect/expect.dart";
|
|
|
|
void main() {
|
|
testOutOfRange();
|
|
testConcat();
|
|
testIndex();
|
|
testCodeUnitAt();
|
|
testEquals();
|
|
testEndsWith();
|
|
testStartsWith();
|
|
testIndexOf();
|
|
testLastIndexOf();
|
|
testContains();
|
|
testReplaceAll();
|
|
testCompareTo();
|
|
testCharCodes();
|
|
testRepeat();
|
|
testPadLeft();
|
|
testPadRight();
|
|
}
|
|
|
|
void testLength() {
|
|
String str = "";
|
|
for (var i = 0; i < 20; i++) {
|
|
testStringLength(i, str);
|
|
str += " ";
|
|
}
|
|
}
|
|
|
|
void testOutOfRange() {
|
|
String a = "Hello";
|
|
bool exception_caught = false;
|
|
try {
|
|
var c = a[20]; // Throw exception.
|
|
} on RangeError catch (e) {
|
|
exception_caught = true;
|
|
}
|
|
Expect.isTrue(exception_caught);
|
|
}
|
|
|
|
void testIndex() {
|
|
String str = "string";
|
|
for (int i = 0; i < str.length; i++) {
|
|
Expect.isTrue(str[i] is String);
|
|
testStringLength(1, str[i]);
|
|
}
|
|
}
|
|
|
|
void testCodeUnitAt() {
|
|
String str = "string";
|
|
for (int i = 0; i < str.length; i++) {
|
|
Expect.isTrue(str.codeUnitAt(i) is int);
|
|
}
|
|
}
|
|
|
|
void testConcat() {
|
|
var a = "One";
|
|
var b = "Four";
|
|
var c = a + b;
|
|
testStringLength(7, c);
|
|
Expect.equals("OneFour", c);
|
|
}
|
|
|
|
void testEquals() {
|
|
Expect.equals("str", "str");
|
|
|
|
Expect.equals("str", "s" + "t" + "r");
|
|
Expect.equals("s" + "t" + "r", "str");
|
|
|
|
Expect.isFalse("str" == "s");
|
|
Expect.isFalse("str" == "r");
|
|
Expect.isFalse("str" == "st");
|
|
Expect.isFalse("str" == "tr");
|
|
|
|
Expect.isFalse("s" == "str");
|
|
Expect.isFalse("r" == "str");
|
|
Expect.isFalse("st" == "str");
|
|
Expect.isFalse("tr" == "str");
|
|
|
|
Expect.isFalse("" == "s");
|
|
Expect.equals("", "");
|
|
}
|
|
|
|
void testEndsWith() {
|
|
Expect.isTrue("str".endsWith("r"));
|
|
Expect.isTrue("str".endsWith("tr"));
|
|
Expect.isTrue("str".endsWith("str"));
|
|
|
|
Expect.isFalse("str".endsWith("stri"));
|
|
Expect.isFalse("str".endsWith("t"));
|
|
Expect.isFalse("str".endsWith("st"));
|
|
Expect.isFalse("str".endsWith("s"));
|
|
|
|
Expect.isTrue("".endsWith(""));
|
|
Expect.isFalse("".endsWith("s"));
|
|
}
|
|
|
|
void testStartsWith() {
|
|
Expect.isTrue("str".startsWith("s"));
|
|
Expect.isTrue("str".startsWith("st"));
|
|
Expect.isTrue("str".startsWith("str"));
|
|
|
|
Expect.isFalse("str".startsWith("stri"));
|
|
Expect.isFalse("str".startsWith("r"));
|
|
Expect.isFalse("str".startsWith("tr"));
|
|
Expect.isFalse("str".startsWith("t"));
|
|
|
|
Expect.isTrue("".startsWith(""));
|
|
Expect.isFalse("".startsWith("s"));
|
|
|
|
Expect.isFalse("strstr".startsWith("s", 1));
|
|
Expect.isFalse("strstr".startsWith("s", 2));
|
|
Expect.isTrue("strstr".startsWith("s", 3));
|
|
Expect.isFalse("strstr".startsWith("s", 4));
|
|
|
|
Expect.isFalse("strstr".startsWith("st", 1));
|
|
Expect.isFalse("strstr".startsWith("st", 2));
|
|
Expect.isTrue("strstr".startsWith("st", 3));
|
|
Expect.isFalse("strstr".startsWith("st", 4));
|
|
|
|
Expect.isFalse("strstr".startsWith("str", 1));
|
|
Expect.isFalse("strstr".startsWith("str", 2));
|
|
Expect.isTrue("strstr".startsWith("str", 3));
|
|
Expect.isFalse("strstr".startsWith("str", 4));
|
|
|
|
Expect.isTrue("str".startsWith("", 0));
|
|
Expect.isTrue("str".startsWith("", 1));
|
|
Expect.isTrue("str".startsWith("", 2));
|
|
Expect.isTrue("str".startsWith("", 3));
|
|
|
|
Expect.throws(() => "str".startsWith("", -1));
|
|
Expect.throws(() => "str".startsWith("", 4));
|
|
|
|
var regexp = new RegExp("s(?:tr?)?");
|
|
Expect.isTrue("s".startsWith(regexp));
|
|
Expect.isTrue("st".startsWith(regexp));
|
|
Expect.isTrue("str".startsWith(regexp));
|
|
Expect.isTrue("sX".startsWith(regexp));
|
|
Expect.isTrue("stX".startsWith(regexp));
|
|
Expect.isTrue("strX".startsWith(regexp));
|
|
|
|
Expect.isFalse("".startsWith(regexp));
|
|
Expect.isFalse("astr".startsWith(regexp));
|
|
|
|
Expect.isTrue("".startsWith(new RegExp("")));
|
|
Expect.isTrue("".startsWith(new RegExp("a?")));
|
|
|
|
Expect.isFalse("strstr".startsWith(regexp, 1));
|
|
Expect.isFalse("strstr".startsWith(regexp, 2));
|
|
Expect.isTrue("strstr".startsWith(regexp, 3));
|
|
Expect.isFalse("strstr".startsWith(regexp, 4));
|
|
|
|
Expect.isTrue("str".startsWith(new RegExp(""), 0));
|
|
Expect.isTrue("str".startsWith(new RegExp(""), 1));
|
|
Expect.isTrue("str".startsWith(new RegExp(""), 2));
|
|
Expect.isTrue("str".startsWith(new RegExp(""), 3));
|
|
Expect.isTrue("str".startsWith(new RegExp("a?"), 0));
|
|
Expect.isTrue("str".startsWith(new RegExp("a?"), 1));
|
|
Expect.isTrue("str".startsWith(new RegExp("a?"), 2));
|
|
Expect.isTrue("str".startsWith(new RegExp("a?"), 3));
|
|
|
|
Expect.throws(() => "str".startsWith(regexp, -1));
|
|
Expect.throws(() => "str".startsWith(regexp, 4));
|
|
|
|
regexp = new RegExp("^str");
|
|
Expect.isTrue("strstr".startsWith(regexp));
|
|
Expect.isTrue("strstr".startsWith(regexp, 0));
|
|
Expect.isFalse("strstr".startsWith(regexp, 1));
|
|
Expect.isFalse("strstr".startsWith(regexp, 2));
|
|
Expect.isFalse("strstr".startsWith(regexp, 3)); // Second "str" isn't at ^.
|
|
}
|
|
|
|
void testIndexOf() {
|
|
Expect.equals(0, "str".indexOf("", 0));
|
|
Expect.equals(0, "".indexOf("", 0));
|
|
Expect.equals(-1, "".indexOf("a", 0));
|
|
|
|
Expect.equals(1, "str".indexOf("t", 0));
|
|
Expect.equals(1, "str".indexOf("tr", 0));
|
|
Expect.equals(0, "str".indexOf("str", 0));
|
|
Expect.equals(0, "str".indexOf("st", 0));
|
|
Expect.equals(0, "str".indexOf("s", 0));
|
|
Expect.equals(2, "str".indexOf("r", 0));
|
|
Expect.equals(-1, "str".indexOf("string", 0));
|
|
|
|
Expect.equals(1, "strstr".indexOf("t", 0));
|
|
Expect.equals(1, "strstr".indexOf("tr", 0));
|
|
Expect.equals(0, "strstr".indexOf("str", 0));
|
|
Expect.equals(0, "strstr".indexOf("st", 0));
|
|
Expect.equals(0, "strstr".indexOf("s", 0));
|
|
Expect.equals(2, "strstr".indexOf("r", 0));
|
|
Expect.equals(-1, "str".indexOf("string", 0));
|
|
|
|
Expect.equals(4, "strstr".indexOf("t", 2));
|
|
Expect.equals(4, "strstr".indexOf("tr", 2));
|
|
Expect.equals(3, "strstr".indexOf("str", 1));
|
|
Expect.equals(3, "strstr".indexOf("str", 2));
|
|
Expect.equals(3, "strstr".indexOf("str", 3));
|
|
Expect.equals(3, "strstr".indexOf("st", 1));
|
|
Expect.equals(3, "strstr".indexOf("s", 3));
|
|
Expect.equals(5, "strstr".indexOf("r", 3));
|
|
Expect.equals(5, "strstr".indexOf("r", 4));
|
|
Expect.equals(5, "strstr".indexOf("r", 5));
|
|
|
|
String str = "hello";
|
|
for (int i = 0; i < 10; i++) {
|
|
if (i > str.length) {
|
|
Expect.throws(() => str.indexOf("", i));
|
|
} else {
|
|
int result = str.indexOf("", i);
|
|
Expect.equals(i, result);
|
|
}
|
|
}
|
|
|
|
var re = new RegExp("an?");
|
|
Expect.equals(1, "banana".indexOf(re));
|
|
Expect.equals(1, "banana".indexOf(re, 0));
|
|
Expect.equals(1, "banana".indexOf(re, 1));
|
|
Expect.equals(3, "banana".indexOf(re, 2));
|
|
Expect.equals(3, "banana".indexOf(re, 3));
|
|
Expect.equals(5, "banana".indexOf(re, 4));
|
|
Expect.equals(5, "banana".indexOf(re, 5));
|
|
Expect.equals(-1, "banana".indexOf(re, 6));
|
|
Expect.throws(() => "banana".indexOf(re, -1));
|
|
Expect.throws(() => "banana".indexOf(re, 7));
|
|
re = new RegExp("x?");
|
|
for (int i = 0; i <= str.length; i++) {
|
|
Expect.equals(i, str.indexOf(re, i));
|
|
}
|
|
}
|
|
|
|
void testLastIndexOf() {
|
|
Expect.equals(2, "str".lastIndexOf("", 2));
|
|
Expect.equals(0, "".lastIndexOf("", 0));
|
|
Expect.equals(-1, "".lastIndexOf("a", 0));
|
|
|
|
Expect.equals(1, "str".lastIndexOf("t", 2));
|
|
Expect.equals(1, "str".lastIndexOf("tr", 2));
|
|
Expect.equals(0, "str".lastIndexOf("str", 2));
|
|
Expect.equals(0, "str".lastIndexOf("st", 2));
|
|
Expect.equals(0, "str".lastIndexOf("s", 2));
|
|
Expect.equals(2, "str".lastIndexOf("r", 2));
|
|
Expect.equals(-1, "str".lastIndexOf("string", 2));
|
|
|
|
Expect.equals(4, "strstr".lastIndexOf("t", 5));
|
|
Expect.equals(4, "strstr".lastIndexOf("tr", 5));
|
|
Expect.equals(3, "strstr".lastIndexOf("str", 5));
|
|
Expect.equals(3, "strstr".lastIndexOf("st", 5));
|
|
Expect.equals(3, "strstr".lastIndexOf("s", 5));
|
|
Expect.equals(5, "strstr".lastIndexOf("r", 5));
|
|
Expect.throws(() {
|
|
"str".lastIndexOf("string", 5);
|
|
});
|
|
Expect.equals(4, "strstr".lastIndexOf("t", 5));
|
|
Expect.equals(4, "strstr".lastIndexOf("tr", 5));
|
|
Expect.equals(3, "strstr".lastIndexOf("str", 5));
|
|
Expect.equals(3, "strstr".lastIndexOf("str", 5));
|
|
Expect.equals(3, "strstr".lastIndexOf("str", 5));
|
|
Expect.equals(3, "strstr".lastIndexOf("st", 5));
|
|
Expect.equals(3, "strstr".lastIndexOf("s", 5));
|
|
Expect.equals(5, "strstr".lastIndexOf("r", 5));
|
|
Expect.equals(2, "strstr".lastIndexOf("r", 4));
|
|
Expect.equals(2, "strstr".lastIndexOf("r", 3));
|
|
Expect.equals(5, "strstr".lastIndexOf("r"));
|
|
Expect.equals(5, "strstr".lastIndexOf("r", null));
|
|
|
|
String str = "hello";
|
|
for (int i = 0; i < 10; i++) {
|
|
if (i > str.length) {
|
|
Expect.throws(() => str.indexOf("", i));
|
|
} else {
|
|
int result = str.lastIndexOf("", i);
|
|
Expect.equals(i, result);
|
|
}
|
|
}
|
|
|
|
var re = new RegExp("an?");
|
|
Expect.equals(5, "banana".lastIndexOf(re));
|
|
Expect.equals(5, "banana".lastIndexOf(re, 6));
|
|
Expect.equals(5, "banana".lastIndexOf(re, 5));
|
|
Expect.equals(3, "banana".lastIndexOf(re, 4));
|
|
Expect.equals(3, "banana".lastIndexOf(re, 3));
|
|
Expect.equals(1, "banana".lastIndexOf(re, 2));
|
|
Expect.equals(1, "banana".lastIndexOf(re, 1));
|
|
Expect.equals(-1, "banana".lastIndexOf(re, 0));
|
|
Expect.throws(() => "banana".lastIndexOf(re, -1));
|
|
Expect.throws(() => "banana".lastIndexOf(re, 7));
|
|
re = new RegExp("x?");
|
|
for (int i = 0; i <= str.length; i++) {
|
|
Expect.equals(i, str.indexOf(re, i));
|
|
}
|
|
}
|
|
|
|
void testContains() {
|
|
Expect.isTrue("str".contains("s", 0));
|
|
Expect.isTrue("str".contains("st", 0));
|
|
Expect.isTrue("str".contains("str", 0));
|
|
Expect.isTrue("str".contains("t", 0));
|
|
Expect.isTrue("str".contains("r", 0));
|
|
Expect.isTrue("str".contains("tr", 0));
|
|
|
|
Expect.isFalse("str".contains("sr", 0));
|
|
Expect.isFalse("str".contains("string", 0));
|
|
|
|
Expect.isTrue("str".contains("", 0));
|
|
Expect.isTrue("".contains("", 0));
|
|
Expect.isFalse("".contains("s", 0));
|
|
}
|
|
|
|
void testReplaceAll() {
|
|
Expect.equals("AtoBtoCDtoE", "AfromBfromCDfromE".replaceAll("from", "to"));
|
|
|
|
// Test with the replaced string at the beginning.
|
|
Expect.equals("toABtoCDtoE", "fromABfromCDfromE".replaceAll("from", "to"));
|
|
|
|
// Test with the replaced string at the end.
|
|
Expect.equals(
|
|
"toABtoCDtoEto", "fromABfromCDfromEfrom".replaceAll("from", "to"));
|
|
|
|
// Test when there are no occurence of the string to replace.
|
|
Expect.equals("ABC", "ABC".replaceAll("from", "to"));
|
|
|
|
// Test when the string to change is the empty string.
|
|
Expect.equals("", "".replaceAll("from", "to"));
|
|
|
|
// Test when the string to change is a substring of the string to
|
|
// replace.
|
|
Expect.equals("fro", "fro".replaceAll("from", "to"));
|
|
|
|
// Test when the string to change is the replaced string.
|
|
Expect.equals("to", "from".replaceAll("from", "to"));
|
|
|
|
// Test when the string to change is the replacement string.
|
|
Expect.equals("to", "to".replaceAll("from", "to"));
|
|
|
|
// Test replacing by the empty string.
|
|
Expect.equals("", "from".replaceAll("from", ""));
|
|
Expect.equals("AB", "AfromB".replaceAll("from", ""));
|
|
|
|
// Test changing the empty string.
|
|
Expect.equals("to", "".replaceAll("", "to"));
|
|
|
|
// Test replacing the empty string.
|
|
Expect.equals("toAtoBtoCto", "ABC".replaceAll("", "to"));
|
|
}
|
|
|
|
void testCompareTo() {
|
|
Expect.equals(0, "".compareTo(""));
|
|
Expect.equals(0, "str".compareTo("str"));
|
|
Expect.equals(-1, "str".compareTo("string"));
|
|
Expect.equals(1, "string".compareTo("str"));
|
|
Expect.equals(1, "string".compareTo(""));
|
|
Expect.equals(-1, "".compareTo("string"));
|
|
}
|
|
|
|
void testCharCodes() {
|
|
test(str) {
|
|
var list = str.codeUnits;
|
|
Expect.equals(str.length, list.length);
|
|
for (int i = 0; i < str.length; i++) {
|
|
Expect.equals(str.codeUnitAt(i), list[i]);
|
|
}
|
|
}
|
|
|
|
test("abc");
|
|
test("");
|
|
test(" ");
|
|
}
|
|
|
|
void testStringLength(int length, String str) {
|
|
Expect.equals(length, str.length);
|
|
(length == 0 ? Expect.isTrue : Expect.isFalse)(str.isEmpty);
|
|
(length != 0 ? Expect.isTrue : Expect.isFalse)(str.isNotEmpty);
|
|
}
|
|
|
|
void testRepeat() {
|
|
List<String> testStrings = [
|
|
"",
|
|
"\x00",
|
|
"a",
|
|
"ab",
|
|
"\x80",
|
|
"\xff",
|
|
"\u2028",
|
|
"abcdef\u2028",
|
|
"\u{10002}",
|
|
"abcdef\u{10002}"
|
|
];
|
|
List<int> counts = [
|
|
0,
|
|
1,
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7,
|
|
8,
|
|
9,
|
|
10,
|
|
11,
|
|
12,
|
|
13,
|
|
14,
|
|
15,
|
|
16,
|
|
17,
|
|
127,
|
|
128,
|
|
129
|
|
];
|
|
void testRepeat(str, repeat) {
|
|
String expect;
|
|
if (repeat <= 0) {
|
|
expect = "";
|
|
} else if (repeat == 1) {
|
|
expect = str;
|
|
} else {
|
|
StringBuffer buf = new StringBuffer();
|
|
for (int i = 0; i < repeat; i++) {
|
|
buf.write(str);
|
|
}
|
|
expect = buf.toString();
|
|
}
|
|
String actual = str * repeat;
|
|
Expect.equals(expect, actual, "$str#${str.length} * $repeat");
|
|
}
|
|
|
|
for (String str in testStrings) {
|
|
for (int repeat in counts) {
|
|
testRepeat(str, repeat);
|
|
}
|
|
}
|
|
}
|
|
|
|
void testPadLeft() {
|
|
Expect.equals(" 1", "1".padLeft(5, ' '));
|
|
Expect.equals(" 11", "11".padLeft(5, ' '));
|
|
Expect.equals(" 111", "111".padLeft(5, ' '));
|
|
Expect.equals(" 1111", "1111".padLeft(5, ' '));
|
|
Expect.equals("11111", "11111".padLeft(5, ' '));
|
|
Expect.equals("111111", "111111".padLeft(5, ' '));
|
|
Expect.equals(" \u{10002}", "\u{10002}".padLeft(5, ' '));
|
|
Expect.equals('', ''.padLeft(0, 'a'));
|
|
Expect.equals('a', ''.padLeft(1, 'a'));
|
|
Expect.equals('aaaaa', ''.padLeft(5, 'a'));
|
|
Expect.equals('', ''.padLeft(-2, 'a'));
|
|
|
|
Expect.equals('xyzxyzxyzxyzxyz', ''.padLeft(5, 'xyz'));
|
|
Expect.equals('xyzxyzxyzxyza', 'a'.padLeft(5, 'xyz'));
|
|
Expect.equals('xyzxyzxyzaa', 'aa'.padLeft(5, 'xyz'));
|
|
Expect.equals('\u{10002}\u{10002}\u{10002}aa', 'aa'.padLeft(5, '\u{10002}'));
|
|
Expect.equals('a', 'a'.padLeft(10, ''));
|
|
}
|
|
|
|
void testPadRight() {
|
|
Expect.equals("1 ", "1".padRight(5, ' '));
|
|
Expect.equals("11 ", "11".padRight(5, ' '));
|
|
Expect.equals("111 ", "111".padRight(5, ' '));
|
|
Expect.equals("1111 ", "1111".padRight(5, ' '));
|
|
Expect.equals("11111", "11111".padRight(5, ' '));
|
|
Expect.equals("111111", "111111".padRight(5, ' '));
|
|
Expect.equals("\u{10002} ", "\u{10002}".padRight(5, ' '));
|
|
Expect.equals('', ''.padRight(0, 'a'));
|
|
Expect.equals('a', ''.padRight(1, 'a'));
|
|
Expect.equals('aaaaa', ''.padRight(5, 'a'));
|
|
Expect.equals('', ''.padRight(-2, 'a'));
|
|
|
|
Expect.equals('xyzxyzxyzxyzxyz', ''.padRight(5, 'xyz'));
|
|
Expect.equals('axyzxyzxyzxyz', 'a'.padRight(5, 'xyz'));
|
|
Expect.equals('aaxyzxyzxyz', 'aa'.padRight(5, 'xyz'));
|
|
Expect.equals('aa\u{10002}\u{10002}\u{10002}', 'aa'.padRight(5, '\u{10002}'));
|
|
Expect.equals('a', 'a'.padRight(10, ''));
|
|
}
|