mirror of
https://github.com/danog/dart-sass.git
synced 2024-11-27 04:34:59 +01:00
Add tests for Value subclasses
Now that these are an exposed part of the API, they need to be tested.
This commit is contained in:
Natalie Weizenbaum
parent
e5af175b55
commit
ce1cc18c0e
133
test/dart_api/function_test.dart
Normal file
133
test/dart_api/function_test.dart
Normal file
@ -0,0 +1,133 @@
|
||||
// Copyright 2018 Google Inc. Use of this source code is governed by an
|
||||
// MIT-style license that can be found in the LICENSE file or at
|
||||
// https://opensource.org/licenses/MIT.
|
||||
|
||||
@TestOn('vm')
|
||||
|
||||
import 'package:test/test.dart';
|
||||
|
||||
import 'package:sass/sass.dart';
|
||||
import 'package:sass/src/exception.dart';
|
||||
|
||||
main() {
|
||||
test(
|
||||
"new Callable() throws a SassFormatException if the argument list is "
|
||||
"invalid", () {
|
||||
expect(() => new Callable("foo", "arg", (_) => sassNull),
|
||||
throwsA(new isInstanceOf<SassFormatException>()));
|
||||
});
|
||||
|
||||
test(
|
||||
"new AsyncCallable() throws a SassFormatException if the argument list "
|
||||
"is invalid", () {
|
||||
expect(() => new AsyncCallable("foo", "arg", (_) async => sassNull),
|
||||
throwsA(new isInstanceOf<SassFormatException>()));
|
||||
});
|
||||
|
||||
test("passes an argument to a custom function and uses its return value", () {
|
||||
var css = compileString('a {b: foo(bar)}', functions: [
|
||||
new Callable("foo", r"$arg", expectAsync1((arguments) {
|
||||
expect(arguments, hasLength(1));
|
||||
expect(arguments.first.assertString().text, equals("bar"));
|
||||
return new SassString("result");
|
||||
}))
|
||||
]);
|
||||
|
||||
expect(css, equalsIgnoringWhitespace("a { b: result; }"));
|
||||
});
|
||||
|
||||
test("runs a function asynchronously", () async {
|
||||
var css = await compileStringAsync('a {b: foo(bar)}', functions: [
|
||||
new AsyncCallable("foo", r"$arg", expectAsync1((arguments) async {
|
||||
expect(arguments, hasLength(1));
|
||||
expect(arguments.first.assertString().text, equals("bar"));
|
||||
await pumpEventQueue();
|
||||
return new SassString("result");
|
||||
}))
|
||||
]);
|
||||
|
||||
expect(css, equalsIgnoringWhitespace("a { b: result; }"));
|
||||
});
|
||||
|
||||
test("passes no arguments to a custom function", () {
|
||||
expect(
|
||||
compileString('a {b: foo()}', functions: [
|
||||
new Callable("foo", "", expectAsync1((arguments) {
|
||||
expect(arguments, isEmpty);
|
||||
return sassNull;
|
||||
}))
|
||||
]),
|
||||
isEmpty);
|
||||
});
|
||||
|
||||
test("passes multiple arguments to a custom function", () {
|
||||
expect(
|
||||
compileString('a {b: foo(x, y, z)}', functions: [
|
||||
new Callable("foo", r"$arg1, $arg2, $arg3", expectAsync1((arguments) {
|
||||
expect(arguments, hasLength(3));
|
||||
expect(arguments[0].assertString().text, equals("x"));
|
||||
expect(arguments[1].assertString().text, equals("y"));
|
||||
expect(arguments[2].assertString().text, equals("z"));
|
||||
return sassNull;
|
||||
}))
|
||||
]),
|
||||
isEmpty);
|
||||
});
|
||||
|
||||
test("gracefuly handles a custom function throwing", () {
|
||||
expect(() {
|
||||
compileString('a {b: foo()}',
|
||||
functions: [new Callable("foo", "", (arguments) => throw "heck")]);
|
||||
}, throwsA(new isInstanceOf<SassException>()));
|
||||
});
|
||||
|
||||
test("gracefuly handles a custom function returning null", () {
|
||||
expect(() {
|
||||
compileString('a {b: foo()}',
|
||||
functions: [new Callable("foo", "", (arguments) => null)]);
|
||||
}, throwsA(new isInstanceOf<SassException>()));
|
||||
});
|
||||
|
||||
test("supports default argument values", () {
|
||||
var css = compileString('a {b: foo()}', functions: [
|
||||
new Callable("foo", r"$arg: 1", expectAsync1((arguments) {
|
||||
expect(arguments, hasLength(1));
|
||||
expect(arguments.first.assertNumber().value, equals(1));
|
||||
return arguments.first;
|
||||
}))
|
||||
]);
|
||||
|
||||
expect(css, equalsIgnoringWhitespace("a { b: 1; }"));
|
||||
});
|
||||
|
||||
test("supports argument lists", () {
|
||||
var css = compileString('a {b: foo(1, 2, 3)}', functions: [
|
||||
new Callable("foo", r"$args...", expectAsync1((arguments) {
|
||||
expect(arguments, hasLength(1));
|
||||
var list = arguments[0] as SassArgumentList;
|
||||
expect(list.asList, hasLength(3));
|
||||
expect(list.asList[0].assertNumber().value, equals(1));
|
||||
expect(list.asList[1].assertNumber().value, equals(2));
|
||||
expect(list.asList[2].assertNumber().value, equals(3));
|
||||
return arguments.first;
|
||||
}))
|
||||
]);
|
||||
|
||||
expect(css, equalsIgnoringWhitespace("a { b: 1, 2, 3; }"));
|
||||
});
|
||||
|
||||
test("supports keyword arguments", () {
|
||||
var css = compileString(r'a {b: foo($bar: 1)}', functions: [
|
||||
new Callable("foo", r"$args...", expectAsync1((arguments) {
|
||||
expect(arguments, hasLength(1));
|
||||
var list = arguments[0] as SassArgumentList;
|
||||
expect(list.asList, hasLength(0));
|
||||
expect(list.keywords, contains("bar"));
|
||||
expect(list.keywords["bar"].assertNumber().value, equals(1));
|
||||
return list.keywords["bar"];
|
||||
}))
|
||||
]);
|
||||
|
||||
expect(css, equalsIgnoringWhitespace("a { b: 1; }"));
|
||||
});
|
||||
}
|
||||
73
test/dart_api/value/boolean_test.dart
Normal file
73
test/dart_api/value/boolean_test.dart
Normal file
@ -0,0 +1,73 @@
|
||||
// Copyright 2018 Google Inc. Use of this source code is governed by an
|
||||
// MIT-style license that can be found in the LICENSE file or at
|
||||
// https://opensource.org/licenses/MIT.
|
||||
|
||||
@TestOn("vm")
|
||||
|
||||
import 'package:test/test.dart';
|
||||
|
||||
import 'package:sass/sass.dart';
|
||||
|
||||
import 'utils.dart';
|
||||
|
||||
main() {
|
||||
group("true", () {
|
||||
Value value;
|
||||
setUp(() => value = parseValue("true"));
|
||||
|
||||
test("is truthy", () {
|
||||
expect(value.isTruthy, isTrue);
|
||||
});
|
||||
|
||||
test("is sassTrue", () {
|
||||
expect(value, equalsWithHash(sassTrue));
|
||||
});
|
||||
|
||||
test("is a boolean", () {
|
||||
expect(value.assertBoolean(), equals(value));
|
||||
});
|
||||
|
||||
test("isn't any other type", () {
|
||||
expect(value.assertColor, throwsSassScriptException);
|
||||
expect(value.assertFunction, throwsSassScriptException);
|
||||
expect(value.assertMap, throwsSassScriptException);
|
||||
expect(value.assertNumber, throwsSassScriptException);
|
||||
expect(value.assertString, throwsSassScriptException);
|
||||
});
|
||||
});
|
||||
|
||||
group("false", () {
|
||||
Value value;
|
||||
setUp(() => value = parseValue("false"));
|
||||
|
||||
test("is falsey", () {
|
||||
expect(value.isTruthy, isFalse);
|
||||
});
|
||||
|
||||
test("is sassFalse", () {
|
||||
expect(value, equalsWithHash(sassFalse));
|
||||
});
|
||||
|
||||
test("is a boolean", () {
|
||||
expect(value.assertBoolean(), equals(value));
|
||||
});
|
||||
|
||||
test("isn't any other type", () {
|
||||
expect(value.assertColor, throwsSassScriptException);
|
||||
expect(value.assertFunction, throwsSassScriptException);
|
||||
expect(value.assertMap, throwsSassScriptException);
|
||||
expect(value.assertNumber, throwsSassScriptException);
|
||||
expect(value.assertString, throwsSassScriptException);
|
||||
});
|
||||
});
|
||||
|
||||
group("new SassBoolean()", () {
|
||||
test("returns sassTrue", () {
|
||||
expect(new SassBoolean(true), equals(sassTrue));
|
||||
});
|
||||
|
||||
test("returns sassFalse", () {
|
||||
expect(new SassBoolean(false), equals(sassFalse));
|
||||
});
|
||||
});
|
||||
}
|
||||
217
test/dart_api/value/color_test.dart
Normal file
217
test/dart_api/value/color_test.dart
Normal file
@ -0,0 +1,217 @@
|
||||
// Copyright 2018 Google Inc. Use of this source code is governed by an
|
||||
// MIT-style license that can be found in the LICENSE file or at
|
||||
// https://opensource.org/licenses/MIT.
|
||||
|
||||
@TestOn("vm")
|
||||
|
||||
import 'package:test/test.dart';
|
||||
|
||||
import 'package:sass/sass.dart';
|
||||
import 'package:sass/src/util/number.dart';
|
||||
|
||||
import 'utils.dart';
|
||||
|
||||
main() {
|
||||
group("an RGB color", () {
|
||||
SassColor value;
|
||||
setUp(() => value = parseValue("#123456") as SassColor);
|
||||
|
||||
test("has RGB channels", () {
|
||||
expect(value.red, equals(0x12));
|
||||
expect(value.green, equals(0x34));
|
||||
expect(value.blue, equals(0x56));
|
||||
});
|
||||
|
||||
test("has HSL channels", () {
|
||||
expect(value.hue, equals(210));
|
||||
expect(value.saturation, equals(65.3846153846154));
|
||||
expect(value.lightness, equals(20.392156862745097));
|
||||
});
|
||||
|
||||
test("has an alpha channel", () {
|
||||
expect(value.alpha, equals(1));
|
||||
});
|
||||
|
||||
test("equals the same color", () {
|
||||
expect(value, equalsWithHash(new SassColor.rgb(0x12, 0x34, 0x56)));
|
||||
expect(
|
||||
value,
|
||||
equalsWithHash(
|
||||
new SassColor.hsl(210, 65.3846153846154, 20.392156862745097)));
|
||||
});
|
||||
|
||||
group("changeRgb()", () {
|
||||
test("changes RGB values", () {
|
||||
expect(value.changeRgb(red: 0xAA),
|
||||
equals(new SassColor.rgb(0xAA, 0x34, 0x56)));
|
||||
expect(value.changeRgb(green: 0xAA),
|
||||
equals(new SassColor.rgb(0x12, 0xAA, 0x56)));
|
||||
expect(value.changeRgb(blue: 0xAA),
|
||||
equals(new SassColor.rgb(0x12, 0x34, 0xAA)));
|
||||
expect(value.changeRgb(alpha: 0.5),
|
||||
equals(new SassColor.rgb(0x12, 0x34, 0x56, 0.5)));
|
||||
expect(value.changeRgb(red: 0xAA, green: 0xAA, blue: 0xAA, alpha: 0.5),
|
||||
equals(new SassColor.rgb(0xAA, 0xAA, 0xAA, 0.5)));
|
||||
});
|
||||
|
||||
test("allows valid values", () {
|
||||
expect(value.changeRgb(red: 0).red, equals(0));
|
||||
expect(value.changeRgb(red: 0xFF).red, equals(0xFF));
|
||||
expect(value.changeRgb(green: 0).green, equals(0));
|
||||
expect(value.changeRgb(green: 0xFF).green, equals(0xFF));
|
||||
expect(value.changeRgb(blue: 0).blue, equals(0));
|
||||
expect(value.changeRgb(blue: 0xFF).blue, equals(0xFF));
|
||||
expect(value.changeRgb(alpha: 0).alpha, equals(0));
|
||||
expect(value.changeRgb(alpha: 1).alpha, equals(1));
|
||||
});
|
||||
|
||||
test("disallows invalid values", () {
|
||||
expect(() => value.changeRgb(red: -1), throwsRangeError);
|
||||
expect(() => value.changeRgb(red: 0x100), throwsRangeError);
|
||||
expect(() => value.changeRgb(green: -1), throwsRangeError);
|
||||
expect(() => value.changeRgb(green: 0x100), throwsRangeError);
|
||||
expect(() => value.changeRgb(blue: -1), throwsRangeError);
|
||||
expect(() => value.changeRgb(blue: 0x100), throwsRangeError);
|
||||
expect(() => value.changeRgb(alpha: -0.1), throwsRangeError);
|
||||
expect(() => value.changeRgb(alpha: 1.1), throwsRangeError);
|
||||
});
|
||||
});
|
||||
|
||||
group("changeHsl()", () {
|
||||
test("changes HSL values", () {
|
||||
expect(
|
||||
value.changeHsl(hue: 120),
|
||||
equals(
|
||||
new SassColor.hsl(120, 65.3846153846154, 20.392156862745097)));
|
||||
expect(value.changeHsl(saturation: 42),
|
||||
equals(new SassColor.hsl(210, 42, 20.392156862745097)));
|
||||
expect(value.changeHsl(lightness: 42),
|
||||
equals(new SassColor.hsl(210, 65.3846153846154, 42)));
|
||||
expect(
|
||||
value.changeHsl(alpha: 0.5),
|
||||
equals(new SassColor.hsl(
|
||||
210, 65.3846153846154, 20.392156862745097, 0.5)));
|
||||
expect(
|
||||
value.changeHsl(
|
||||
hue: 120, saturation: 42, lightness: 42, alpha: 0.5),
|
||||
equals(new SassColor.hsl(120, 42, 42, 0.5)));
|
||||
});
|
||||
|
||||
test("allows valid values", () {
|
||||
expect(value.changeHsl(saturation: 0).saturation, equals(0));
|
||||
expect(value.changeHsl(saturation: 100).saturation, equals(100));
|
||||
expect(value.changeHsl(lightness: 0).lightness, equals(0));
|
||||
expect(value.changeHsl(lightness: 100).lightness, equals(100));
|
||||
expect(value.changeHsl(alpha: 0).alpha, equals(0));
|
||||
expect(value.changeHsl(alpha: 1).alpha, equals(1));
|
||||
});
|
||||
|
||||
test("disallows invalid values", () {
|
||||
expect(() => value.changeHsl(saturation: -0.1), throwsRangeError);
|
||||
expect(() => value.changeHsl(saturation: 100.1), throwsRangeError);
|
||||
expect(() => value.changeHsl(lightness: -0.1), throwsRangeError);
|
||||
expect(() => value.changeHsl(lightness: 100.1), throwsRangeError);
|
||||
expect(() => value.changeHsl(alpha: -0.1), throwsRangeError);
|
||||
expect(() => value.changeHsl(alpha: 1.1), throwsRangeError);
|
||||
});
|
||||
});
|
||||
|
||||
group("changeAlpha()", () {
|
||||
test("changes the alpha value", () {
|
||||
expect(value.changeAlpha(0.5),
|
||||
equals(new SassColor.rgb(0x12, 0x34, 0x56, 0.5)));
|
||||
});
|
||||
|
||||
test("allows valid alphas", () {
|
||||
expect(value.changeAlpha(0).alpha, equals(0));
|
||||
expect(value.changeAlpha(1).alpha, equals(1));
|
||||
});
|
||||
|
||||
test("rejects invalid alphas", () {
|
||||
expect(() => value.changeAlpha(-0.1), throwsRangeError);
|
||||
expect(() => value.changeAlpha(1.1), throwsRangeError);
|
||||
});
|
||||
});
|
||||
|
||||
test("is a color", () {
|
||||
expect(value.assertColor(), equals(value));
|
||||
});
|
||||
|
||||
test("isn't any other type", () {
|
||||
expect(value.assertBoolean, throwsSassScriptException);
|
||||
expect(value.assertFunction, throwsSassScriptException);
|
||||
expect(value.assertMap, throwsSassScriptException);
|
||||
expect(value.assertNumber, throwsSassScriptException);
|
||||
expect(value.assertString, throwsSassScriptException);
|
||||
});
|
||||
});
|
||||
|
||||
group("an HSL color", () {
|
||||
SassColor value;
|
||||
setUp(() => value = parseValue("hsl(120, 42%, 42%)") as SassColor);
|
||||
|
||||
test("has RGB channels", () {
|
||||
expect(value.red, equals(0x3E));
|
||||
expect(value.green, equals(0x98));
|
||||
expect(value.blue, equals(0x3E));
|
||||
});
|
||||
|
||||
test("has HSL channels", () {
|
||||
expect(value.hue, equals(120));
|
||||
expect(value.saturation, equals(42));
|
||||
expect(value.lightness, equals(42));
|
||||
});
|
||||
|
||||
test("has an alpha channel", () {
|
||||
expect(value.alpha, equals(1));
|
||||
});
|
||||
|
||||
test("equals the same color", () {
|
||||
expect(value, equalsWithHash(new SassColor.rgb(0x3E, 0x98, 0x3E)));
|
||||
expect(value, equalsWithHash(new SassColor.hsl(120, 42, 42)));
|
||||
});
|
||||
});
|
||||
|
||||
test("an RGBA color has an alpha channel", () {
|
||||
var color = parseValue("rgba(10, 20, 30, 0.7)") as SassColor;
|
||||
expect(color.alpha, closeTo(0.7, epsilon));
|
||||
});
|
||||
|
||||
group("new SassColor.rgb()", () {
|
||||
test("allows valid values", () {
|
||||
expect(new SassColor.rgb(0, 0, 0, 0),
|
||||
equals(parseValue("rgba(0, 0, 0, 0)")));
|
||||
expect(
|
||||
new SassColor.rgb(0xFF, 0xFF, 0xFF, 1), equals(parseValue("#fff")));
|
||||
});
|
||||
|
||||
test("disallows invalid values", () {
|
||||
expect(() => new SassColor.rgb(-1, 0, 0, 0), throwsRangeError);
|
||||
expect(() => new SassColor.rgb(0, -1, 0, 0), throwsRangeError);
|
||||
expect(() => new SassColor.rgb(0, 0, -1, 0), throwsRangeError);
|
||||
expect(() => new SassColor.rgb(0, 0, 0, -0.1), throwsRangeError);
|
||||
expect(() => new SassColor.rgb(0x100, 0, 0, 0), throwsRangeError);
|
||||
expect(() => new SassColor.rgb(0, 0x100, 0, 0), throwsRangeError);
|
||||
expect(() => new SassColor.rgb(0, 0, 0x100, 0), throwsRangeError);
|
||||
expect(() => new SassColor.rgb(0, 0, 0, 1.1), throwsRangeError);
|
||||
});
|
||||
});
|
||||
|
||||
group("new SassColor.hsl()", () {
|
||||
test("allows valid values", () {
|
||||
expect(new SassColor.hsl(0, 0, 0, 0),
|
||||
equals(parseValue("hsla(0, 0, 0, 0)")));
|
||||
expect(new SassColor.hsl(4320, 100, 100, 1),
|
||||
equals(parseValue("hsl(4320, 100, 100)")));
|
||||
});
|
||||
|
||||
test("disallows invalid values", () {
|
||||
expect(() => new SassColor.hsl(0, -0.1, 0, 0), throwsRangeError);
|
||||
expect(() => new SassColor.hsl(0, 0, -0.1, 0), throwsRangeError);
|
||||
expect(() => new SassColor.hsl(0, 0, 0, -0.1), throwsRangeError);
|
||||
expect(() => new SassColor.hsl(0, 100.1, 0, 0), throwsRangeError);
|
||||
expect(() => new SassColor.hsl(0, 0, 100.1, 0), throwsRangeError);
|
||||
expect(() => new SassColor.hsl(0, 0, 0, 1.1), throwsRangeError);
|
||||
});
|
||||
});
|
||||
}
|
||||
52
test/dart_api/value/function_test.dart
Normal file
52
test/dart_api/value/function_test.dart
Normal file
@ -0,0 +1,52 @@
|
||||
// Copyright 2018 Google Inc. Use of this source code is governed by an
|
||||
// MIT-style license that can be found in the LICENSE file or at
|
||||
// https://opensource.org/licenses/MIT.
|
||||
|
||||
@TestOn("vm")
|
||||
|
||||
import 'package:test/test.dart';
|
||||
|
||||
import 'package:sass/sass.dart';
|
||||
|
||||
import 'utils.dart';
|
||||
|
||||
main() {
|
||||
group("a function value", () {
|
||||
SassFunction value;
|
||||
setUp(() => value = parseValue("get-function('red')") as SassFunction);
|
||||
|
||||
test("has a callable with the given name", () {
|
||||
expect(value.callable.name, equals("red"));
|
||||
});
|
||||
|
||||
test("is a function", () {
|
||||
expect(value.assertFunction(), equals(value));
|
||||
});
|
||||
|
||||
test("equals the same function", () {
|
||||
expect(value, equalsWithHash(parseValue("get-function('red')")));
|
||||
});
|
||||
|
||||
test("isn't any other type", () {
|
||||
expect(value.assertBoolean, throwsSassScriptException);
|
||||
expect(value.assertColor, throwsSassScriptException);
|
||||
expect(value.assertMap, throwsSassScriptException);
|
||||
expect(value.assertNumber, throwsSassScriptException);
|
||||
expect(value.assertString, throwsSassScriptException);
|
||||
});
|
||||
});
|
||||
|
||||
test("can return a new function", () {
|
||||
var css = compileString("a {b: call(foo(), 12)}", functions: [
|
||||
new Callable("foo", "", (_) {
|
||||
return new SassFunction(new Callable(
|
||||
"bar",
|
||||
r"$arg",
|
||||
(arguments) =>
|
||||
new SassNumber(arguments[0].assertNumber().value + 1)));
|
||||
})
|
||||
]);
|
||||
|
||||
expect(css, equalsIgnoringWhitespace("a { b: 13; }"));
|
||||
});
|
||||
}
|
||||
205
test/dart_api/value/list_test.dart
Normal file
205
test/dart_api/value/list_test.dart
Normal file
@ -0,0 +1,205 @@
|
||||
// Copyright 2018 Google Inc. Use of this source code is governed by an
|
||||
// MIT-style license that can be found in the LICENSE file or at
|
||||
// https://opensource.org/licenses/MIT.
|
||||
|
||||
@TestOn("vm")
|
||||
|
||||
import 'package:test/test.dart';
|
||||
|
||||
import 'package:sass/sass.dart';
|
||||
|
||||
import 'utils.dart';
|
||||
|
||||
main() {
|
||||
group("a comma-separated list", () {
|
||||
Value value;
|
||||
setUp(() => value = parseValue("a, b, c"));
|
||||
|
||||
test("is comma-separated", () {
|
||||
expect(value.separator, equals(ListSeparator.comma));
|
||||
});
|
||||
|
||||
test("has no brackets", () {
|
||||
expect(value.hasBrackets, isFalse);
|
||||
});
|
||||
|
||||
test("returns its contents as a list", () {
|
||||
expect(
|
||||
value.asList,
|
||||
equals(
|
||||
[new SassString("a"), new SassString("b"), new SassString("c")]));
|
||||
});
|
||||
|
||||
test("equals the same list", () {
|
||||
expect(
|
||||
value,
|
||||
equalsWithHash(new SassList(
|
||||
[new SassString("a"), new SassString("b"), new SassString("c")],
|
||||
ListSeparator.comma)));
|
||||
});
|
||||
|
||||
test("doesn't equal a value with different metadata", () {
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(new SassList(
|
||||
[new SassString("a"), new SassString("b"), new SassString("c")],
|
||||
ListSeparator.space))));
|
||||
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(new SassList([
|
||||
new SassString("a"),
|
||||
new SassString("b"),
|
||||
new SassString("c")
|
||||
], ListSeparator.comma, brackets: true))));
|
||||
});
|
||||
|
||||
test("doesn't equal a value with different contents", () {
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(new SassList(
|
||||
[new SassString("a"), new SassString("x"), new SassString("c")],
|
||||
ListSeparator.comma))));
|
||||
});
|
||||
|
||||
test("isn't any other type", () {
|
||||
expect(value.assertBoolean, throwsSassScriptException);
|
||||
expect(value.assertColor, throwsSassScriptException);
|
||||
expect(value.assertFunction, throwsSassScriptException);
|
||||
expect(value.assertMap, throwsSassScriptException);
|
||||
expect(value.assertNumber, throwsSassScriptException);
|
||||
expect(value.assertString, throwsSassScriptException);
|
||||
});
|
||||
});
|
||||
|
||||
test("a space-separated list is space-separated", () {
|
||||
expect(parseValue("a, b, c").separator, equals(ListSeparator.comma));
|
||||
});
|
||||
|
||||
test("a bracketed list has brackets", () {
|
||||
expect(parseValue("[a, b, c]").hasBrackets, isTrue);
|
||||
});
|
||||
|
||||
group("a single-element list", () {
|
||||
Value value;
|
||||
setUp(() => value = parseValue("[1]"));
|
||||
|
||||
test("has an undecided separator", () {
|
||||
expect(value.separator, equals(ListSeparator.undecided));
|
||||
});
|
||||
|
||||
test("returns its contents as a list", () {
|
||||
expect(value.asList, equals([new SassNumber(1)]));
|
||||
});
|
||||
|
||||
test("isn't any other type", () {
|
||||
expect(value.assertBoolean, throwsSassScriptException);
|
||||
expect(value.assertColor, throwsSassScriptException);
|
||||
expect(value.assertFunction, throwsSassScriptException);
|
||||
expect(value.assertMap, throwsSassScriptException);
|
||||
expect(value.assertNumber, throwsSassScriptException);
|
||||
expect(value.assertString, throwsSassScriptException);
|
||||
});
|
||||
});
|
||||
|
||||
test("a comma-separated single-element list is comma-separated", () {
|
||||
expect(parseValue("(1,)").separator, equals(ListSeparator.comma));
|
||||
});
|
||||
|
||||
group("an empty list", () {
|
||||
Value value;
|
||||
setUp(() => value = parseValue("()"));
|
||||
|
||||
test("has an undecided separator", () {
|
||||
expect(value.separator, equals(ListSeparator.undecided));
|
||||
});
|
||||
|
||||
test("returns its contents as a list", () {
|
||||
expect(value.asList, isEmpty);
|
||||
});
|
||||
|
||||
test("equals an empty map", () {
|
||||
expect(value, equalsWithHash(new SassMap.empty()));
|
||||
});
|
||||
|
||||
test("counts as an empty map", () {
|
||||
expect(value.assertMap().contents, isEmpty);
|
||||
});
|
||||
|
||||
test("isn't any other type", () {
|
||||
expect(value.assertBoolean, throwsSassScriptException);
|
||||
expect(value.assertColor, throwsSassScriptException);
|
||||
expect(value.assertFunction, throwsSassScriptException);
|
||||
expect(value.assertNumber, throwsSassScriptException);
|
||||
expect(value.assertString, throwsSassScriptException);
|
||||
});
|
||||
});
|
||||
|
||||
group("a scalar value", () {
|
||||
Value value;
|
||||
setUp(() => value = parseValue("blue"));
|
||||
|
||||
test("has an undecided separator", () {
|
||||
expect(value.separator, equals(ListSeparator.undecided));
|
||||
});
|
||||
|
||||
test("has no brackets", () {
|
||||
expect(value.hasBrackets, isFalse);
|
||||
});
|
||||
|
||||
test("returns itself as a list", () {
|
||||
var list = value.asList;
|
||||
expect(list, hasLength(1));
|
||||
expect(list.first, same(value));
|
||||
});
|
||||
});
|
||||
|
||||
group("new SassList.empty()", () {
|
||||
test("creates an empty list with default metadata", () {
|
||||
var list = new SassList.empty();
|
||||
expect(list.asList, isEmpty);
|
||||
expect(list.separator, equals(ListSeparator.undecided));
|
||||
expect(list.hasBrackets, isFalse);
|
||||
});
|
||||
|
||||
test("can set the metadata", () {
|
||||
var list =
|
||||
new SassList.empty(separator: ListSeparator.space, brackets: true);
|
||||
expect(list.separator, equals(ListSeparator.space));
|
||||
expect(list.hasBrackets, isTrue);
|
||||
});
|
||||
});
|
||||
|
||||
group("new SassList()", () {
|
||||
test("creates a list with the given contents and metadata", () {
|
||||
var list = new SassList([new SassString("a")], ListSeparator.space);
|
||||
expect(list.asList, equals([new SassString("a")]));
|
||||
expect(list.separator, equals(ListSeparator.space));
|
||||
expect(list.hasBrackets, isFalse);
|
||||
});
|
||||
|
||||
test("can create a bracketed list", () {
|
||||
expect(
|
||||
new SassList([new SassString("a")], ListSeparator.space,
|
||||
brackets: true)
|
||||
.hasBrackets,
|
||||
isTrue);
|
||||
});
|
||||
|
||||
test("can create a short list with an undecided separator", () {
|
||||
expect(
|
||||
new SassList([new SassString("a")], ListSeparator.undecided)
|
||||
.separator,
|
||||
equals(ListSeparator.undecided));
|
||||
expect(new SassList([], ListSeparator.undecided).separator,
|
||||
equals(ListSeparator.undecided));
|
||||
});
|
||||
|
||||
test("can't create a long list with an undecided separator", () {
|
||||
expect(
|
||||
() => new SassList([new SassString("a"), new SassString("b")],
|
||||
ListSeparator.undecided),
|
||||
throwsArgumentError);
|
||||
});
|
||||
});
|
||||
}
|
||||
141
test/dart_api/value/map_test.dart
Normal file
141
test/dart_api/value/map_test.dart
Normal file
@ -0,0 +1,141 @@
|
||||
// Copyright 2018 Google Inc. Use of this source code is governed by an
|
||||
// MIT-style license that can be found in the LICENSE file or at
|
||||
// https://opensource.org/licenses/MIT.
|
||||
|
||||
@TestOn("vm")
|
||||
|
||||
import 'package:test/test.dart';
|
||||
|
||||
import 'package:sass/sass.dart';
|
||||
|
||||
import 'utils.dart';
|
||||
|
||||
main() {
|
||||
group("a map with contents", () {
|
||||
SassMap value;
|
||||
setUp(() => value = parseValue("(a: b, c: d)") as SassMap);
|
||||
|
||||
test("is comma-separated", () {
|
||||
expect(value.separator, equals(ListSeparator.comma));
|
||||
});
|
||||
|
||||
test("returns its contents as a map", () {
|
||||
expect(
|
||||
value.contents,
|
||||
equals({
|
||||
new SassString("a"): new SassString("b"),
|
||||
new SassString("c"): new SassString("d")
|
||||
}));
|
||||
});
|
||||
|
||||
test("returns its contents as a list", () {
|
||||
expect(
|
||||
value.asList,
|
||||
equals([
|
||||
new SassList([new SassString("a"), new SassString("b")],
|
||||
ListSeparator.space),
|
||||
new SassList(
|
||||
[new SassString("c"), new SassString("d")], ListSeparator.space)
|
||||
]));
|
||||
});
|
||||
|
||||
test("equals the same map", () {
|
||||
expect(
|
||||
value,
|
||||
equalsWithHash(new SassMap({
|
||||
new SassString("a"): new SassString("b"),
|
||||
new SassString("c"): new SassString("d")
|
||||
})));
|
||||
});
|
||||
|
||||
test("doesn't equal the equivalent list", () {
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(new SassList([
|
||||
new SassList([new SassString("a"), new SassString("b")],
|
||||
ListSeparator.space),
|
||||
new SassList(
|
||||
[new SassString("c"), new SassString("d")], ListSeparator.space)
|
||||
], ListSeparator.comma))));
|
||||
});
|
||||
|
||||
group("doesn't equal a map with", () {
|
||||
test("a different value", () {
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(new SassMap({
|
||||
new SassString("a"): new SassString("x"),
|
||||
new SassString("c"): new SassString("d")
|
||||
}))));
|
||||
});
|
||||
|
||||
test("a different key", () {
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(new SassMap({
|
||||
new SassString("a"): new SassString("b"),
|
||||
new SassString("x"): new SassString("d")
|
||||
}))));
|
||||
});
|
||||
|
||||
test("a missing pair", () {
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(
|
||||
new SassMap({new SassString("a"): new SassString("b")}))));
|
||||
});
|
||||
|
||||
test("an additional pair", () {
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(new SassMap({
|
||||
new SassString("a"): new SassString("b"),
|
||||
new SassString("c"): new SassString("d"),
|
||||
new SassString("e"): new SassString("f")
|
||||
}))));
|
||||
});
|
||||
});
|
||||
|
||||
test("is a map", () {
|
||||
expect(value.assertMap(), equals(value));
|
||||
});
|
||||
|
||||
test("isn't any other type", () {
|
||||
expect(value.assertBoolean, throwsSassScriptException);
|
||||
expect(value.assertColor, throwsSassScriptException);
|
||||
expect(value.assertFunction, throwsSassScriptException);
|
||||
expect(value.assertNumber, throwsSassScriptException);
|
||||
expect(value.assertString, throwsSassScriptException);
|
||||
});
|
||||
});
|
||||
|
||||
group("an empty map", () {
|
||||
SassMap value;
|
||||
setUp(() => value = parseValue("map-remove((a: b), a)") as SassMap);
|
||||
|
||||
test("is comma-separated", () {
|
||||
expect(value.separator, equals(ListSeparator.comma));
|
||||
});
|
||||
|
||||
test("returns its contents as a map", () {
|
||||
expect(value.contents, isEmpty);
|
||||
});
|
||||
|
||||
test("returns its contents as a list", () {
|
||||
expect(value.asList, isEmpty);
|
||||
});
|
||||
|
||||
test("equals an empty list", () {
|
||||
expect(value, equalsWithHash(new SassList.empty()));
|
||||
});
|
||||
});
|
||||
|
||||
test("new SassMap.empty() creates an empty map with default metadata", () {
|
||||
expect(new SassMap.empty().contents, isEmpty);
|
||||
});
|
||||
|
||||
test("new SassMap() creates a map with the given contents", () {
|
||||
var list = new SassMap({new SassString("a"): new SassString("b")});
|
||||
expect(list.contents, equals({new SassString("a"): new SassString("b")}));
|
||||
});
|
||||
}
|
||||
33
test/dart_api/value/null_test.dart
Normal file
33
test/dart_api/value/null_test.dart
Normal file
@ -0,0 +1,33 @@
|
||||
// Copyright 2018 Google Inc. Use of this source code is governed by an
|
||||
// MIT-style license that can be found in the LICENSE file or at
|
||||
// https://opensource.org/licenses/MIT.
|
||||
|
||||
@TestOn("vm")
|
||||
|
||||
import 'package:test/test.dart';
|
||||
|
||||
import 'package:sass/sass.dart';
|
||||
|
||||
import 'utils.dart';
|
||||
|
||||
main() {
|
||||
Value value;
|
||||
setUp(() => value = parseValue("null"));
|
||||
|
||||
test("is falsey", () {
|
||||
expect(value.isTruthy, isFalse);
|
||||
});
|
||||
|
||||
test("is sassNull", () {
|
||||
expect(value, equalsWithHash(sassNull));
|
||||
});
|
||||
|
||||
test("isn't any type", () {
|
||||
expect(value.assertBoolean, throwsSassScriptException);
|
||||
expect(value.assertColor, throwsSassScriptException);
|
||||
expect(value.assertFunction, throwsSassScriptException);
|
||||
expect(value.assertMap, throwsSassScriptException);
|
||||
expect(value.assertNumber, throwsSassScriptException);
|
||||
expect(value.assertString, throwsSassScriptException);
|
||||
});
|
||||
}
|
||||
293
test/dart_api/value/number_test.dart
Normal file
293
test/dart_api/value/number_test.dart
Normal file
@ -0,0 +1,293 @@
|
||||
// Copyright 2018 Google Inc. Use of this source code is governed by an
|
||||
// MIT-style license that can be found in the LICENSE file or at
|
||||
// https://opensource.org/licenses/MIT.
|
||||
|
||||
@TestOn("vm")
|
||||
|
||||
import 'dart:math' as math;
|
||||
|
||||
import 'package:test/test.dart';
|
||||
|
||||
import 'package:sass/sass.dart';
|
||||
|
||||
import 'utils.dart';
|
||||
|
||||
main() {
|
||||
group("a unitless integer", () {
|
||||
SassNumber value;
|
||||
setUp(() => value = parseValue("123") as SassNumber);
|
||||
|
||||
test("has the correct value", () {
|
||||
expect(value.value, equals(123));
|
||||
expect(value.value, new isInstanceOf<int>());
|
||||
});
|
||||
|
||||
test("has no units", () {
|
||||
expect(value.numeratorUnits, isEmpty);
|
||||
expect(value.denominatorUnits, isEmpty);
|
||||
expect(value.hasUnits, isFalse);
|
||||
expect(value.hasUnit("px"), isFalse);
|
||||
expect(() => value.assertUnit("px"), throwsSassScriptException);
|
||||
value.assertNoUnits(); // Should not throw.
|
||||
});
|
||||
|
||||
test("is an int", () {
|
||||
expect(value.isInt, isTrue);
|
||||
expect(value.asInt, equals(123));
|
||||
expect(value.assertInt(), equals(123));
|
||||
});
|
||||
|
||||
test("can be coerced to any units", () {
|
||||
expect(
|
||||
value.coerce(["abc"], ["def"]),
|
||||
equals(new SassNumber.withUnits(123,
|
||||
numeratorUnits: ["abc"], denominatorUnits: ["def"])));
|
||||
});
|
||||
|
||||
test("can return its value in any units", () {
|
||||
expect(value.valueInUnits(["abc"], ["def"]), equals(123));
|
||||
});
|
||||
|
||||
test("equals the same number", () {
|
||||
expect(value, equalsWithHash(new SassNumber(123)));
|
||||
});
|
||||
|
||||
test("equals the same number within precision tolerance", () {
|
||||
expect(
|
||||
value,
|
||||
equalsWithHash(
|
||||
new SassNumber(123 + math.pow(10, -SassNumber.precision - 1))));
|
||||
expect(
|
||||
value,
|
||||
equalsWithHash(
|
||||
new SassNumber(123 - math.pow(10, -SassNumber.precision - 1))));
|
||||
});
|
||||
|
||||
test("doesn't equal a different number", () {
|
||||
expect(value, isNot(equals(new SassNumber(124))));
|
||||
expect(value, isNot(equals(new SassNumber(122))));
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(
|
||||
new SassNumber(123 + math.pow(10, -SassNumber.precision)))));
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(
|
||||
new SassNumber(123 - math.pow(10, -SassNumber.precision)))));
|
||||
});
|
||||
|
||||
test("doesn't equal a number with units", () {
|
||||
expect(value, isNot(equals(new SassNumber(123, "px"))));
|
||||
});
|
||||
|
||||
test("is a number", () {
|
||||
expect(value.assertNumber(), equals(value));
|
||||
});
|
||||
|
||||
test("isn't any other type", () {
|
||||
expect(value.assertBoolean, throwsSassScriptException);
|
||||
expect(value.assertColor, throwsSassScriptException);
|
||||
expect(value.assertFunction, throwsSassScriptException);
|
||||
expect(value.assertMap, throwsSassScriptException);
|
||||
expect(value.assertString, throwsSassScriptException);
|
||||
});
|
||||
});
|
||||
|
||||
group("a unitless double", () {
|
||||
SassNumber value;
|
||||
setUp(() => value = parseValue("123.456") as SassNumber);
|
||||
|
||||
test("has the correct value", () {
|
||||
expect(value.value, equals(123.456));
|
||||
});
|
||||
|
||||
test("is not an int", () {
|
||||
expect(value.isInt, isFalse);
|
||||
expect(value.asInt, isNull);
|
||||
expect(value.assertInt, throwsSassScriptException);
|
||||
});
|
||||
});
|
||||
|
||||
group("a unitless fuzzy integer", () {
|
||||
SassNumber value;
|
||||
setUp(() => value = parseValue("123.00000000001") as SassNumber);
|
||||
|
||||
test("has the correct value", () {
|
||||
expect(value.value, equals(123.00000000001));
|
||||
});
|
||||
|
||||
test("is an int", () {
|
||||
expect(value.isInt, isTrue);
|
||||
expect(value.asInt, equals(123));
|
||||
expect(value.assertInt(), equals(123));
|
||||
});
|
||||
|
||||
test("equals the same number", () {
|
||||
expect(
|
||||
value,
|
||||
equalsWithHash(
|
||||
new SassNumber(123 + math.pow(10, -SassNumber.precision - 1))));
|
||||
});
|
||||
|
||||
test("equals the same number within precision tolerance", () {
|
||||
expect(value, equalsWithHash(new SassNumber(123)));
|
||||
expect(
|
||||
value,
|
||||
equalsWithHash(
|
||||
new SassNumber(123 - math.pow(10, -SassNumber.precision - 1))));
|
||||
});
|
||||
});
|
||||
|
||||
group("an integer with a single numerator unit", () {
|
||||
SassNumber value;
|
||||
setUp(() => value = parseValue("123px") as SassNumber);
|
||||
|
||||
test("has that unit", () {
|
||||
expect(value.numeratorUnits, equals(["px"]));
|
||||
expect(value.hasUnits, isTrue);
|
||||
expect(value.hasUnit("px"), isTrue);
|
||||
value.assertUnit("px"); // Should not throw.
|
||||
expect(value.assertNoUnits, throwsSassScriptException);
|
||||
});
|
||||
|
||||
test("has no other units", () {
|
||||
expect(value.denominatorUnits, isEmpty);
|
||||
expect(value.hasUnit("in"), isFalse);
|
||||
expect(() => value.assertUnit("in"), throwsSassScriptException);
|
||||
});
|
||||
|
||||
test("can be coerced to compatible units", () {
|
||||
expect(value.coerce(["px"], []), equals(value));
|
||||
expect(value.coerce(["in"], []), equals(new SassNumber(1.28125, "in")));
|
||||
});
|
||||
|
||||
test("can return its value in compatible units", () {
|
||||
expect(value.valueInUnits(["px"], []), equals(123));
|
||||
expect(value.valueInUnits(["in"], []), equals(1.28125));
|
||||
});
|
||||
|
||||
test("equals the same number", () {
|
||||
expect(value, equalsWithHash(new SassNumber(123, "px")));
|
||||
});
|
||||
|
||||
test("equals an equivalent number", () {
|
||||
expect(value.hashCode, equals(new SassNumber(1.28125, "in").hashCode));
|
||||
expect(value, equalsWithHash(new SassNumber(1.28125, "in")));
|
||||
});
|
||||
|
||||
test("doesn't equal a unitless number", () {
|
||||
expect(value, isNot(equals(new SassNumber(123))));
|
||||
});
|
||||
|
||||
test("doesn't equal a number with different units", () {
|
||||
expect(value, isNot(equals(new SassNumber(123, "abc"))));
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(
|
||||
new SassNumber.withUnits(123, numeratorUnits: ["px", "px"]))));
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(new SassNumber.withUnits(123,
|
||||
numeratorUnits: ["px"], denominatorUnits: ["abc"]))));
|
||||
expect(
|
||||
value,
|
||||
isNot(
|
||||
equals(new SassNumber.withUnits(123, denominatorUnits: ["px"]))));
|
||||
});
|
||||
});
|
||||
|
||||
group("an integer with numerator and denominator units", () {
|
||||
SassNumber value;
|
||||
setUp(() => value = parseValue("123px / 5ms") as SassNumber);
|
||||
|
||||
test("has those units", () {
|
||||
expect(value.numeratorUnits, equals(["px"]));
|
||||
expect(value.denominatorUnits, equals(["ms"]));
|
||||
expect(value.hasUnits, isTrue);
|
||||
expect(value.assertNoUnits, throwsSassScriptException);
|
||||
});
|
||||
|
||||
test("reports false for hasUnit()", () {
|
||||
// [hasUnit] and [assertUnit] only allow a single numerator unit.
|
||||
expect(value.hasUnit("px"), isFalse);
|
||||
expect(() => value.assertUnit("px"), throwsSassScriptException);
|
||||
});
|
||||
|
||||
test("can be coerced to compatible units", () {
|
||||
expect(value.coerce(["px"], ["ms"]), equals(value));
|
||||
expect(
|
||||
value.coerce(["in"], ["s"]),
|
||||
equals(new SassNumber.withUnits(256.25,
|
||||
numeratorUnits: ["in"], denominatorUnits: ["s"])));
|
||||
});
|
||||
|
||||
test("can return its value in compatible units", () {
|
||||
expect(value.valueInUnits(["px"], ["ms"]), equals(24.6));
|
||||
expect(value.valueInUnits(["in"], ["s"]), equals(256.25));
|
||||
});
|
||||
|
||||
test("equals the same number", () {
|
||||
expect(
|
||||
value,
|
||||
equalsWithHash(new SassNumber.withUnits(24.6,
|
||||
numeratorUnits: ["px"], denominatorUnits: ["ms"])));
|
||||
});
|
||||
|
||||
test("equals an equivalent number", () {
|
||||
expect(
|
||||
value,
|
||||
equalsWithHash(new SassNumber.withUnits(256.25,
|
||||
numeratorUnits: ["in"], denominatorUnits: ["s"])));
|
||||
});
|
||||
|
||||
test("doesn't equal a unitless number", () {
|
||||
expect(value, isNot(equals(new SassNumber(24.6))));
|
||||
});
|
||||
|
||||
test("doesn't equal a number with different units", () {
|
||||
expect(value, isNot(equals(new SassNumber(24.6, "px"))));
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(
|
||||
new SassNumber.withUnits(24.6, denominatorUnits: ["ms"]))));
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(new SassNumber.withUnits(24.6,
|
||||
numeratorUnits: ["ms"], denominatorUnits: ["px"]))));
|
||||
expect(
|
||||
value,
|
||||
isNot(equals(new SassNumber.withUnits(24.6,
|
||||
numeratorUnits: ["in"], denominatorUnits: ["s"]))));
|
||||
});
|
||||
});
|
||||
|
||||
group("new SassNumber()", () {
|
||||
test("can create a unitless number", () {
|
||||
var number = new SassNumber(123.456);
|
||||
expect(number.value, equals(123.456));
|
||||
expect(number.hasUnits, isFalse);
|
||||
});
|
||||
|
||||
test("can create a number with a numerator unit", () {
|
||||
var number = new SassNumber(123.456, "px");
|
||||
expect(number.value, equals(123.456));
|
||||
expect(number.hasUnit('px'), isTrue);
|
||||
});
|
||||
});
|
||||
|
||||
group("new SassNumber.withUnits()", () {
|
||||
test("can create a unitless number", () {
|
||||
var number = new SassNumber.withUnits(123.456);
|
||||
expect(number.value, equals(123.456));
|
||||
expect(number.hasUnits, isFalse);
|
||||
});
|
||||
|
||||
test("can create a number with units", () {
|
||||
var number = new SassNumber.withUnits(123.456,
|
||||
numeratorUnits: ["px", "em"], denominatorUnits: ["ms", "kHz"]);
|
||||
expect(number.value, equals(123.456));
|
||||
expect(number.numeratorUnits, equals(["px", "em"]));
|
||||
expect(number.denominatorUnits, equals(["ms", "kHz"]));
|
||||
});
|
||||
});
|
||||
}
|
||||
89
test/dart_api/value/string_test.dart
Normal file
89
test/dart_api/value/string_test.dart
Normal file
@ -0,0 +1,89 @@
|
||||
// Copyright 2018 Google Inc. Use of this source code is governed by an
|
||||
// MIT-style license that can be found in the LICENSE file or at
|
||||
// https://opensource.org/licenses/MIT.
|
||||
|
||||
@TestOn("vm")
|
||||
|
||||
import 'package:test/test.dart';
|
||||
|
||||
import 'package:sass/sass.dart';
|
||||
|
||||
import 'utils.dart';
|
||||
|
||||
main() {
|
||||
group("an unquoted string", () {
|
||||
SassString value;
|
||||
setUp(() => value = parseValue("foobar") as SassString);
|
||||
|
||||
test("has the correct text", () {
|
||||
expect(value.text, equals("foobar"));
|
||||
});
|
||||
|
||||
test("has no quotes", () {
|
||||
expect(value.hasQuotes, isFalse);
|
||||
});
|
||||
|
||||
test("equals the same string", () {
|
||||
expect(value, equalsWithHash(new SassString("foobar", quotes: false)));
|
||||
expect(value, equalsWithHash(new SassString("foobar", quotes: true)));
|
||||
});
|
||||
|
||||
test("is a string", () {
|
||||
expect(value.assertString(), equals(value));
|
||||
});
|
||||
|
||||
test("isn't any other type", () {
|
||||
expect(value.assertBoolean, throwsSassScriptException);
|
||||
expect(value.assertColor, throwsSassScriptException);
|
||||
expect(value.assertFunction, throwsSassScriptException);
|
||||
expect(value.assertMap, throwsSassScriptException);
|
||||
expect(value.assertNumber, throwsSassScriptException);
|
||||
});
|
||||
});
|
||||
|
||||
group("a quoted string", () {
|
||||
SassString value;
|
||||
setUp(() => value = parseValue('"foobar"') as SassString);
|
||||
|
||||
test("has the correct text", () {
|
||||
expect(value.text, equals("foobar"));
|
||||
});
|
||||
|
||||
test("has quotes", () {
|
||||
expect(value.hasQuotes, isTrue);
|
||||
});
|
||||
|
||||
test("equals the same string", () {
|
||||
expect(value, equalsWithHash(new SassString("foobar", quotes: false)));
|
||||
expect(value, equalsWithHash(new SassString("foobar", quotes: true)));
|
||||
});
|
||||
});
|
||||
|
||||
group("new SassString.empty()", () {
|
||||
test("creates an empty unquoted string", () {
|
||||
var string = new SassString.empty();
|
||||
expect(string.text, isEmpty);
|
||||
expect(string.hasQuotes, isFalse);
|
||||
});
|
||||
|
||||
test("creates an empty quoted string", () {
|
||||
var string = new SassString.empty(quotes: true);
|
||||
expect(string.text, isEmpty);
|
||||
expect(string.hasQuotes, isTrue);
|
||||
});
|
||||
});
|
||||
|
||||
group("new SassString()", () {
|
||||
test("creates an unquoted string with the given text", () {
|
||||
var string = new SassString("a b c");
|
||||
expect(string.text, equals("a b c"));
|
||||
expect(string.hasQuotes, isFalse);
|
||||
});
|
||||
|
||||
test("creates a quoted string with the given text", () {
|
||||
var string = new SassString("a b c", quotes: true);
|
||||
expect(string.text, equals("a b c"));
|
||||
expect(string.hasQuotes, isTrue);
|
||||
});
|
||||
});
|
||||
}
|
||||
34
test/dart_api/value/utils.dart
Normal file
34
test/dart_api/value/utils.dart
Normal file
@ -0,0 +1,34 @@
|
||||
// Copyright 2018 Google Inc. Use of this source code is governed by an
|
||||
// MIT-style license that can be found in the LICENSE file or at
|
||||
// https://opensource.org/licenses/MIT.
|
||||
|
||||
import 'package:test/test.dart';
|
||||
|
||||
import 'package:sass/sass.dart';
|
||||
import 'package:sass/src/exception.dart';
|
||||
|
||||
/// Parses [source] by way of a function call.
|
||||
Value parseValue(String source) {
|
||||
Value value;
|
||||
compileString("a {b: foo(($source))}", functions: [
|
||||
new Callable("foo", r"$arg", expectAsync1((arguments) {
|
||||
expect(arguments, hasLength(1));
|
||||
value = arguments.first;
|
||||
return sassNull;
|
||||
}))
|
||||
]);
|
||||
return value;
|
||||
}
|
||||
|
||||
/// A matcher that asserts that a function throws a [SassScriptException].
|
||||
final throwsSassScriptException =
|
||||
throwsA(new isInstanceOf<SassScriptException>());
|
||||
|
||||
/// Like [equals], but asserts that the hash codes of the values are the same as
|
||||
/// well.
|
||||
Matcher equalsWithHash(expected) => predicate((actual) {
|
||||
expect(actual, equals(expected));
|
||||
expect(actual.hashCode, equals(expected.hashCode),
|
||||
reason: "Expected $actual's hash code to equal $expected's.");
|
||||
return true;
|
||||
});
|
||||
Loading…
Reference in New Issue
Block a user