Merge remote-tracking branch 'origin/master' into joey/fun-with-functions

Conflicts:
      vm/src/pyobject.rs

Author: OddCoincidence

Cargo.lock

@@ -55,6 +55,7 @@ pub struct Lexer<T: Iterator<Item = char>> {
 pub enum LexicalError {
     StringError,
     NestingError,
+    UnrecognizedToken { tok: char },
 }
 
 #[derive(Clone, Debug, Default, PartialEq)]
@@ -687,7 +688,9 @@ where
 
             match self.chr0 {
                 Some('0'..='9') => return Some(self.lex_number()),
-                Some('_') | Some('a'..='z') | Some('A'..='Z') => return Some(self.lex_identifier()),
+                Some('_') | Some('a'..='z') | Some('A'..='Z') => {
+                    return Some(self.lex_identifier());
+                }
                 Some('#') => {
                     self.lex_comment();
                     continue;
@@ -1033,7 +1036,7 @@ where
                 None => return None,
                 _ => {
                     let c = self.next_char();
-                    panic!("Not impl {:?}", c)
+                    return Some(Err(LexicalError::UnrecognizedToken { tok: c.unwrap() }));
                 } // Ignore all the rest..
             }
         }

parser/src/lexer.rs

@@ -306,7 +306,9 @@ mod tests {
 
     #[test]
     fn test_parse_class() {
-        let source = String::from("class Foo(A, B):\n def __init__(self):\n  pass\n def method_with_default(self, arg='default'):\n  pass\n");
+        let source = String::from(
+            "class Foo(A, B):\n def __init__(self):\n  pass\n def method_with_default(self, arg='default'):\n  pass\n",
+        );
         assert_eq!(
             parse_statement(&source),
             Ok(ast::LocatedStatement {

parser/src/parser.rs

@@ -0,0 +1 @@
+edition = "2018"

rustfmt.toml

@@ -10,6 +10,7 @@ def test_function():
     x = 17
     assert sys._getframe().f_locals is not locals_dict
     assert sys._getframe().f_locals['x'] == 17
+    assert sys._getframe(1).f_locals['foo'] == 'bar'
 
 test_function()
 

tests/snippets/getframe.py

@@ -1,3 +1,5 @@
+from testutils import assert_raises
+
 # int to int comparisons
 
 assert 1 == 1
@@ -15,6 +17,10 @@
 assert 1 >= 1.0
 assert 1 <= 1.0
 
+# check for argument handling
+
+assert int("101", base=2) == 5
+
 # magic methods should only be implemented for other ints
 
 assert (1).__eq__(1) == True
@@ -36,6 +42,7 @@
 assert (1).real == 1
 assert (1).imag == 0
 
+assert_raises(OverflowError, lambda: 1 << 10 ** 100000)
 
 assert (1).__eq__(1.0) == NotImplemented
 assert (1).__ne__(1.0) == NotImplemented

tests/snippets/ints.py

@@ -0,0 +1,54 @@
+
+class Regular:
+    pass
+
+
+assert isinstance(Regular(), Regular)
+
+
+class MCNotInstanceOf(type):
+    def __instancecheck__(self, instance):
+        return False
+
+
+class NotInstanceOf(metaclass=MCNotInstanceOf):
+    pass
+
+
+class InheritedNotInstanceOf(NotInstanceOf):
+    pass
+
+
+assert not isinstance(Regular(), NotInstanceOf)
+assert not isinstance(1, NotInstanceOf)
+
+# weird cpython behaviour if exact match then isinstance return true
+assert isinstance(NotInstanceOf(), NotInstanceOf)
+assert not NotInstanceOf.__instancecheck__(NotInstanceOf())
+assert not isinstance(InheritedNotInstanceOf(), NotInstanceOf)
+
+
+class MCAlwaysInstanceOf(type):
+    def __instancecheck__(self, instance):
+        return True
+
+
+class AlwaysInstanceOf(metaclass=MCAlwaysInstanceOf):
+    pass
+
+
+assert isinstance(AlwaysInstanceOf(), AlwaysInstanceOf)
+assert isinstance(Regular(), AlwaysInstanceOf)
+assert isinstance(1, AlwaysInstanceOf)
+
+
+class MCReturnInt(type):
+    def __instancecheck__(self, instance):
+        return 3
+
+
+class ReturnInt(metaclass=MCReturnInt):
+    pass
+
+
+assert isinstance("a", ReturnInt) is True

tests/snippets/isinstance.py

@@ -0,0 +1,63 @@
+
+class A:
+    pass
+
+
+class B(A):
+    pass
+
+
+assert issubclass(A, A)
+assert issubclass(B, A)
+assert not issubclass(A, B)
+
+
+class MCNotSubClass(type):
+    def __subclasscheck__(self, subclass):
+        return False
+
+
+class NotSubClass(metaclass=MCNotSubClass):
+    pass
+
+
+class InheritedNotSubClass(NotSubClass):
+    pass
+
+
+assert not issubclass(A, NotSubClass)
+assert not issubclass(NotSubClass, NotSubClass)
+assert not issubclass(InheritedNotSubClass, NotSubClass)
+assert not issubclass(NotSubClass, InheritedNotSubClass)
+
+
+class MCAlwaysSubClass(type):
+    def __subclasscheck__(self, subclass):
+        return True
+
+
+class AlwaysSubClass(metaclass=MCAlwaysSubClass):
+    pass
+
+
+class InheritedAlwaysSubClass(AlwaysSubClass):
+    pass
+
+
+assert issubclass(A, AlwaysSubClass)
+assert issubclass(AlwaysSubClass, AlwaysSubClass)
+assert issubclass(InheritedAlwaysSubClass, AlwaysSubClass)
+assert issubclass(AlwaysSubClass, InheritedAlwaysSubClass)
+
+
+class MCAVirtualSubClass(type):
+    def __subclasscheck__(self, subclass):
+        return subclass is A
+
+
+class AVirtualSubClass(metaclass=MCAVirtualSubClass):
+    pass
+
+
+assert issubclass(A, AVirtualSubClass)
+assert not isinstance(B, AVirtualSubClass)

tests/snippets/issubclass.py

@@ -117,3 +117,42 @@ def __eq__(self, x):
 assert a == b
 
 assert [foo] == [foo]
+
+for size in [1, 2, 3, 4, 5, 8, 10, 100, 1000]:
+   lst = list(range(size))
+   orig = lst[:]
+   lst.sort()
+   assert lst == orig
+   assert sorted(lst) == orig
+   assert_raises(ZeroDivisionError, lambda: sorted(lst, key=lambda x: 1/x))
+   lst.reverse()
+   assert sorted(lst) == orig
+   assert sorted(lst, reverse=True) == lst
+   assert sorted(lst, key=lambda x: -x) == lst
+   assert sorted(lst, key=lambda x: -x, reverse=True) == orig
+
+assert sorted([(1, 2, 3), (0, 3, 6)]) == [(0, 3, 6), (1, 2, 3)]
+assert sorted([(1, 2, 3), (0, 3, 6)], key=lambda x: x[0]) == [(0, 3, 6), (1, 2, 3)]
+assert sorted([(1, 2, 3), (0, 3, 6)], key=lambda x: x[1]) == [(1, 2, 3), (0, 3, 6)]
+assert sorted([(1, 2), (), (5,)], key=len) == [(), (5,), (1, 2)]
+
+lst = [3, 1, 5, 2, 4]
+class C:
+  def __init__(self, x): self.x = x
+  def __lt__(self, other): return self.x < other.x
+lst.sort(key=C)
+assert lst == [1, 2, 3, 4, 5]
+
+lst = [3, 1, 5, 2, 4]
+class C:
+  def __init__(self, x): self.x = x
+  def __gt__(self, other): return self.x > other.x
+lst.sort(key=C)
+assert lst == [1, 2, 3, 4, 5]
+
+lst = [5, 1, 2, 3, 4]
+def f(x):
+    lst.append(1)
+    return x
+assert_raises(ValueError, lambda: lst.sort(key=f)) # "list modified during sort"
+assert lst == [1, 2, 3, 4, 5]

tests/snippets/list.py

@@ -1,20 +1,37 @@
 import socket
+from testutils import assertRaises
+
 
 listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-listener.bind(("127.0.0.1", 8080))
+listener.bind(("127.0.0.1", 0))
 listener.listen(1)
 
 connector = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-connector.connect(("127.0.0.1", 8080))
+connector.connect(("127.0.0.1", listener.getsockname()[1]))
 connection = listener.accept()[0]
 
 message_a = b'aaaa'
 message_b = b'bbbbb'
 
 connector.send(message_a)
-connector.close()
-recv_a = connection.recv(10)
+connection.send(message_b)
+recv_a = connection.recv(len(message_a))
+recv_b = connector.recv(len(message_b))
+assert recv_a == message_a
+assert recv_b == message_b
 
 connection.close()
+connector.close()
 listener.close()
 
+s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+with assertRaises(TypeError):
+	s.connect(("127.0.0.1", 8888, 8888))
+
+with assertRaises(TypeError):
+	s.bind(("127.0.0.1", 8888, 8888))
+
+with assertRaises(TypeError):
+	s.bind((888, 8888))
+
+s.close()