Jacob Richman
2dcd56ef43
There are far too many files here to review everyone carefully. Spot checking most of the diffs look good as test code is generally written with less care than application code so lots of ugly formatting get through. If people notice files where the automated formatting bothers them feel free to comment indicating file names and I'll move spaces within comments to make the formatting cleaner and use comments to force block formatting as I have done for other case where formatting looked bad. BUG= R=efortuna@google.com Review-Url: https://codereview.chromium.org/2771453003 .
495 lines
15 KiB
Dart
495 lines
15 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();
|
|
testIllegalArgument();
|
|
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 testIllegalArgument() {
|
|
String a = "Hello";
|
|
bool exception_caught = false;
|
|
try {
|
|
var c = a[2.2]; // Throw exception.
|
|
Expect.fail("Accepting double as index");
|
|
} on ArgumentError catch (e) {
|
|
exception_caught = true;
|
|
} on TypeError catch (e) {
|
|
// Thrown in checked mode only.
|
|
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 begining.
|
|
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, ''));
|
|
}
|