blob: aad7d69e8934b82e9d1e080a1a344c2dc5e461ee [file] [log] [blame]
// Copyright (c) 2016, 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:analyzer/dart/element/nullability_suffix.dart';
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/dart/element/type_provider.dart';
import 'package:analyzer/src/dart/element/type_system.dart';
import 'package:analyzer/src/generated/constant.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
import '../../../generated/test_analysis_context.dart';
main() {
defineReflectiveSuite(() {
defineReflectiveTests(DartObjectImplTest);
});
}
const int LONG_MAX_VALUE = 0x7fffffffffffffff;
final Matcher throwsEvaluationException =
throwsA(TypeMatcher<EvaluationException>());
@reflectiveTest
class DartObjectImplTest {
late final TypeProvider _typeProvider;
late final TypeSystemImpl _typeSystem;
void setUp() {
var analysisContext = TestAnalysisContext();
_typeProvider = analysisContext.typeProviderLegacy;
_typeSystem = analysisContext.typeSystemLegacy;
}
void test_add_knownDouble_knownDouble() {
_assertAdd(_doubleValue(3.0), _doubleValue(1.0), _doubleValue(2.0));
}
void test_add_knownDouble_knownInt() {
_assertAdd(_doubleValue(3.0), _doubleValue(1.0), _intValue(2));
}
void test_add_knownDouble_unknownDouble() {
_assertAdd(_doubleValue(null), _doubleValue(1.0), _doubleValue(null));
}
void test_add_knownDouble_unknownInt() {
_assertAdd(_doubleValue(null), _doubleValue(1.0), _intValue(null));
}
void test_add_knownInt_knownInt() {
_assertAdd(_intValue(3), _intValue(1), _intValue(2));
}
void test_add_knownInt_knownString() {
_assertAdd(null, _intValue(1), _stringValue("2"));
}
void test_add_knownInt_unknownDouble() {
_assertAdd(_doubleValue(null), _intValue(1), _doubleValue(null));
}
void test_add_knownInt_unknownInt() {
_assertAdd(_intValue(null), _intValue(1), _intValue(null));
}
void test_add_knownString_knownInt() {
_assertAdd(null, _stringValue("1"), _intValue(2));
}
void test_add_knownString_knownString() {
_assertAdd(_stringValue("ab"), _stringValue("a"), _stringValue("b"));
}
void test_add_knownString_unknownString() {
_assertAdd(_stringValue(null), _stringValue("a"), _stringValue(null));
}
void test_add_unknownDouble_knownDouble() {
_assertAdd(_doubleValue(null), _doubleValue(null), _doubleValue(2.0));
}
void test_add_unknownDouble_knownInt() {
_assertAdd(_doubleValue(null), _doubleValue(null), _intValue(2));
}
void test_add_unknownInt_knownDouble() {
_assertAdd(_doubleValue(null), _intValue(null), _doubleValue(2.0));
}
void test_add_unknownInt_knownInt() {
_assertAdd(_intValue(null), _intValue(null), _intValue(2));
}
void test_add_unknownString_knownString() {
_assertAdd(_stringValue(null), _stringValue(null), _stringValue("b"));
}
void test_add_unknownString_unknownString() {
_assertAdd(_stringValue(null), _stringValue(null), _stringValue(null));
}
void test_bitAnd_knownInt_knownInt() {
_assertEagerAnd(_intValue(2), _intValue(6), _intValue(3));
}
void test_bitAnd_knownInt_knownString() {
_assertEagerAnd(null, _intValue(6), _stringValue("3"));
}
void test_bitAnd_knownInt_unknownInt() {
_assertEagerAnd(_intValue(null), _intValue(6), _intValue(null));
}
void test_bitAnd_knownString_knownInt() {
_assertEagerAnd(null, _stringValue("6"), _intValue(3));
}
void test_bitAnd_unknownInt_knownInt() {
_assertEagerAnd(_intValue(null), _intValue(null), _intValue(3));
}
void test_bitAnd_unknownInt_unknownInt() {
_assertEagerAnd(_intValue(null), _intValue(null), _intValue(null));
}
void test_bitNot_knownInt() {
_assertBitNot(_intValue(-4), _intValue(3));
}
void test_bitNot_knownString() {
_assertBitNot(null, _stringValue("6"));
}
void test_bitNot_unknownInt() {
_assertBitNot(_intValue(null), _intValue(null));
}
void test_bitOr_knownInt_knownInt() {
_assertEagerOr(_intValue(7), _intValue(6), _intValue(3));
}
void test_bitOr_knownInt_knownString() {
_assertEagerOr(null, _intValue(6), _stringValue("3"));
}
void test_bitOr_knownInt_unknownInt() {
_assertEagerOr(_intValue(null), _intValue(6), _intValue(null));
}
void test_bitOr_knownString_knownInt() {
_assertEagerOr(null, _stringValue("6"), _intValue(3));
}
void test_bitOr_unknownInt_knownInt() {
_assertEagerOr(_intValue(null), _intValue(null), _intValue(3));
}
void test_bitOr_unknownInt_unknownInt() {
_assertEagerOr(_intValue(null), _intValue(null), _intValue(null));
}
void test_bitXor_knownInt_knownInt() {
_assertEagerXor(_intValue(5), _intValue(6), _intValue(3));
}
void test_bitXor_knownInt_knownString() {
_assertEagerXor(null, _intValue(6), _stringValue("3"));
}
void test_bitXor_knownInt_unknownInt() {
_assertEagerXor(_intValue(null), _intValue(6), _intValue(null));
}
void test_bitXor_knownString_knownInt() {
_assertEagerXor(null, _stringValue("6"), _intValue(3));
}
void test_bitXor_unknownInt_knownInt() {
_assertEagerXor(_intValue(null), _intValue(null), _intValue(3));
}
void test_bitXor_unknownInt_unknownInt() {
_assertEagerXor(_intValue(null), _intValue(null), _intValue(null));
}
void test_concatenate_knownInt_knownString() {
_assertConcatenate(null, _intValue(2), _stringValue("def"));
}
void test_concatenate_knownString_knownInt() {
_assertConcatenate(null, _stringValue("abc"), _intValue(3));
}
void test_concatenate_knownString_knownString() {
_assertConcatenate(
_stringValue("abcdef"), _stringValue("abc"), _stringValue("def"));
}
void test_concatenate_knownString_unknownString() {
_assertConcatenate(
_stringValue(null), _stringValue("abc"), _stringValue(null));
}
void test_concatenate_unknownString_knownString() {
_assertConcatenate(
_stringValue(null), _stringValue(null), _stringValue("def"));
}
void test_divide_knownDouble_knownDouble() {
_assertDivide(_doubleValue(3.0), _doubleValue(6.0), _doubleValue(2.0));
}
void test_divide_knownDouble_knownInt() {
_assertDivide(_doubleValue(3.0), _doubleValue(6.0), _intValue(2));
}
void test_divide_knownDouble_unknownDouble() {
_assertDivide(_doubleValue(null), _doubleValue(6.0), _doubleValue(null));
}
void test_divide_knownDouble_unknownInt() {
_assertDivide(_doubleValue(null), _doubleValue(6.0), _intValue(null));
}
void test_divide_knownInt_knownInt() {
_assertDivide(_doubleValue(3.0), _intValue(6), _intValue(2));
}
void test_divide_knownInt_knownString() {
_assertDivide(null, _intValue(6), _stringValue("2"));
}
void test_divide_knownInt_unknownDouble() {
_assertDivide(_doubleValue(null), _intValue(6), _doubleValue(null));
}
void test_divide_knownInt_unknownInt() {
_assertDivide(_doubleValue(null), _intValue(6), _intValue(null));
}
void test_divide_knownString_knownInt() {
_assertDivide(null, _stringValue("6"), _intValue(2));
}
void test_divide_unknownDouble_knownDouble() {
_assertDivide(_doubleValue(null), _doubleValue(null), _doubleValue(2.0));
}
void test_divide_unknownDouble_knownInt() {
_assertDivide(_doubleValue(null), _doubleValue(null), _intValue(2));
}
void test_divide_unknownInt_knownDouble() {
_assertDivide(_doubleValue(null), _intValue(null), _doubleValue(2.0));
}
void test_divide_unknownInt_knownInt() {
_assertDivide(_doubleValue(null), _intValue(null), _intValue(2));
}
void test_eagerAnd_knownBool_knownBool() {
void check(bool left, bool right, bool expected) {
_assertEagerAnd(
_boolValue(expected),
_boolValue(left),
_boolValue(right),
);
}
check(false, false, false);
check(true, false, false);
check(false, true, false);
check(true, true, true);
}
void test_eagerAnd_knownBool_knownInt() {
_assertEagerAnd(null, _boolValue(true), _intValue(0));
}
void test_eagerAnd_knownBool_unknownBool() {
_assertEagerAnd(_boolValue(null), _boolValue(true), _boolValue(null));
}
void test_eagerAnd_unknownBool_knownBool() {
_assertEagerAnd(_boolValue(null), _boolValue(null), _boolValue(true));
}
void test_eagerOr_knownBool_knownBool() {
void check(bool left, bool right, bool expected) {
_assertEagerOr(
_boolValue(expected),
_boolValue(left),
_boolValue(right),
);
}
check(false, false, false);
check(true, false, true);
check(false, true, true);
check(true, true, true);
}
void test_eagerOr_knownBool_knownInt() {
_assertEagerOr(null, _boolValue(true), _intValue(0));
}
void test_eagerOr_knownBool_unknownBool() {
_assertEagerOr(_boolValue(null), _boolValue(true), _boolValue(null));
}
void test_eagerOr_unknownBool_knownBool() {
_assertEagerOr(_boolValue(null), _boolValue(null), _boolValue(true));
}
void test_eagerXor_knownBool_knownBool() {
void check(bool left, bool right, bool expected) {
_assertEagerXor(
_boolValue(expected),
_boolValue(left),
_boolValue(right),
);
}
check(false, false, false);
check(true, false, true);
check(false, true, true);
check(true, true, false);
}
void test_eagerXor_knownBool_knownInt() {
_assertEagerXor(null, _boolValue(true), _intValue(0));
}
void test_eagerXor_knownBool_unknownBool() {
_assertEagerXor(_boolValue(null), _boolValue(true), _boolValue(null));
}
void test_eagerXor_unknownBool_knownBool() {
_assertEagerXor(_boolValue(null), _boolValue(null), _boolValue(true));
}
void test_equalEqual_bool_false() {
_assertEqualEqual(_boolValue(false), _boolValue(false), _boolValue(true));
}
void test_equalEqual_bool_true() {
_assertEqualEqual(_boolValue(true), _boolValue(true), _boolValue(true));
}
void test_equalEqual_bool_unknown() {
_assertEqualEqual(_boolValue(null), _boolValue(null), _boolValue(false));
}
void test_equalEqual_double_false() {
_assertEqualEqual(_boolValue(false), _doubleValue(2.0), _doubleValue(4.0));
}
void test_equalEqual_double_true() {
_assertEqualEqual(_boolValue(true), _doubleValue(2.0), _doubleValue(2.0));
}
void test_equalEqual_double_unknown() {
_assertEqualEqual(_boolValue(null), _doubleValue(1.0), _doubleValue(null));
}
void test_equalEqual_int_false() {
_assertEqualEqual(_boolValue(false), _intValue(-5), _intValue(5));
}
void test_equalEqual_int_true() {
_assertEqualEqual(_boolValue(true), _intValue(5), _intValue(5));
}
void test_equalEqual_int_unknown() {
_assertEqualEqual(_boolValue(null), _intValue(null), _intValue(3));
}
void test_equalEqual_list_empty() {
_assertEqualEqual(
null,
_listValue(_typeProvider.intType, []),
_listValue(_typeProvider.intType, []),
);
}
void test_equalEqual_list_false() {
_assertEqualEqual(
null,
_listValue(_typeProvider.intType, []),
_listValue(_typeProvider.intType, []),
);
}
void test_equalEqual_map_empty() {
_assertEqualEqual(
null,
_mapValue(_typeProvider.intType, _typeProvider.stringType, []),
_mapValue(_typeProvider.intType, _typeProvider.stringType, []),
);
}
void test_equalEqual_map_false() {
_assertEqualEqual(
null,
_mapValue(_typeProvider.intType, _typeProvider.stringType, []),
_mapValue(_typeProvider.intType, _typeProvider.stringType, []),
);
}
void test_equalEqual_null() {
_assertEqualEqual(_boolValue(true), _nullValue(), _nullValue());
}
void test_equalEqual_string_false() {
_assertEqualEqual(
_boolValue(false), _stringValue("abc"), _stringValue("def"));
}
void test_equalEqual_string_true() {
_assertEqualEqual(
_boolValue(true), _stringValue("abc"), _stringValue("abc"));
}
void test_equalEqual_string_unknown() {
_assertEqualEqual(
_boolValue(null), _stringValue(null), _stringValue("def"));
}
void test_equals_list_false_differentSizes() {
expect(
_listValue(_typeProvider.boolType, [_boolValue(true)]) ==
_listValue(
_typeProvider.boolType, [_boolValue(true), _boolValue(false)]),
isFalse);
}
void test_equals_list_false_sameSize() {
expect(
_listValue(_typeProvider.boolType, [_boolValue(true)]) ==
_listValue(_typeProvider.boolType, [_boolValue(false)]),
isFalse);
}
void test_equals_list_true_empty() {
expect(
_listValue(_typeProvider.intType, []),
_listValue(_typeProvider.intType, []),
);
}
void test_equals_list_true_nonEmpty() {
expect(
_listValue(_typeProvider.boolType, [_boolValue(true)]),
_listValue(_typeProvider.boolType, [_boolValue(true)]),
);
}
void test_equals_map_true_empty() {
expect(
_mapValue(_typeProvider.intType, _typeProvider.stringType, []),
_mapValue(_typeProvider.intType, _typeProvider.stringType, []),
);
}
void test_equals_symbol_false() {
expect(_symbolValue("a") == _symbolValue("b"), isFalse);
}
void test_equals_symbol_true() {
expect(_symbolValue("a"), _symbolValue("a"));
}
void test_getValue_bool_false() {
expect(_boolValue(false).toBoolValue(), false);
}
void test_getValue_bool_true() {
expect(_boolValue(true).toBoolValue(), true);
}
void test_getValue_bool_unknown() {
expect(_boolValue(null).toBoolValue(), isNull);
}
void test_getValue_double_known() {
double value = 2.3;
expect(_doubleValue(value).toDoubleValue(), value);
}
void test_getValue_double_unknown() {
expect(_doubleValue(null).toDoubleValue(), isNull);
}
void test_getValue_int_known() {
int value = 23;
expect(_intValue(value).toIntValue(), value);
}
void test_getValue_int_unknown() {
expect(_intValue(null).toIntValue(), isNull);
}
void test_getValue_list_empty() {
var result = _listValue(_typeProvider.intType, []).toListValue();
_assertInstanceOfObjectArray(result);
List<Object> array = result as List<Object>;
expect(array, hasLength(0));
}
void test_getValue_list_valid() {
var result =
_listValue(_typeProvider.intType, [_intValue(23)]).toListValue();
_assertInstanceOfObjectArray(result);
List<Object> array = result as List<Object>;
expect(array, hasLength(1));
}
void test_getValue_map_empty() {
var result = _mapValue(_typeProvider.intType, _typeProvider.stringType, [])
.toMapValue();
expect(result, hasLength(0));
}
void test_getValue_map_valid() {
var result = _mapValue(_typeProvider.stringType, _typeProvider.stringType,
[_stringValue("key"), _stringValue("value")]).toMapValue();
expect(result, hasLength(1));
}
void test_getValue_null() {
expect(_nullValue().isNull, isTrue);
}
void test_getValue_set_empty() {
DartObjectImpl object = _setValue(_typeProvider.intType, null);
var set = object.toSetValue();
expect(set, hasLength(0));
}
void test_getValue_set_valid() {
DartObjectImpl object = _setValue(_typeProvider.intType, {_intValue(23)});
var set = object.toSetValue();
expect(set, hasLength(1));
}
void test_getValue_string_known() {
String value = "twenty-three";
expect(_stringValue(value).toStringValue(), value);
}
void test_getValue_string_unknown() {
expect(_stringValue(null).toStringValue(), isNull);
}
void test_greaterThan_knownDouble_knownDouble_false() {
_assertGreaterThan(_boolValue(false), _doubleValue(1.0), _doubleValue(2.0));
}
void test_greaterThan_knownDouble_knownDouble_true() {
_assertGreaterThan(_boolValue(true), _doubleValue(2.0), _doubleValue(1.0));
}
void test_greaterThan_knownDouble_knownInt_false() {
_assertGreaterThan(_boolValue(false), _doubleValue(1.0), _intValue(2));
}
void test_greaterThan_knownDouble_knownInt_true() {
_assertGreaterThan(_boolValue(true), _doubleValue(2.0), _intValue(1));
}
void test_greaterThan_knownDouble_unknownDouble() {
_assertGreaterThan(_boolValue(null), _doubleValue(1.0), _doubleValue(null));
}
void test_greaterThan_knownDouble_unknownInt() {
_assertGreaterThan(_boolValue(null), _doubleValue(1.0), _intValue(null));
}
void test_greaterThan_knownInt_knownInt_false() {
_assertGreaterThan(_boolValue(false), _intValue(1), _intValue(2));
}
void test_greaterThan_knownInt_knownInt_true() {
_assertGreaterThan(_boolValue(true), _intValue(2), _intValue(1));
}
void test_greaterThan_knownInt_knownString() {
_assertGreaterThan(null, _intValue(1), _stringValue("2"));
}
void test_greaterThan_knownInt_unknownDouble() {
_assertGreaterThan(_boolValue(null), _intValue(1), _doubleValue(null));
}
void test_greaterThan_knownInt_unknownInt() {
_assertGreaterThan(_boolValue(null), _intValue(1), _intValue(null));
}
void test_greaterThan_knownString_knownInt() {
_assertGreaterThan(null, _stringValue("1"), _intValue(2));
}
void test_greaterThan_unknownDouble_knownDouble() {
_assertGreaterThan(_boolValue(null), _doubleValue(null), _doubleValue(2.0));
}
void test_greaterThan_unknownDouble_knownInt() {
_assertGreaterThan(_boolValue(null), _doubleValue(null), _intValue(2));
}
void test_greaterThan_unknownInt_knownDouble() {
_assertGreaterThan(_boolValue(null), _intValue(null), _doubleValue(2.0));
}
void test_greaterThan_unknownInt_knownInt() {
_assertGreaterThan(_boolValue(null), _intValue(null), _intValue(2));
}
void test_greaterThanOrEqual_knownDouble_knownDouble_false() {
_assertGreaterThanOrEqual(
_boolValue(false), _doubleValue(1.0), _doubleValue(2.0));
}
void test_greaterThanOrEqual_knownDouble_knownDouble_true() {
_assertGreaterThanOrEqual(
_boolValue(true), _doubleValue(2.0), _doubleValue(1.0));
}
void test_greaterThanOrEqual_knownDouble_knownInt_false() {
_assertGreaterThanOrEqual(
_boolValue(false), _doubleValue(1.0), _intValue(2));
}
void test_greaterThanOrEqual_knownDouble_knownInt_true() {
_assertGreaterThanOrEqual(
_boolValue(true), _doubleValue(2.0), _intValue(1));
}
void test_greaterThanOrEqual_knownDouble_unknownDouble() {
_assertGreaterThanOrEqual(
_boolValue(null), _doubleValue(1.0), _doubleValue(null));
}
void test_greaterThanOrEqual_knownDouble_unknownInt() {
_assertGreaterThanOrEqual(
_boolValue(null), _doubleValue(1.0), _intValue(null));
}
void test_greaterThanOrEqual_knownInt_knownInt_false() {
_assertGreaterThanOrEqual(_boolValue(false), _intValue(1), _intValue(2));
}
void test_greaterThanOrEqual_knownInt_knownInt_true() {
_assertGreaterThanOrEqual(_boolValue(true), _intValue(2), _intValue(2));
}
void test_greaterThanOrEqual_knownInt_knownString() {
_assertGreaterThanOrEqual(null, _intValue(1), _stringValue("2"));
}
void test_greaterThanOrEqual_knownInt_unknownDouble() {
_assertGreaterThanOrEqual(
_boolValue(null), _intValue(1), _doubleValue(null));
}
void test_greaterThanOrEqual_knownInt_unknownInt() {
_assertGreaterThanOrEqual(_boolValue(null), _intValue(1), _intValue(null));
}
void test_greaterThanOrEqual_knownString_knownInt() {
_assertGreaterThanOrEqual(null, _stringValue("1"), _intValue(2));
}
void test_greaterThanOrEqual_unknownDouble_knownDouble() {
_assertGreaterThanOrEqual(
_boolValue(null), _doubleValue(null), _doubleValue(2.0));
}
void test_greaterThanOrEqual_unknownDouble_knownInt() {
_assertGreaterThanOrEqual(
_boolValue(null), _doubleValue(null), _intValue(2));
}
void test_greaterThanOrEqual_unknownInt_knownDouble() {
_assertGreaterThanOrEqual(
_boolValue(null), _intValue(null), _doubleValue(2.0));
}
void test_greaterThanOrEqual_unknownInt_knownInt() {
_assertGreaterThanOrEqual(_boolValue(null), _intValue(null), _intValue(2));
}
void test_hasKnownValue_bool_false() {
expect(_boolValue(false).hasKnownValue, isTrue);
}
void test_hasKnownValue_bool_true() {
expect(_boolValue(true).hasKnownValue, isTrue);
}
void test_hasKnownValue_bool_unknown() {
expect(_boolValue(null).hasKnownValue, isFalse);
}
void test_hasKnownValue_double_known() {
expect(_doubleValue(2.3).hasKnownValue, isTrue);
}
void test_hasKnownValue_double_unknown() {
expect(_doubleValue(null).hasKnownValue, isFalse);
}
void test_hasKnownValue_int_known() {
expect(_intValue(23).hasKnownValue, isTrue);
}
void test_hasKnownValue_int_unknown() {
expect(_intValue(null).hasKnownValue, isFalse);
}
void test_hasKnownValue_list_empty() {
expect(_listValue(_typeProvider.intType, []).hasKnownValue, isTrue);
}
void test_hasKnownValue_list_valid() {
expect(_listValue(_typeProvider.intType, [_intValue(23)]).hasKnownValue,
isTrue);
}
void test_hasKnownValue_map_empty() {
expect(
_mapValue(_typeProvider.intType, _typeProvider.stringType, [])
.hasKnownValue,
isTrue);
}
void test_hasKnownValue_map_valid() {
expect(
_mapValue(_typeProvider.stringType, _typeProvider.stringType,
[_stringValue("key"), _stringValue("value")]).hasKnownValue,
isTrue);
}
void test_hasKnownValue_null() {
expect(_nullValue().hasKnownValue, isTrue);
}
void test_hasKnownValue_string_known() {
expect(_stringValue("twenty-three").hasKnownValue, isTrue);
}
void test_hasKnownValue_string_unknown() {
expect(_stringValue(null).hasKnownValue, isFalse);
}
void test_identical_bool_false() {
_assertIdentical(_boolValue(false), _boolValue(false), _boolValue(true));
}
void test_identical_bool_true() {
_assertIdentical(_boolValue(true), _boolValue(true), _boolValue(true));
}
void test_identical_bool_unknown() {
_assertIdentical(_boolValue(null), _boolValue(null), _boolValue(false));
}
void test_identical_double_false() {
_assertIdentical(_boolValue(false), _doubleValue(2.0), _doubleValue(4.0));
}
void test_identical_double_true() {
_assertIdentical(_boolValue(true), _doubleValue(2.0), _doubleValue(2.0));
}
void test_identical_double_unknown() {
_assertIdentical(_boolValue(null), _doubleValue(1.0), _doubleValue(null));
}
void test_identical_int_false() {
_assertIdentical(_boolValue(false), _intValue(-5), _intValue(5));
}
void test_identical_int_true() {
_assertIdentical(_boolValue(true), _intValue(5), _intValue(5));
}
void test_identical_int_unknown() {
_assertIdentical(_boolValue(null), _intValue(null), _intValue(3));
}
void test_identical_intZero_doubleZero() {
// Used in Flutter:
// const bool kIsWeb = identical(0, 0.0);
_assertIdentical(_boolValue(true), _intValue(0), _doubleValue(0.0));
}
void test_identical_list_empty() {
_assertIdentical(
_boolValue(true),
_listValue(_typeProvider.intType, []),
_listValue(_typeProvider.intType, []),
);
}
void test_identical_list_false_differentTypes() {
_assertIdentical(
_boolValue(false),
_listValue(_typeProvider.intType, []),
_listValue(_typeProvider.doubleType, []),
);
}
void test_identical_list_false_differentValues() {
_assertIdentical(_boolValue(false), _listValue(_typeProvider.intType, []),
_listValue(_typeProvider.intType, [_intValue(3)]));
}
void test_identical_list_true_equalTypes() {
_assertIdentical(
_boolValue(true),
_listValue(_typeProvider.intType, []),
_listValue(_typeProvider.intType, []),
);
}
void test_identical_list_true_equalTypesRuntime() {
_assertIdentical(
_boolValue(true),
_listValue(
_typeProvider.objectType,
[],
),
_listValue(
_typeProvider.futureOrElement.instantiate(
typeArguments: [_typeProvider.objectType],
nullabilitySuffix: NullabilitySuffix.none,
),
[],
),
);
}
void test_identical_map_empty() {
_assertIdentical(
_boolValue(true),
_mapValue(_typeProvider.intType, _typeProvider.stringType, []),
_mapValue(_typeProvider.intType, _typeProvider.stringType, []),
);
}
void test_identical_map_false_differentEntries() {
_assertIdentical(
_boolValue(false),
_mapValue(_typeProvider.intType, _typeProvider.intType, []),
_mapValue(
_typeProvider.intType,
_typeProvider.intType,
[_intValue(1), _intValue(2)],
),
);
}
void test_identical_map_false_differentTypes() {
_assertIdentical(
_boolValue(false),
_mapValue(_typeProvider.boolType, _typeProvider.intType, []),
_mapValue(_typeProvider.intType, _typeProvider.intType, []),
);
_assertIdentical(
_boolValue(false),
_mapValue(_typeProvider.intType, _typeProvider.boolType, []),
_mapValue(_typeProvider.intType, _typeProvider.intType, []),
);
}
void test_identical_map_true_equalTypesRuntime() {
_assertIdentical(
_boolValue(true),
_mapValue(
_typeProvider.intType,
_typeProvider.objectType,
[],
),
_mapValue(
_typeProvider.intType,
_typeProvider.futureOrElement.instantiate(
typeArguments: [_typeProvider.objectType],
nullabilitySuffix: NullabilitySuffix.none,
),
[],
),
);
}
void test_identical_null() {
_assertIdentical(_boolValue(true), _nullValue(), _nullValue());
}
void test_identical_string_false() {
_assertIdentical(
_boolValue(false), _stringValue("abc"), _stringValue("def"));
}
void test_identical_string_true() {
_assertIdentical(
_boolValue(true), _stringValue("abc"), _stringValue("abc"));
}
void test_identical_string_unknown() {
_assertIdentical(_boolValue(null), _stringValue(null), _stringValue("def"));
}
void test_identical_Type_interfaceType() {
_assertIdentical(
_boolValue(true),
_typeValue(_typeProvider.intType),
_typeValue(_typeProvider.intType),
);
_assertIdentical(
_boolValue(false),
_typeValue(_typeProvider.intType),
_typeValue(_typeProvider.numType),
);
_assertIdentical(
_boolValue(true),
_typeValue(_typeProvider.futureOrType(_typeProvider.objectType)),
_typeValue(_typeProvider.objectType),
);
}
void test_identical_Type_notType() {
_assertIdentical(
_boolValue(false),
_typeValue(_typeProvider.intType),
_intValue(0),
);
}
void test_integerDivide_infinity_knownDouble() {
_assertIntegerDivide(
null,
_doubleValue(double.infinity),
_doubleValue(2.0),
);
}
void test_integerDivide_infinity_knownInt() {
_assertIntegerDivide(null, _doubleValue(double.infinity), _intValue(2));
}
void test_integerDivide_knownDouble_knownDouble() {
_assertIntegerDivide(_intValue(3), _doubleValue(6.0), _doubleValue(2.0));
}
void test_integerDivide_knownDouble_knownInt() {
_assertIntegerDivide(_intValue(3), _doubleValue(6.0), _intValue(2));
}
void test_integerDivide_knownDouble_unknownDouble() {
_assertIntegerDivide(
_intValue(null), _doubleValue(6.0), _doubleValue(null));
}
void test_integerDivide_knownDouble_unknownInt() {
_assertIntegerDivide(_intValue(null), _doubleValue(6.0), _intValue(null));
}
void test_integerDivide_knownInt_knownDoubleZero() {
_assertIntegerDivide(null, _intValue(6), _doubleValue(0.0));
}
void test_integerDivide_knownInt_knownInt() {
_assertIntegerDivide(_intValue(3), _intValue(6), _intValue(2));
}
void test_integerDivide_knownInt_knownString() {
_assertIntegerDivide(null, _intValue(6), _stringValue("2"));
}
void test_integerDivide_knownInt_unknownDouble() {
_assertIntegerDivide(_intValue(null), _intValue(6), _doubleValue(null));
}
void test_integerDivide_knownInt_unknownInt() {
_assertIntegerDivide(_intValue(null), _intValue(6), _intValue(null));
}
void test_integerDivide_knownInt_zero() {
_assertIntegerDivide(null, _intValue(2), _intValue(0));
}
void test_integerDivide_knownString_knownInt() {
_assertIntegerDivide(null, _stringValue("6"), _intValue(2));
}
void test_integerDivide_NaN_knownDouble() {
_assertIntegerDivide(null, _doubleValue(double.nan), _doubleValue(2.0));
}
void test_integerDivide_NaN_knownInt() {
_assertIntegerDivide(null, _doubleValue(double.nan), _intValue(2));
}
void test_integerDivide_negativeInfinity_knownDouble() {
_assertIntegerDivide(
null,
_doubleValue(double.negativeInfinity),
_doubleValue(2.0),
);
}
void test_integerDivide_negativeInfinity_knownInt() {
_assertIntegerDivide(
null,
_doubleValue(double.negativeInfinity),
_intValue(2),
);
}
void test_integerDivide_unknownDouble_knownDouble() {
_assertIntegerDivide(
_intValue(null), _doubleValue(null), _doubleValue(2.0));
}
void test_integerDivide_unknownDouble_knownInt() {
_assertIntegerDivide(_intValue(null), _doubleValue(null), _intValue(2));
}
void test_integerDivide_unknownInt_knownDouble() {
_assertIntegerDivide(_intValue(null), _intValue(null), _doubleValue(2.0));
}
void test_integerDivide_unknownInt_knownInt() {
_assertIntegerDivide(_intValue(null), _intValue(null), _intValue(2));
}
void test_isBoolNumStringOrNull_bool_false() {
expect(_boolValue(false).isBoolNumStringOrNull, isTrue);
}
void test_isBoolNumStringOrNull_bool_true() {
expect(_boolValue(true).isBoolNumStringOrNull, isTrue);
}
void test_isBoolNumStringOrNull_bool_unknown() {
expect(_boolValue(null).isBoolNumStringOrNull, isTrue);
}
void test_isBoolNumStringOrNull_double_known() {
expect(_doubleValue(2.3).isBoolNumStringOrNull, isTrue);
}
void test_isBoolNumStringOrNull_double_unknown() {
expect(_doubleValue(null).isBoolNumStringOrNull, isTrue);
}
void test_isBoolNumStringOrNull_int_known() {
expect(_intValue(23).isBoolNumStringOrNull, isTrue);
}
void test_isBoolNumStringOrNull_int_unknown() {
expect(_intValue(null).isBoolNumStringOrNull, isTrue);
}
void test_isBoolNumStringOrNull_list() {
expect(
_listValue(_typeProvider.intType, []).isBoolNumStringOrNull, isFalse);
}
void test_isBoolNumStringOrNull_null() {
expect(_nullValue().isBoolNumStringOrNull, isTrue);
}
void test_isBoolNumStringOrNull_string_known() {
expect(_stringValue("twenty-three").isBoolNumStringOrNull, isTrue);
}
void test_isBoolNumStringOrNull_string_unknown() {
expect(_stringValue(null).isBoolNumStringOrNull, isTrue);
}
void test_lessThan_knownDouble_knownDouble_false() {
_assertLessThan(_boolValue(false), _doubleValue(2.0), _doubleValue(1.0));
}
void test_lessThan_knownDouble_knownDouble_true() {
_assertLessThan(_boolValue(true), _doubleValue(1.0), _doubleValue(2.0));
}
void test_lessThan_knownDouble_knownInt_false() {
_assertLessThan(_boolValue(false), _doubleValue(2.0), _intValue(1));
}
void test_lessThan_knownDouble_knownInt_true() {
_assertLessThan(_boolValue(true), _doubleValue(1.0), _intValue(2));
}
void test_lessThan_knownDouble_unknownDouble() {
_assertLessThan(_boolValue(null), _doubleValue(1.0), _doubleValue(null));
}
void test_lessThan_knownDouble_unknownInt() {
_assertLessThan(_boolValue(null), _doubleValue(1.0), _intValue(null));
}
void test_lessThan_knownInt_knownInt_false() {
_assertLessThan(_boolValue(false), _intValue(2), _intValue(1));
}
void test_lessThan_knownInt_knownInt_true() {
_assertLessThan(_boolValue(true), _intValue(1), _intValue(2));
}
void test_lessThan_knownInt_knownString() {
_assertLessThan(null, _intValue(1), _stringValue("2"));
}
void test_lessThan_knownInt_unknownDouble() {
_assertLessThan(_boolValue(null), _intValue(1), _doubleValue(null));
}
void test_lessThan_knownInt_unknownInt() {
_assertLessThan(_boolValue(null), _intValue(1), _intValue(null));
}
void test_lessThan_knownString_knownInt() {
_assertLessThan(null, _stringValue("1"), _intValue(2));
}
void test_lessThan_unknownDouble_knownDouble() {
_assertLessThan(_boolValue(null), _doubleValue(null), _doubleValue(2.0));
}
void test_lessThan_unknownDouble_knownInt() {
_assertLessThan(_boolValue(null), _doubleValue(null), _intValue(2));
}
void test_lessThan_unknownInt_knownDouble() {
_assertLessThan(_boolValue(null), _intValue(null), _doubleValue(2.0));
}
void test_lessThan_unknownInt_knownInt() {
_assertLessThan(_boolValue(null), _intValue(null), _intValue(2));
}
void test_lessThanOrEqual_knownDouble_knownDouble_false() {
_assertLessThanOrEqual(
_boolValue(false), _doubleValue(2.0), _doubleValue(1.0));
}
void test_lessThanOrEqual_knownDouble_knownDouble_true() {
_assertLessThanOrEqual(
_boolValue(true), _doubleValue(1.0), _doubleValue(2.0));
}
void test_lessThanOrEqual_knownDouble_knownInt_false() {
_assertLessThanOrEqual(_boolValue(false), _doubleValue(2.0), _intValue(1));
}
void test_lessThanOrEqual_knownDouble_knownInt_true() {
_assertLessThanOrEqual(_boolValue(true), _doubleValue(1.0), _intValue(2));
}
void test_lessThanOrEqual_knownDouble_unknownDouble() {
_assertLessThanOrEqual(
_boolValue(null), _doubleValue(1.0), _doubleValue(null));
}
void test_lessThanOrEqual_knownDouble_unknownInt() {
_assertLessThanOrEqual(
_boolValue(null), _doubleValue(1.0), _intValue(null));
}
void test_lessThanOrEqual_knownInt_knownInt_false() {
_assertLessThanOrEqual(_boolValue(false), _intValue(2), _intValue(1));
}
void test_lessThanOrEqual_knownInt_knownInt_true() {
_assertLessThanOrEqual(_boolValue(true), _intValue(1), _intValue(2));
}
void test_lessThanOrEqual_knownInt_knownString() {
_assertLessThanOrEqual(null, _intValue(1), _stringValue("2"));
}
void test_lessThanOrEqual_knownInt_unknownDouble() {
_assertLessThanOrEqual(_boolValue(null), _intValue(1), _doubleValue(null));
}
void test_lessThanOrEqual_knownInt_unknownInt() {
_assertLessThanOrEqual(_boolValue(null), _intValue(1), _intValue(null));
}
void test_lessThanOrEqual_knownString_knownInt() {
_assertLessThanOrEqual(null, _stringValue("1"), _intValue(2));
}
void test_lessThanOrEqual_unknownDouble_knownDouble() {
_assertLessThanOrEqual(
_boolValue(null), _doubleValue(null), _doubleValue(2.0));
}
void test_lessThanOrEqual_unknownDouble_knownInt() {
_assertLessThanOrEqual(_boolValue(null), _doubleValue(null), _intValue(2));
}
void test_lessThanOrEqual_unknownInt_knownDouble() {
_assertLessThanOrEqual(
_boolValue(null), _intValue(null), _doubleValue(2.0));
}
void test_lessThanOrEqual_unknownInt_knownInt() {
_assertLessThanOrEqual(_boolValue(null), _intValue(null), _intValue(2));
}
void test_logicalAnd_false_false() {
_assertLazyAnd(_boolValue(false), _boolValue(false), _boolValue(false));
}
void test_logicalAnd_false_null() {
_assertLazyAnd(_boolValue(false), _boolValue(false), _nullValue());
}
void test_logicalAnd_false_string() {
_assertLazyAnd(_boolValue(false), _boolValue(false), _stringValue("false"));
}
void test_logicalAnd_false_true() {
_assertLazyAnd(_boolValue(false), _boolValue(false), _boolValue(true));
}
void test_logicalAnd_null_false() {
expect(() {
_assertLazyAnd(_boolValue(false), _nullValue(), _boolValue(false));
}, throwsEvaluationException);
}
void test_logicalAnd_null_true() {
expect(() {
_assertLazyAnd(_boolValue(false), _nullValue(), _boolValue(true));
}, throwsEvaluationException);
}
void test_logicalAnd_string_false() {
expect(() {
_assertLazyAnd(
_boolValue(false), _stringValue("true"), _boolValue(false));
}, throwsEvaluationException);
}
void test_logicalAnd_string_true() {
expect(() {
_assertLazyAnd(
_boolValue(false), _stringValue("false"), _boolValue(true));
}, throwsEvaluationException);
}
void test_logicalAnd_true_false() {
_assertLazyAnd(_boolValue(false), _boolValue(true), _boolValue(false));
}
void test_logicalAnd_true_null() {
_assertLazyAnd(null, _boolValue(true), _nullValue());
}
void test_logicalAnd_true_string() {
expect(() {
_assertLazyAnd(_boolValue(false), _boolValue(true), _stringValue("true"));
}, throwsEvaluationException);
}
void test_logicalAnd_true_true() {
_assertLazyAnd(_boolValue(true), _boolValue(true), _boolValue(true));
}
void test_logicalNot_false() {
_assertLogicalNot(_boolValue(true), _boolValue(false));
}
void test_logicalNot_null() {
_assertLogicalNot(null, _nullValue());
}
void test_logicalNot_string() {
expect(() {
_assertLogicalNot(_boolValue(true), _stringValue(null));
}, throwsEvaluationException);
}
void test_logicalNot_true() {
_assertLogicalNot(_boolValue(false), _boolValue(true));
}
void test_logicalNot_unknown() {
_assertLogicalNot(_boolValue(null), _boolValue(null));
}
void test_logicalOr_false_false() {
_assertLazyOr(_boolValue(false), _boolValue(false), _boolValue(false));
}
void test_logicalOr_false_null() {
_assertLazyOr(null, _boolValue(false), _nullValue());
}
void test_logicalOr_false_string() {
expect(() {
_assertLazyOr(
_boolValue(false), _boolValue(false), _stringValue("false"));
}, throwsEvaluationException);
}
void test_logicalOr_false_true() {
_assertLazyOr(_boolValue(true), _boolValue(false), _boolValue(true));
}
void test_logicalOr_null_false() {
expect(() {
_assertLazyOr(_boolValue(false), _nullValue(), _boolValue(false));
}, throwsEvaluationException);
}
void test_logicalOr_null_true() {
expect(() {
_assertLazyOr(_boolValue(true), _nullValue(), _boolValue(true));
}, throwsEvaluationException);
}
void test_logicalOr_string_false() {
expect(() {
_assertLazyOr(_boolValue(false), _stringValue("true"), _boolValue(false));
}, throwsEvaluationException);
}
void test_logicalOr_string_true() {
expect(() {
_assertLazyOr(_boolValue(true), _stringValue("false"), _boolValue(true));
}, throwsEvaluationException);
}
void test_logicalOr_true_false() {
_assertLazyOr(_boolValue(true), _boolValue(true), _boolValue(false));
}
void test_logicalOr_true_null() {
_assertLazyOr(_boolValue(true), _boolValue(true), _nullValue());
}
void test_logicalOr_true_string() {
_assertLazyOr(_boolValue(true), _boolValue(true), _stringValue("true"));
}
void test_logicalOr_true_true() {
_assertLazyOr(_boolValue(true), _boolValue(true), _boolValue(true));
}
void test_minus_knownDouble_knownDouble() {
_assertMinus(_doubleValue(1.0), _doubleValue(4.0), _doubleValue(3.0));
}
void test_minus_knownDouble_knownInt() {
_assertMinus(_doubleValue(1.0), _doubleValue(4.0), _intValue(3));
}
void test_minus_knownDouble_unknownDouble() {
_assertMinus(_doubleValue(null), _doubleValue(4.0), _doubleValue(null));
}
void test_minus_knownDouble_unknownInt() {
_assertMinus(_doubleValue(null), _doubleValue(4.0), _intValue(null));
}
void test_minus_knownInt_knownInt() {
_assertMinus(_intValue(1), _intValue(4), _intValue(3));
}
void test_minus_knownInt_knownString() {
_assertMinus(null, _intValue(4), _stringValue("3"));
}
void test_minus_knownInt_unknownDouble() {
_assertMinus(_doubleValue(null), _intValue(4), _doubleValue(null));
}
void test_minus_knownInt_unknownInt() {
_assertMinus(_intValue(null), _intValue(4), _intValue(null));
}
void test_minus_knownString_knownInt() {
_assertMinus(null, _stringValue("4"), _intValue(3));
}
void test_minus_unknownDouble_knownDouble() {
_assertMinus(_doubleValue(null), _doubleValue(null), _doubleValue(3.0));
}
void test_minus_unknownDouble_knownInt() {
_assertMinus(_doubleValue(null), _doubleValue(null), _intValue(3));
}
void test_minus_unknownInt_knownDouble() {
_assertMinus(_doubleValue(null), _intValue(null), _doubleValue(3.0));
}
void test_minus_unknownInt_knownInt() {
_assertMinus(_intValue(null), _intValue(null), _intValue(3));
}
void test_negated_double_known() {
_assertNegated(_doubleValue(2.0), _doubleValue(-2.0));
}
void test_negated_double_unknown() {
_assertNegated(_doubleValue(null), _doubleValue(null));
}
void test_negated_int_known() {
_assertNegated(_intValue(-3), _intValue(3));
}
void test_negated_int_unknown() {
_assertNegated(_intValue(null), _intValue(null));
}
void test_negated_string() {
_assertNegated(null, _stringValue(null));
}
void test_notEqual_bool_false() {
_assertNotEqual(_boolValue(false), _boolValue(true), _boolValue(true));
}
void test_notEqual_bool_true() {
_assertNotEqual(_boolValue(true), _boolValue(false), _boolValue(true));
}
void test_notEqual_bool_unknown() {
_assertNotEqual(_boolValue(null), _boolValue(null), _boolValue(false));
}
void test_notEqual_double_false() {
_assertNotEqual(_boolValue(false), _doubleValue(2.0), _doubleValue(2.0));
}
void test_notEqual_double_true() {
_assertNotEqual(_boolValue(true), _doubleValue(2.0), _doubleValue(4.0));
}
void test_notEqual_double_unknown() {
_assertNotEqual(_boolValue(null), _doubleValue(1.0), _doubleValue(null));
}
void test_notEqual_int_false() {
_assertNotEqual(_boolValue(false), _intValue(5), _intValue(5));
}
void test_notEqual_int_true() {
_assertNotEqual(_boolValue(true), _intValue(-5), _intValue(5));
}
void test_notEqual_int_unknown() {
_assertNotEqual(_boolValue(null), _intValue(null), _intValue(3));
}
void test_notEqual_null() {
_assertNotEqual(_boolValue(false), _nullValue(), _nullValue());
}
void test_notEqual_string_false() {
_assertNotEqual(
_boolValue(false), _stringValue("abc"), _stringValue("abc"));
}
void test_notEqual_string_true() {
_assertNotEqual(_boolValue(true), _stringValue("abc"), _stringValue("def"));
}
void test_notEqual_string_unknown() {
_assertNotEqual(_boolValue(null), _stringValue(null), _stringValue("def"));
}
void test_performToString_bool_false() {
_assertPerformToString(_stringValue("false"), _boolValue(false));
}
void test_performToString_bool_true() {
_assertPerformToString(_stringValue("true"), _boolValue(true));
}
void test_performToString_bool_unknown() {
_assertPerformToString(_stringValue(null), _boolValue(null));
}
void test_performToString_double_known() {
_assertPerformToString(_stringValue("2.0"), _doubleValue(2.0));
}
void test_performToString_double_unknown() {
_assertPerformToString(_stringValue(null), _doubleValue(null));
}
void test_performToString_int_known() {
_assertPerformToString(_stringValue("5"), _intValue(5));
}
void test_performToString_int_unknown() {
_assertPerformToString(_stringValue(null), _intValue(null));
}
void test_performToString_null() {
_assertPerformToString(_stringValue("null"), _nullValue());
}
void test_performToString_string_known() {
_assertPerformToString(_stringValue("abc"), _stringValue("abc"));
}
void test_performToString_string_unknown() {
_assertPerformToString(_stringValue(null), _stringValue(null));
}
void test_remainder_knownDouble_knownDouble() {
_assertRemainder(_doubleValue(1.0), _doubleValue(7.0), _doubleValue(2.0));
}
void test_remainder_knownDouble_knownInt() {
_assertRemainder(_doubleValue(1.0), _doubleValue(7.0), _intValue(2));
}
void test_remainder_knownDouble_unknownDouble() {
_assertRemainder(_doubleValue(null), _doubleValue(7.0), _doubleValue(null));
}
void test_remainder_knownDouble_unknownInt() {
_assertRemainder(_doubleValue(null), _doubleValue(6.0), _intValue(null));
}
void test_remainder_knownInt_knownInt() {
_assertRemainder(_intValue(1), _intValue(7), _intValue(2));
}
void test_remainder_knownInt_knownInt_zero() {
_assertRemainder(null, _intValue(7), _intValue(0));
}
void test_remainder_knownInt_knownString() {
_assertRemainder(null, _intValue(7), _stringValue("2"));
}
void test_remainder_knownInt_unknownDouble() {
_assertRemainder(_doubleValue(null), _intValue(7), _doubleValue(null));
}
void test_remainder_knownInt_unknownInt() {
_assertRemainder(_intValue(null), _intValue(7), _intValue(null));
}
void test_remainder_knownString_knownInt() {
_assertRemainder(null, _stringValue("7"), _intValue(2));
}
void test_remainder_unknownDouble_knownDouble() {
_assertRemainder(_doubleValue(null), _doubleValue(null), _doubleValue(2.0));
}
void test_remainder_unknownDouble_knownInt() {
_assertRemainder(_doubleValue(null), _doubleValue(null), _intValue(2));
}
void test_remainder_unknownInt_knownDouble() {
_assertRemainder(_doubleValue(null), _intValue(null), _doubleValue(2.0));
}
void test_remainder_unknownInt_knownInt() {
_assertRemainder(_intValue(null), _intValue(null), _intValue(2));
}
void test_shiftLeft_knownInt_knownInt() {
_assertShiftLeft(_intValue(48), _intValue(6), _intValue(3));
}
void test_shiftLeft_knownInt_knownInt_negative() {
_assertShiftLeft(null, _intValue(1), _intValue(-1));
}
void test_shiftLeft_knownInt_knownString() {
_assertShiftLeft(null, _intValue(6), _stringValue(null));
}
void test_shiftLeft_knownInt_tooLarge() {
_assertShiftLeft(
_intValue(null),
_intValue(6),
DartObjectImpl(
_typeSystem,
_typeProvider.intType,
IntState(LONG_MAX_VALUE),
),
);
}
void test_shiftLeft_knownInt_unknownInt() {
_assertShiftLeft(_intValue(null), _intValue(6), _intValue(null));
}
void test_shiftLeft_knownString_knownInt() {
_assertShiftLeft(null, _stringValue(null), _intValue(3));
}
void test_shiftLeft_unknownInt_knownInt() {
_assertShiftLeft(_intValue(null), _intValue(null), _intValue(3));
}
void test_shiftLeft_unknownInt_unknownInt() {
_assertShiftLeft(_intValue(null), _intValue(null), _intValue(null));
}
void test_shiftRight_knownInt_knownInt() {
_assertShiftRight(_intValue(6), _intValue(48), _intValue(3));
}
void test_shiftRight_knownInt_knownInt_negative() {
_assertShiftRight(null, _intValue(1), _intValue(-1));
}
void test_shiftRight_knownInt_knownString() {
_assertShiftRight(null, _intValue(48), _stringValue(null));
}
void test_shiftRight_knownInt_tooLarge() {
_assertShiftRight(
_intValue(null),
_intValue(48),
DartObjectImpl(
_typeSystem,
_typeProvider.intType,
IntState(LONG_MAX_VALUE),
),
);
}
void test_shiftRight_knownInt_unknownInt() {
_assertShiftRight(_intValue(null), _intValue(48), _intValue(null));
}
void test_shiftRight_knownString_knownInt() {
_assertShiftRight(null, _stringValue(null), _intValue(3));
}
void test_shiftRight_unknownInt_knownInt() {
_assertShiftRight(_intValue(null), _intValue(null), _intValue(3));
}
void test_shiftRight_unknownInt_unknownInt() {
_assertShiftRight(_intValue(null), _intValue(null), _intValue(null));
}
void test_stringLength_int() {
expect(() {
_assertStringLength(_intValue(null), _intValue(0));
}, throwsEvaluationException);
}
void test_stringLength_knownString() {
_assertStringLength(_intValue(3), _stringValue("abc"));
}
void test_stringLength_unknownString() {
_assertStringLength(_intValue(null), _stringValue(null));
}
void test_times_knownDouble_knownDouble() {
_assertTimes(_doubleValue(6.0), _doubleValue(2.0), _doubleValue(3.0));
}
void test_times_knownDouble_knownInt() {
_assertTimes(_doubleValue(6.0), _doubleValue(2.0), _intValue(3));
}
void test_times_knownDouble_unknownDouble() {
_assertTimes(_doubleValue(null), _doubleValue(2.0), _doubleValue(null));
}
void test_times_knownDouble_unknownInt() {
_assertTimes(_doubleValue(null), _doubleValue(2.0), _intValue(null));
}
void test_times_knownInt_knownInt() {
_assertTimes(_intValue(6), _intValue(2), _intValue(3));
}
void test_times_knownInt_knownString() {
_assertTimes(null, _intValue(2), _stringValue("3"));
}
void test_times_knownInt_unknownDouble() {
_assertTimes(_doubleValue(null), _intValue(2), _doubleValue(null));
}
void test_times_knownInt_unknownInt() {
_assertTimes(_intValue(null), _intValue(2), _intValue(null));
}
void test_times_knownString_knownInt() {
_assertTimes(null, _stringValue("2"), _intValue(3));
}
void test_times_unknownDouble_knownDouble() {
_assertTimes(_doubleValue(null), _doubleValue(null), _doubleValue(3.0));
}
void test_times_unknownDouble_knownInt() {
_assertTimes(_doubleValue(null), _doubleValue(null), _intValue(3));
}
void test_times_unknownInt_knownDouble() {
_assertTimes(_doubleValue(null), _intValue(null), _doubleValue(3.0));
}
void test_times_unknownInt_knownInt() {
_assertTimes(_intValue(null), _intValue(null), _intValue(3));
}
/// Assert that the result of adding the [left] and [right] operands is the
/// [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertAdd(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.add(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.add(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the bit-not of the [operand] is the [expected] value, or that
/// the operation throws an exception if the expected value is `null`.
void _assertBitNot(DartObjectImpl? expected, DartObjectImpl operand) {
if (expected == null) {
expect(() {
operand.bitNot(_typeSystem);
}, throwsEvaluationException);
} else {
DartObjectImpl result = operand.bitNot(_typeSystem);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of concatenating the [left] and [right] operands is
/// the [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertConcatenate(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.concatenate(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.concatenate(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of dividing the [left] and [right] operands is the
/// [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertDivide(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.divide(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.divide(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of bit-anding the [left] and [right] operands is
/// the [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertEagerAnd(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.eagerAnd(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.eagerAnd(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of bit-oring the [left] and [right] operands is the
/// [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertEagerOr(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.eagerOr(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.eagerOr(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of bit-xoring the [left] and [right] operands is
/// the [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertEagerXor(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.eagerXor(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.eagerXor(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of comparing the [left] and [right] operands for
/// equality is the [expected] value, or that the operation throws an
/// exception if the expected value is `null`.
void _assertEqualEqual(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.equalEqual(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.equalEqual(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of comparing the [left] and [right] operands is the
/// [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertGreaterThan(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.greaterThan(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.greaterThan(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of comparing the [left] and [right] operands is the
/// [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertGreaterThanOrEqual(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.greaterThanOrEqual(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.greaterThanOrEqual(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of comparing the [left] and [right] operands using
/// identical() is the expected value.
void _assertIdentical(
DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
DartObjectImpl result = left.isIdentical2(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
void _assertInstanceOfObjectArray(Object? result) {
// TODO(scheglov) implement
}
/// Assert that the result of dividing the [left] and [right] operands as
/// integers is the [expected] value, or that the operation throws an
/// exception if the expected value is `null`.
void _assertIntegerDivide(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.integerDivide(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.integerDivide(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of logical-anding the [left] and [right] operands
/// is the [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertLazyAnd(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.lazyAnd(_typeSystem, () => right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.lazyAnd(_typeSystem, () => right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of logical-oring the [left] and [right] operands is
/// the [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertLazyOr(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.lazyOr(_typeSystem, () => right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.lazyOr(_typeSystem, () => right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of comparing the [left] and [right] operands is the
/// [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertLessThan(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.lessThan(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.lessThan(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of comparing the [left] and [right] operands is the
/// [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertLessThanOrEqual(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.lessThanOrEqual(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.lessThanOrEqual(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the logical-not of the [operand] is the [expected] value, or
/// that the operation throws an exception if the expected value is `null`.
void _assertLogicalNot(DartObjectImpl? expected, DartObjectImpl operand) {
if (expected == null) {
expect(() {
operand.logicalNot(_typeSystem);
}, throwsEvaluationException);
} else {
DartObjectImpl result = operand.logicalNot(_typeSystem);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of subtracting the [left] and [right] operands is
/// the [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertMinus(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.minus(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.minus(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the negation of the [operand] is the [expected] value, or that
/// the operation throws an exception if the expected value is `null`.
void _assertNegated(DartObjectImpl? expected, DartObjectImpl operand) {
if (expected == null) {
expect(() {
operand.negated(_typeSystem);
}, throwsEvaluationException);
} else {
DartObjectImpl result = operand.negated(_typeSystem);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of comparing the [left] and [right] operands for
/// inequality is the [expected] value, or that the operation throws an
/// exception if the expected value is `null`.
void _assertNotEqual(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.notEqual(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.notEqual(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that converting the [operand] to a string is the [expected] value,
/// or that the operation throws an exception if the expected value is `null`.
void _assertPerformToString(
DartObjectImpl? expected, DartObjectImpl operand) {
if (expected == null) {
expect(() {
operand.performToString(_typeSystem);
}, throwsEvaluationException);
} else {
DartObjectImpl result = operand.performToString(_typeSystem);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of taking the remainder of the [left] and [right]
/// operands is the [expected] value, or that the operation throws an
/// exception if the expected value is `null`.
void _assertRemainder(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.remainder(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.remainder(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of multiplying the [left] and [right] operands is
/// the [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertShiftLeft(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.shiftLeft(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.shiftLeft(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of multiplying the [left] and [right] operands is
/// the [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertShiftRight(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.shiftRight(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.shiftRight(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the length of the [operand] is the [expected] value, or that
/// the operation throws an exception if the expected value is `null`.
void _assertStringLength(DartObjectImpl? expected, DartObjectImpl operand) {
if (expected == null) {
expect(() {
operand.stringLength(_typeSystem);
}, throwsEvaluationException);
} else {
DartObjectImpl result = operand.stringLength(_typeSystem);
expect(result, isNotNull);
expect(result, expected);
}
}
/// Assert that the result of multiplying the [left] and [right] operands is
/// the [expected] value, or that the operation throws an exception if the
/// expected value is `null`.
void _assertTimes(
DartObjectImpl? expected, DartObjectImpl left, DartObjectImpl right) {
if (expected == null) {
expect(() {
left.times(_typeSystem, right);
}, throwsEvaluationException);
} else {
DartObjectImpl result = left.times(_typeSystem, right);
expect(result, isNotNull);
expect(result, expected);
}
}
DartObjectImpl _boolValue(bool? value) {
if (value == null) {
return DartObjectImpl(
_typeSystem,
_typeProvider.boolType,
BoolState.UNKNOWN_VALUE,
);
} else if (identical(value, false)) {
return DartObjectImpl(
_typeSystem,
_typeProvider.boolType,
BoolState.FALSE_STATE,
);
} else if (identical(value, true)) {
return DartObjectImpl(
_typeSystem,
_typeProvider.boolType,
BoolState.TRUE_STATE,
);
}
fail("Invalid boolean value used in test");
}
DartObjectImpl _doubleValue(double? value) {
if (value == null) {
return DartObjectImpl(
_typeSystem,
_typeProvider.doubleType,
DoubleState.UNKNOWN_VALUE,
);
} else {
return DartObjectImpl(
_typeSystem,
_typeProvider.doubleType,
DoubleState(value),
);
}
}
DartObjectImpl _intValue(int? value) {
if (value == null) {
return DartObjectImpl(
_typeSystem,
_typeProvider.intType,
IntState.UNKNOWN_VALUE,
);
} else {
return DartObjectImpl(
_typeSystem,
_typeProvider.intType,
IntState(value),
);
}
}
DartObjectImpl _listValue(
DartType elementType,
List<DartObjectImpl> elements,
) {
return DartObjectImpl(
_typeSystem,
_typeProvider.listType(elementType),
ListState(elements),
);
}
DartObjectImpl _mapValue(DartType keyType, DartType valueType,
List<DartObjectImpl> keyValuePairs) {
Map<DartObjectImpl, DartObjectImpl> map =
<DartObjectImpl, DartObjectImpl>{};
int count = keyValuePairs.length;
for (int i = 0; i < count;) {
map[keyValuePairs[i++]] = keyValuePairs[i++];
}
return DartObjectImpl(
_typeSystem,
_typeProvider.mapType(keyType, valueType),
MapState(map),
);
}
DartObjectImpl _nullValue() {
return DartObjectImpl(
_typeSystem,
_typeProvider.nullType,
NullState.NULL_STATE,
);
}
DartObjectImpl _setValue(
ParameterizedType type, Set<DartObjectImpl>? elements) {
return DartObjectImpl(
_typeSystem,
type,
SetState(elements ?? <DartObjectImpl>{}),
);
}
DartObjectImpl _stringValue(String? value) {
if (value == null) {
return DartObjectImpl(
_typeSystem,
_typeProvider.stringType,
StringState.UNKNOWN_VALUE,
);
} else {
return DartObjectImpl(
_typeSystem,
_typeProvider.stringType,
StringState(value),
);
}
}
DartObjectImpl _symbolValue(String value) {
return DartObjectImpl(
_typeSystem,
_typeProvider.symbolType,
SymbolState(value),
);
}
DartObjectImpl _typeValue(DartType value) {
return DartObjectImpl(
_typeSystem,
_typeProvider.typeType,
TypeState(value),
);
}
}