mirror of
https://github.com/pocketpy/pocketpy
synced 2025-10-20 03:20:18 +00:00
Update 99_builtin_func.py
This commit is contained in:
zhs628
GitHub
parent
ce295301fc
commit
d493d74cde
@ -207,8 +207,6 @@ def f():
|
||||
assert type(hash(a)) is int
|
||||
|
||||
# 测试不可哈希对象
|
||||
|
||||
|
||||
# try:
|
||||
# hash({1:1})
|
||||
# print('未能拦截错误')
|
||||
@ -224,7 +222,6 @@ except:
|
||||
pass
|
||||
|
||||
|
||||
|
||||
# -----------------------------------------------
|
||||
# 114: 259: _vm->bind_builtin_func<1>("chr", [](VM* vm, ArgsView args) {
|
||||
# #####: 260: i64 i = CAST(i64, args[0]);
|
||||
@ -240,3 +237,785 @@ assert l == ['0 \x00', '1 \x01', '2 \x02', '3 \x03', '4 \x04', '5 \x05', '6 \x06
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 269: _vm->bind_builtin_func<1>("bin", [](VM* vm, ArgsView args) {
|
||||
# #####: 270: std::stringstream ss;
|
||||
# #####: 271: i64 x = CAST(i64, args[0]);
|
||||
# #####: 272: if(x < 0){ ss << "-"; x = -x; }
|
||||
# #####: 273: ss << "0b";
|
||||
# #####: 274: std::string bits;
|
||||
# #####: 275: while(x){
|
||||
# #####: 276: bits += (x & 1) ? '1' : '0';
|
||||
# #####: 277: x >>= 1;
|
||||
# -: 278: }
|
||||
# #####: 279: std::reverse(bits.begin(), bits.end());
|
||||
# #####: 280: if(bits.empty()) bits = "0";
|
||||
# #####: 281: ss << bits;
|
||||
# #####: 282: return VAR(ss.str());
|
||||
# #####: 283: });
|
||||
# test bin:
|
||||
|
||||
assert type(bin(1234)) is str
|
||||
|
||||
# 无法测试, 不能覆盖-----------------------------------------------
|
||||
# 136: 285: _vm->bind_builtin_func<1>("dir", [](VM* vm, ArgsView args) {
|
||||
# 10: 286: std::set<StrName> names;
|
||||
# 10: 287: if(!is_tagged(args[0]) && args[0]->is_attr_valid()){
|
||||
# #####: 288: std::vector<StrName> keys = args[0]->attr().keys();
|
||||
# #####: 289: names.insert(keys.begin(), keys.end());
|
||||
# #####: 290: }
|
||||
# 10: 291: const NameDict& t_attr = vm->_t(args[0])->attr();
|
||||
# 10: 292: std::vector<StrName> keys = t_attr.keys();
|
||||
# 10: 293: names.insert(keys.begin(), keys.end());
|
||||
# 10: 294: List ret;
|
||||
# 305: 295: for (StrName name : names) ret.push_back(VAR(name.sv()));
|
||||
# 10: 296: return VAR(std::move(ret));
|
||||
# 10: 297: });
|
||||
# test dir:
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 299: _vm->bind__repr__(_vm->tp_object, [](VM* vm, PyObject* obj) {
|
||||
# #####: 300: if(is_tagged(obj)) FATAL_ERROR();
|
||||
# #####: 301: std::stringstream ss;
|
||||
# #####: 302: ss << "<" << OBJ_NAME(vm->_t(obj)) << " object at 0x";
|
||||
# #####: 303: ss << std::hex << reinterpret_cast<intptr_t>(obj) << ">";
|
||||
# #####: 304: return VAR(ss.str());
|
||||
# #####: 305: });
|
||||
# test __repr__:
|
||||
class A():
|
||||
def __init__(self):
|
||||
self.attr = 0
|
||||
|
||||
repr(A())
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 33600: 318: _vm->bind_constructor<-1>("range", [](VM* vm, ArgsView args) {
|
||||
# 16742: 319: args._begin += 1; // skip cls
|
||||
# 16742: 320: Range r;
|
||||
# 16742: 321: switch (args.size()) {
|
||||
# 8735: 322: case 1: r.stop = CAST(i64, args[0]); break;
|
||||
# 3867: 323: case 2: r.start = CAST(i64, args[0]); r.stop = CAST(i64, args[1]); break;
|
||||
# 4140: 324: case 3: r.start = CAST(i64, args[0]); r.stop = CAST(i64, args[1]); r.step = CAST(i64, args[2]); break;
|
||||
# #####: 325: default: vm->TypeError("expected 1-3 arguments, got " + std::to_string(args.size()));
|
||||
# #####: 326: }
|
||||
# 33484: 327: return VAR(r);
|
||||
# 16742: 328: });
|
||||
# -: 329:
|
||||
# test range:
|
||||
|
||||
try:
|
||||
range(1,2,3,4)
|
||||
print('未能拦截错误, 在测试 range')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
# /************ int ************/
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 172: 367: _vm->bind_constructor<-1>("int", [](VM* vm, ArgsView args) {
|
||||
# 28: 368: if(args.size() == 1+0) return VAR(0);
|
||||
# 28: 369: if(args.size() == 1+1){
|
||||
# 26: 370: if (is_type(args[1], vm->tp_float)) return VAR((i64)CAST(f64, args[1]));
|
||||
# 2: 371: if (is_type(args[1], vm->tp_int)) return args[1];
|
||||
# 1: 372: if (is_type(args[1], vm->tp_bool)) return VAR(_CAST(bool, args[1]) ? 1 : 0);
|
||||
# -: 373: }
|
||||
# 3: 374: if(args.size() > 1+2) vm->TypeError("int() takes at most 2 arguments");
|
||||
# 3: 375: if (is_type(args[1], vm->tp_str)) {
|
||||
# 3: 376: int base = 10;
|
||||
# 3: 377: if(args.size() == 1+2) base = CAST(i64, args[2]);
|
||||
# 3: 378: const Str& s = CAST(Str&, args[1]);
|
||||
# -: 379: try{
|
||||
# 3: 380: size_t parsed = 0;
|
||||
# 3: 381: i64 val = Number::stoi(s.str(), &parsed, base);
|
||||
# 3: 382: PK_ASSERT(parsed == s.length());
|
||||
# 3: 383: return VAR(val);
|
||||
# 3: 384: }catch(...){
|
||||
# #####: 385: vm->ValueError("invalid literal for int(): " + s.escape());
|
||||
# #####: 386: }
|
||||
# 3: 387: }
|
||||
# #####: 388: vm->TypeError("invalid arguments for int()");
|
||||
# #####: 389: return vm->None;
|
||||
# 28: 390: });
|
||||
# test int:
|
||||
|
||||
try:
|
||||
int('asad')
|
||||
print('未能拦截错误, 在测试 int')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
try:
|
||||
int(123, 16)
|
||||
print('未能拦截错误, 在测试 int')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 392: _vm->bind_method<0>("int", "bit_length", [](VM* vm, ArgsView args) {
|
||||
# #####: 393: i64 x = _CAST(i64, args[0]);
|
||||
# #####: 394: if(x < 0) x = -x;
|
||||
# -: 395: int bits = 0;
|
||||
# #####: 396: while(x){ x >>= 1; bits++; }
|
||||
# #####: 397: return VAR(bits);
|
||||
# -: 398: });
|
||||
# test int.bit_length:
|
||||
assert type(int.bit_length(100)) is int
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 400: _vm->bind__floordiv__(_vm->tp_int, [](VM* vm, PyObject* lhs_, PyObject* rhs_) {
|
||||
# #####: 401: i64 rhs = CAST(i64, rhs_);
|
||||
# #####: 402: return VAR(_CAST(i64, lhs_) / rhs);
|
||||
# -: 403: });
|
||||
# test int.__floordiv__:
|
||||
assert type(10//11) is int
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 405: _vm->bind__mod__(_vm->tp_int, [](VM* vm, PyObject* lhs_, PyObject* rhs_) {
|
||||
# #####: 406: i64 rhs = CAST(i64, rhs_);
|
||||
# #####: 407: return VAR(_CAST(i64, lhs_) % rhs);
|
||||
# test int.__mod__:
|
||||
assert type(11%2) is int
|
||||
|
||||
|
||||
# /************ float ************/
|
||||
# 136: 433: _vm->bind_constructor<2>("float", [](VM* vm, ArgsView args) {
|
||||
# 10: 434: if (is_type(args[1], vm->tp_int)) return VAR((f64)CAST(i64, args[1]));
|
||||
# 9: 435: if (is_type(args[1], vm->tp_float)) return args[1];
|
||||
# 3: 436: if (is_type(args[1], vm->tp_bool)) return VAR(_CAST(bool, args[1]) ? 1.0 : 0.0);
|
||||
# 3: 437: if (is_type(args[1], vm->tp_str)) {
|
||||
# 3: 438: const Str& s = CAST(Str&, args[1]);
|
||||
# 3: 439: if(s == "inf") return VAR(INFINITY);
|
||||
# 2: 440: if(s == "-inf") return VAR(-INFINITY);
|
||||
# -: 441: try{
|
||||
# 2: 442: f64 val = Number::stof(s.str());
|
||||
# 2: 443: return VAR(val);
|
||||
# #####: 444: }catch(...){
|
||||
# #####: 445: vm->ValueError("invalid literal for float(): " + s.escape());
|
||||
# #####: 446: }
|
||||
# #####: 447: }
|
||||
# #####: 448: vm->TypeError("float() argument must be a int, float, bool or str");
|
||||
# #####: 449: return vm->None;
|
||||
# 10: 450: });
|
||||
# test float:
|
||||
|
||||
try:
|
||||
float('asad')
|
||||
print('未能拦截错误, 在测试 float')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
try:
|
||||
float([])
|
||||
print('未能拦截错误, 在测试 float')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
# /************ str ************/
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 495: _vm->bind_method<1>("str", "__rmul__", [](VM* vm, ArgsView args) {
|
||||
# #####: 496: const Str& self = _CAST(Str&, args[0]);
|
||||
# #####: 497: i64 n = CAST(i64, args[1]);
|
||||
# #####: 498: std::stringstream ss;
|
||||
# #####: 499: for(i64 i = 0; i < n; i++) ss << self.sv();
|
||||
# #####: 500: return VAR(ss.str());
|
||||
# #####: 501: });
|
||||
# test str.__rmul__:
|
||||
assert type(12 * '12') is str
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 554: _vm->bind_method<1>("str", "index", [](VM* vm, ArgsView args) {
|
||||
# #####: 555: const Str& self = _CAST(Str&, args[0]);
|
||||
# #####: 556: const Str& sub = CAST(Str&, args[1]);
|
||||
# #####: 557: int index = self.index(sub);
|
||||
# #####: 558: if(index == -1) vm->ValueError("substring not found");
|
||||
# #####: 559: return VAR(index);
|
||||
# #####: 560: });
|
||||
# test str.index:
|
||||
assert type('25363546'.index('63')) is int
|
||||
try:
|
||||
'25363546'.index('err')
|
||||
print('未能拦截错误, 在测试 str.index')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 562: _vm->bind_method<1>("str", "find", [](VM* vm, ArgsView args) {
|
||||
# #####: 563: const Str& self = _CAST(Str&, args[0]);
|
||||
# #####: 564: const Str& sub = CAST(Str&, args[1]);
|
||||
# #####: 565: return VAR(self.index(sub));
|
||||
# -: 566: });
|
||||
# test str.find:
|
||||
assert type('25363546'.find('63')) is int
|
||||
assert type('25363546'.find('err')) is int
|
||||
|
||||
|
||||
# /************ list ************/
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 174: 615: _vm->bind_constructor<-1>("list", [](VM* vm, ArgsView args) {
|
||||
# 29: 616: if(args.size() == 1+0) return VAR(List());
|
||||
# 29: 617: if(args.size() == 1+1){
|
||||
# 29: 618: return vm->py_list(args[1]);
|
||||
# -: 619: }
|
||||
# #####: 620: vm->TypeError("list() takes 0 or 1 arguments");
|
||||
# #####: 621: return vm->None;
|
||||
# 29: 622: });
|
||||
# test list:
|
||||
try:
|
||||
list(1,2)
|
||||
print('未能拦截错误, 在测试 list')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
# 未完全测试准确性----------------------------------------------
|
||||
# 116: 648: _vm->bind_method<1>("list", "index", [](VM* vm, ArgsView args) {
|
||||
# #####: 649: List& self = _CAST(List&, args[0]);
|
||||
# #####: 650: PyObject* obj = args[1];
|
||||
# #####: 651: for(int i=0; i<self.size(); i++){
|
||||
# #####: 652: if(vm->py_equals(self[i], obj)) return VAR(i);
|
||||
# -: 653: }
|
||||
# #####: 654: vm->ValueError(_CAST(Str&, vm->py_repr(obj)) + " is not in list");
|
||||
# #####: 655: return vm->None;
|
||||
# #####: 656: });
|
||||
# test list.index:
|
||||
assert type([1,2,3,4,5].index(4)) is int
|
||||
try:
|
||||
[1,2,3,4,5].index(6)
|
||||
print('未能拦截错误, 在测试 list.index')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
|
||||
|
||||
# 未完全测试准确性----------------------------------------------
|
||||
# 118: 658: _vm->bind_method<1>("list", "remove", [](VM* vm, ArgsView args) {
|
||||
# 1: 659: List& self = _CAST(List&, args[0]);
|
||||
# 1: 660: PyObject* obj = args[1];
|
||||
# 2: 661: for(int i=0; i<self.size(); i++){
|
||||
# 2: 662: if(vm->py_equals(self[i], obj)){
|
||||
# 1: 663: self.erase(i);
|
||||
# 1: 664: return vm->None;
|
||||
# -: 665: }
|
||||
# -: 666: }
|
||||
# #####: 667: vm->ValueError(_CAST(Str&, vm->py_repr(obj)) + " is not in list");
|
||||
# #####: 668: return vm->None;
|
||||
# 1: 669: });
|
||||
# test list.remove:
|
||||
try:
|
||||
[1,2,3,4,5].remove(6)
|
||||
print('未能拦截错误, 在测试 list.remove')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
|
||||
# 未完全测试准确性----------------------------------------------
|
||||
# 2536: 671: _vm->bind_method<-1>("list", "pop", [](VM* vm, ArgsView args) {
|
||||
# 1210: 672: List& self = _CAST(List&, args[0]);
|
||||
# 1210: 673: if(args.size() == 1+0){
|
||||
# 1208: 674: if(self.empty()) vm->IndexError("pop from empty list");
|
||||
# 1208: 675: return self.popx_back();
|
||||
# -: 676: }
|
||||
# 2: 677: if(args.size() == 1+1){
|
||||
# 2: 678: int index = CAST(int, args[1]);
|
||||
# 2: 679: index = vm->normalized_index(index, self.size());
|
||||
# 2: 680: PyObject* ret = self[index];
|
||||
# 2: 681: self.erase(index);
|
||||
# -: 682: return ret;
|
||||
# -: 683: }
|
||||
# #####: 684: vm->TypeError("pop() takes at most 1 argument");
|
||||
# #####: 685: return vm->None;
|
||||
# 1210: 686: });
|
||||
# test list.pop:
|
||||
try:
|
||||
[1,2,3,4,5].pop(1,2,3,4)
|
||||
print('未能拦截错误, 在测试 list.pop')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 721: _vm->bind_method<1>("list", "__rmul__", [](VM* vm, ArgsView args) {
|
||||
# #####: 722: const List& self = _CAST(List&, args[0]);
|
||||
# #####: 723: if(!is_int(args[1])) return vm->NotImplemented;
|
||||
# #####: 724: int n = _CAST(int, args[1]);
|
||||
# #####: 725: List result;
|
||||
# #####: 726: result.reserve(self.size() * n);
|
||||
# #####: 727: for(int i = 0; i < n; i++) result.extend(self);
|
||||
# #####: 728: return VAR(std::move(result));
|
||||
# #####: 729: });
|
||||
# test list.__rmul__:
|
||||
assert type(12 * [12]) is list
|
||||
|
||||
|
||||
# /************ tuple ************/
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 180: 783: _vm->bind_constructor<-1>("tuple", [](VM* vm, ArgsView args) {
|
||||
# 32: 784: if(args.size() == 1+0) return VAR(Tuple(0));
|
||||
# 32: 785: if(args.size() == 1+1){
|
||||
# 32: 786: List list = CAST(List, vm->py_list(args[1]));
|
||||
# 32: 787: return VAR(Tuple(std::move(list)));
|
||||
# 32: 788: }
|
||||
# #####: 789: vm->TypeError("tuple() takes at most 1 argument");
|
||||
# #####: 790: return vm->None;
|
||||
# 32: 791: });
|
||||
# -: 792:
|
||||
# test tuple:
|
||||
try:
|
||||
tuple(1,2)
|
||||
print('未能拦截错误, 在测试 tuple')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 118: 793: _vm->bind__contains__(_vm->tp_tuple, [](VM* vm, PyObject* obj, PyObject* item) {
|
||||
# 1: 794: Tuple& self = _CAST(Tuple&, obj);
|
||||
# 3: 795: for(PyObject* i: self) if(vm->py_equals(i, item)) return vm->True;
|
||||
# #####: 796: return vm->False;
|
||||
# 1: 797: });
|
||||
# test tuple.__contains__:
|
||||
assert (1,2,3).__contains__(5) == False
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 799: _vm->bind_method<1>("tuple", "count", [](VM* vm, ArgsView args) {
|
||||
# #####: 800: Tuple& self = _CAST(Tuple&, args[0]);
|
||||
# -: 801: int count = 0;
|
||||
# #####: 802: for(PyObject* i: self) if(vm->py_equals(i, args[1])) count++;
|
||||
# #####: 803: return VAR(count);
|
||||
# -: 804: });
|
||||
# test tuple.count:
|
||||
assert (1,2,2,3,3,3).count(3) == 3
|
||||
assert (1,2,2,3,3,3).count(0) == 0
|
||||
|
||||
|
||||
# /************ bool ************/
|
||||
# -----------------------------------------------
|
||||
# 116: 842: _vm->bind__repr__(_vm->tp_bool, [](VM* vm, PyObject* self) {
|
||||
# #####: 843: bool val = _CAST(bool, self);
|
||||
# #####: 844: return VAR(val ? "True" : "False");
|
||||
# -: 845: });
|
||||
# test bool.__repr__:
|
||||
assert repr(True) == 'True'
|
||||
assert repr(False) == 'False'
|
||||
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 58: 851: const PK_LOCAL_STATIC auto f_bool_add = [](VM* vm, PyObject* lhs, PyObject* rhs) -> PyObject* {
|
||||
# #####: 852: int x = (int)_CAST(bool, lhs);
|
||||
# #####: 853: if(is_int(rhs)) return VAR(x + _CAST(int, rhs));
|
||||
# #####: 854: if(rhs == vm->True) return VAR(x + 1);
|
||||
# #####: 855: if(rhs == vm->False) return VAR(x);
|
||||
# #####: 856: return vm->NotImplemented;
|
||||
# #####: 857: };
|
||||
#
|
||||
# 58: 867: _vm->bind__add__(_vm->tp_bool, f_bool_add);
|
||||
# test bool.__add__:
|
||||
assert type(True + 1) is int
|
||||
assert type(True + False) is int
|
||||
assert type(True + True) is int
|
||||
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 58: 859: const PK_LOCAL_STATIC auto f_bool_mul = [](VM* vm, PyObject* lhs, PyObject* rhs) -> PyObject* {
|
||||
# #####: 860: int x = (int)_CAST(bool, lhs);
|
||||
# #####: 861: if(is_int(rhs)) return VAR(x * _CAST(int, rhs));
|
||||
# #####: 862: if(rhs == vm->True) return VAR(x);
|
||||
# #####: 863: if(rhs == vm->False) return VAR(0);
|
||||
# #####: 864: return vm->NotImplemented;
|
||||
# #####: 865: };
|
||||
#
|
||||
# 58: 872: _vm->bind__mul__(_vm->tp_bool, f_bool_mul);
|
||||
# test bool.__mul__:
|
||||
assert type(True * 1) is int
|
||||
assert type(True * False) is int
|
||||
assert type(True * True) is int
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 873: _vm->bind_method<1>("bool", "__radd__", [](VM* vm, ArgsView args){
|
||||
# #####: 874: return f_bool_add(vm, args[0], args[1]);
|
||||
# -: 875: });
|
||||
# test bool.__radd__:
|
||||
assert type(1 + True) is int
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 878: _vm->bind_method<1>("bool", "__rmul__", [](VM* vm, ArgsView args){
|
||||
# #####: 879: return f_bool_mul(vm, args[0], args[1]);
|
||||
# -: 880: });
|
||||
# test bool.__rmul__:
|
||||
assert type(1 * True) is int
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 882: _vm->bind__and__(_vm->tp_bool, [](VM* vm, PyObject* lhs, PyObject* rhs) {
|
||||
# #####: 883: return VAR(_CAST(bool, lhs) && CAST(bool, rhs));
|
||||
# -: 884: });
|
||||
# test bool.__and__:
|
||||
assert True & True == 1
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 885: _vm->bind__or__(_vm->tp_bool, [](VM* vm, PyObject* lhs, PyObject* rhs) {
|
||||
# #####: 886: return VAR(_CAST(bool, lhs) || CAST(bool, rhs));
|
||||
# -: 887: });
|
||||
# test bool.__or__:
|
||||
assert True | True == 1
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 888: _vm->bind__xor__(_vm->tp_bool, [](VM* vm, PyObject* lhs, PyObject* rhs) {
|
||||
# #####: 889: return VAR(_CAST(bool, lhs) != CAST(bool, rhs));
|
||||
# -: 890: });
|
||||
# test bool.__xor__:
|
||||
assert (True ^ True) == 0
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 120: 891: _vm->bind__eq__(_vm->tp_bool, [](VM* vm, PyObject* lhs, PyObject* rhs) {
|
||||
# 2: 892: if(is_non_tagged_type(rhs, vm->tp_bool)) return VAR(lhs == rhs);
|
||||
# #####: 893: if(is_int(rhs)) return VAR(_CAST(bool, lhs) == (bool)CAST(i64, rhs));
|
||||
# #####: 894: return vm->NotImplemented;
|
||||
# 2: 895: });
|
||||
# test bool.__eq__:
|
||||
assert (True == True) == 1
|
||||
|
||||
|
||||
# /************ bytes ************/
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 922: _vm->bind__hash__(_vm->tp_bytes, [](VM* vm, PyObject* obj) {
|
||||
# #####: 923: const Bytes& self = _CAST(Bytes&, obj);
|
||||
# #####: 924: std::string_view view(self.data(), self.size());
|
||||
# #####: 925: return (i64)std::hash<std::string_view>()(view);
|
||||
# #####: 926: });
|
||||
# test bytes.__hash__:
|
||||
assert type(hash(bytes([0x41, 0x42, 0x43]))) is int
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 928: _vm->bind__repr__(_vm->tp_bytes, [](VM* vm, PyObject* obj) {
|
||||
# #####: 929: const Bytes& self = _CAST(Bytes&, obj);
|
||||
# #####: 930: std::stringstream ss;
|
||||
# #####: 931: ss << "b'";
|
||||
# #####: 932: for(int i=0; i<self.size(); i++){
|
||||
# #####: 933: ss << "\\x" << std::hex << std::setw(2) << std::setfill('0') << self[i];
|
||||
# -: 934: }
|
||||
# #####: 935: ss << "'";
|
||||
# #####: 936: return VAR(ss.str());
|
||||
# #####: 937: });
|
||||
# test bytes.__repr__:
|
||||
assert type(repr(bytes([0x41, 0x42, 0x43]))) is str
|
||||
|
||||
|
||||
# /************ slice ************/
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 953: _vm->bind_constructor<4>("slice", [](VM* vm, ArgsView args) {
|
||||
# #####: 954: return VAR(Slice(args[1], args[2], args[3]));
|
||||
# -: 955: });
|
||||
# test slice:
|
||||
assert type(slice(0.1, 0.2, 0.3)) is slice
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 957: _vm->bind__repr__(_vm->tp_slice, [](VM* vm, PyObject* obj) {
|
||||
# #####: 958: const Slice& self = _CAST(Slice&, obj);
|
||||
# #####: 959: std::stringstream ss;
|
||||
# #####: 960: ss << "slice(";
|
||||
# #####: 961: ss << CAST(Str, vm->py_repr(self.start)) << ", ";
|
||||
# #####: 962: ss << CAST(Str, vm->py_repr(self.stop)) << ", ";
|
||||
# #####: 963: ss << CAST(Str, vm->py_repr(self.step)) << ")";
|
||||
# #####: 964: return VAR(ss.str());
|
||||
# #####: 965: });
|
||||
# test slice.__repr__
|
||||
assert type(repr(slice(1,1,1))) is str
|
||||
|
||||
# /************ mappingproxy ************/
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 968: _vm->bind_method<0>("mappingproxy", "keys", [](VM* vm, ArgsView args) {
|
||||
# #####: 969: MappingProxy& self = _CAST(MappingProxy&, args[0]);
|
||||
# #####: 970: List keys;
|
||||
# #####: 971: for(StrName name : self.attr().keys()) keys.push_back(VAR(name.sv()));
|
||||
# #####: 972: return VAR(std::move(keys));
|
||||
# #####: 973: });
|
||||
# test mappingproxy.keys:
|
||||
class A():
|
||||
def __init__(self):
|
||||
self.a = 10
|
||||
def method(self):
|
||||
pass
|
||||
|
||||
|
||||
my_mappingproxy = A().__dict__
|
||||
assert type(my_mappingproxy.keys()) is list
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 975: _vm->bind_method<0>("mappingproxy", "values", [](VM* vm, ArgsView args) {
|
||||
# #####: 976: MappingProxy& self = _CAST(MappingProxy&, args[0]);
|
||||
# #####: 977: List values;
|
||||
# #####: 978: for(auto& item : self.attr().items()) values.push_back(item.second);
|
||||
# #####: 979: return VAR(std::move(values));
|
||||
# #####: 980: });
|
||||
# test mappingproxy.values:
|
||||
class A():
|
||||
def __init__(self):
|
||||
self.a = 10
|
||||
def method(self):
|
||||
pass
|
||||
|
||||
|
||||
my_mappingproxy = A().__dict__
|
||||
assert type(my_mappingproxy.values()) is list
|
||||
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 992: _vm->bind__len__(_vm->tp_mappingproxy, [](VM* vm, PyObject* obj) {
|
||||
# #####: 993: return (i64)_CAST(MappingProxy&, obj).attr().size();
|
||||
# -: 994: });
|
||||
# test mappingproxy.__len__:
|
||||
class A():
|
||||
def __init__(self):
|
||||
self.a = 10
|
||||
def method(self):
|
||||
pass
|
||||
|
||||
|
||||
my_mappingproxy = A().__dict__
|
||||
assert type(len(my_mappingproxy)) is int
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 996: _vm->bind__hash__(_vm->tp_mappingproxy, [](VM* vm, PyObject* obj) {
|
||||
# #####: 997: vm->TypeError("unhashable type: 'mappingproxy'");
|
||||
# #####: 998: return (i64)0;
|
||||
# #####: 999: });
|
||||
# test mappingproxy.__hash__:
|
||||
class A():
|
||||
def __init__(self):
|
||||
self.a = 10
|
||||
def method(self):
|
||||
pass
|
||||
|
||||
|
||||
my_mappingproxy = A().__dict__
|
||||
|
||||
try:
|
||||
hash(my_mappingproxy)
|
||||
print('未能拦截错误, 在测试 mappingproxy.__hash__')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 1009: _vm->bind__repr__(_vm->tp_mappingproxy, [](VM* vm, PyObject* obj) {
|
||||
# #####: 1010: MappingProxy& self = _CAST(MappingProxy&, obj);
|
||||
# #####: 1011: std::stringstream ss;
|
||||
# #####: 1012: ss << "mappingproxy({";
|
||||
# -: 1013: bool first = true;
|
||||
# #####: 1014: for(auto& item : self.attr().items()){
|
||||
# #####: 1015: if(!first) ss << ", ";
|
||||
# -: 1016: first = false;
|
||||
# #####: 1017: ss << item.first.escape() << ": " << CAST(Str, vm->py_repr(item.second));
|
||||
# -: 1018: }
|
||||
# #####: 1019: ss << "})";
|
||||
# #####: 1020: return VAR(ss.str());
|
||||
# #####: 1021: });
|
||||
# test mappingproxy.__repr__:
|
||||
class A():
|
||||
def __init__(self):
|
||||
self.a = 10
|
||||
def method(self):
|
||||
pass
|
||||
|
||||
|
||||
my_mappingproxy = A().__dict__
|
||||
assert type(repr(my_mappingproxy)) is str
|
||||
|
||||
|
||||
# /************ dict ************/
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 202: 1033: _vm->bind_method<-1>("dict", "__init__", [](VM* vm, ArgsView args){
|
||||
# 43: 1034: if(args.size() == 1+0) return vm->None;
|
||||
# 42: 1035: if(args.size() == 1+1){
|
||||
# 42: 1036: auto _lock = vm->heap.gc_scope_lock();
|
||||
# 42: 1037: Dict& self = _CAST(Dict&, args[0]);
|
||||
# 42: 1038: List& list = CAST(List&, args[1]);
|
||||
# 165: 1039: for(PyObject* item : list){
|
||||
# 123: 1040: Tuple& t = CAST(Tuple&, item);
|
||||
# 123: 1041: if(t.size() != 2){
|
||||
# #####: 1042: vm->ValueError("dict() takes an iterable of tuples (key, value)");
|
||||
# #####: 1043: return vm->None;
|
||||
# -: 1044: }
|
||||
# 123: 1045: self.set(t[0], t[1]);
|
||||
# 246: 1046: }
|
||||
# 42: 1047: return vm->None;
|
||||
# 42: 1048: }
|
||||
# #####: 1049: vm->TypeError("dict() takes at most 1 argument");
|
||||
# #####: 1050: return vm->None;
|
||||
# 43: 1051: });
|
||||
# test dict:
|
||||
assert type(dict([(1,2)])) is dict
|
||||
|
||||
try:
|
||||
dict([(1, 2, 3)])
|
||||
print('未能拦截错误, 在测试 dict')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
try:
|
||||
dict([(1, 2)], 1)
|
||||
print('未能拦截错误, 在测试 dict')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 1057: _vm->bind__hash__(_vm->tp_dict, [](VM* vm, PyObject* obj) {
|
||||
# #####: 1058: vm->TypeError("unhashable type: 'dict'");
|
||||
# #####: 1059: return (i64)0;
|
||||
# #####: 1060: });
|
||||
# test dict.__hash__
|
||||
try:
|
||||
hash(dict([(1,2)]))
|
||||
print('未能拦截错误, 在测试 dict.__hash__')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 1093: _vm->bind__iter__(_vm->tp_dict, [](VM* vm, PyObject* obj) {
|
||||
# #####: 1094: const Dict& self = _CAST(Dict&, obj);
|
||||
# #####: 1095: return vm->py_iter(VAR(self.keys()));
|
||||
# #####: 1096: });
|
||||
# test dict.__iter__
|
||||
for k in {1:2, 2:3, 3:4}:
|
||||
assert k in [1,2,3]
|
||||
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 166: 1098: _vm->bind_method<-1>("dict", "get", [](VM* vm, ArgsView args) {
|
||||
# 25: 1099: Dict& self = _CAST(Dict&, args[0]);
|
||||
# 25: 1100: if(args.size() == 1+1){
|
||||
# #####: 1101: PyObject* ret = self.try_get(args[1]);
|
||||
# #####: 1102: if(ret != nullptr) return ret;
|
||||
# #####: 1103: return vm->None;
|
||||
# 25: 1104: }else if(args.size() == 1+2){
|
||||
# 25: 1105: PyObject* ret = self.try_get(args[1]);
|
||||
# 25: 1106: if(ret != nullptr) return ret;
|
||||
# 19: 1107: return args[2];
|
||||
# -: 1108: }
|
||||
# #####: 1109: vm->TypeError("get() takes at most 2 arguments");
|
||||
# #####: 1110: return vm->None;
|
||||
# 25: 1111: });
|
||||
# test dict.get
|
||||
|
||||
assert {1:2, 3:4}.get(1) == 2
|
||||
assert {1:2, 3:4}.get(2) is None
|
||||
assert {1:2, 3:4}.get(20, 100) == 100
|
||||
|
||||
try:
|
||||
{1:2, 3:4}.get(1,1, 1)
|
||||
print('未能拦截错误, 在测试 dict.get')
|
||||
exit(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 1151: _vm->bind__repr__(_vm->tp_dict, [](VM* vm, PyObject* obj) {
|
||||
# #####: 1152: Dict& self = _CAST(Dict&, obj);
|
||||
# #####: 1153: std::stringstream ss;
|
||||
# #####: 1154: ss << "{";
|
||||
# #####: 1155: bool first = true;
|
||||
# -: 1156:
|
||||
# #####: 1157: self.apply([&](PyObject* k, PyObject* v){
|
||||
# #####: 1158: if(!first) ss << ", ";
|
||||
# #####: 1159: first = false;
|
||||
# #####: 1160: Str key = CAST(Str&, vm->py_repr(k));
|
||||
# #####: 1161: Str value = CAST(Str&, vm->py_repr(v));
|
||||
# #####: 1162: ss << key << ": " << value;
|
||||
# #####: 1163: });
|
||||
# -: 1164:
|
||||
# #####: 1165: ss << "}";
|
||||
# #####: 1166: return VAR(ss.str());
|
||||
# #####: 1167: });
|
||||
# test dict.__repr__
|
||||
assert type(repr({1:2, 3:4})) is str
|
||||
|
||||
# /************ property ************/
|
||||
|
||||
# /************ module timeit ************/
|
||||
|
||||
# /************ module time ************/
|
||||
import time
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 1267: vm->bind_func<1>(mod, "sleep", [](VM* vm, ArgsView args) {
|
||||
# #####: 1268: f64 seconds = CAST_F(args[0]);
|
||||
# #####: 1269: auto begin = std::chrono::system_clock::now();
|
||||
# #####: 1270: while(true){
|
||||
# #####: 1271: auto now = std::chrono::system_clock::now();
|
||||
# #####: 1272: f64 elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - begin).count() / 1000.0;
|
||||
# #####: 1273: if(elapsed >= seconds) break;
|
||||
# #####: 1274: }
|
||||
# #####: 1275: return vm->None;
|
||||
# #####: 1276: });
|
||||
# test time.time
|
||||
assert type(time.time()) is float
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 1267: vm->bind_func<1>(mod, "sleep", [](VM* vm, ArgsView args) {
|
||||
# #####: 1268: f64 seconds = CAST_F(args[0]);
|
||||
# #####: 1269: auto begin = std::chrono::system_clock::now();
|
||||
# #####: 1270: while(true){
|
||||
# #####: 1271: auto now = std::chrono::system_clock::now();
|
||||
# #####: 1272: f64 elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - begin).count() / 1000.0;
|
||||
# #####: 1273: if(elapsed >= seconds) break;
|
||||
# #####: 1274: }
|
||||
# #####: 1275: return vm->None;
|
||||
# #####: 1276: });
|
||||
# test time.sleep
|
||||
time.sleep(0.5)
|
||||
|
||||
# 未完全测试准确性-----------------------------------------------
|
||||
# 116: 1278: vm->bind_func<0>(mod, "localtime", [](VM* vm, ArgsView args) {
|
||||
# #####: 1279: auto now = std::chrono::system_clock::now();
|
||||
# #####: 1280: std::time_t t = std::chrono::system_clock::to_time_t(now);
|
||||
# #####: 1281: std::tm* tm = std::localtime(&t);
|
||||
# #####: 1282: Dict d(vm);
|
||||
# #####: 1283: d.set(VAR("tm_year"), VAR(tm->tm_year + 1900));
|
||||
# #####: 1284: d.set(VAR("tm_mon"), VAR(tm->tm_mon + 1));
|
||||
# #####: 1285: d.set(VAR("tm_mday"), VAR(tm->tm_mday));
|
||||
# #####: 1286: d.set(VAR("tm_hour"), VAR(tm->tm_hour));
|
||||
# #####: 1287: d.set(VAR("tm_min"), VAR(tm->tm_min));
|
||||
# #####: 1288: d.set(VAR("tm_sec"), VAR(tm->tm_sec + 1));
|
||||
# #####: 1289: d.set(VAR("tm_wday"), VAR((tm->tm_wday + 6) % 7));
|
||||
# #####: 1290: d.set(VAR("tm_yday"), VAR(tm->tm_yday + 1));
|
||||
# #####: 1291: d.set(VAR("tm_isdst"), VAR(tm->tm_isdst));
|
||||
# #####: 1292: return VAR(std::move(d));
|
||||
# #####: 1293: });
|
||||
# 58: 1294:}
|
||||
# test time.localtime
|
||||
assert type(time.localtime()) is dict
|
||||
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user