fancy 0.3.3 → 0.4.0

data/tests/hash.fy

@@ -1,101 +1,118 @@
 FancySpec describe: Hash with: {
-  it: "should be empty on initialization" for: 'empty? when: {
+  it: "is empty on initialization" with: 'empty? when: {
     hash = <[]>
-    hash size should == 0
-    hash empty? should == true
+    hash size is: 0
+    hash empty? is: true
   }
 
-  it: "should be empty on initialization via Hash#new" for: 'size when: {
+  it: "is empty on initialization via Hash#new" with: 'size when: {
     hash = Hash new
-    hash size should == 0
-    hash empty? should == true
+    hash size is: 0
+    hash empty? is: true
   }
 
-  it: "should contain one entry" when: {
+  it: "contains one entry" when: {
     hash = <['foo => "bar"]>
-    hash size should == 1
-    hash empty? should == false
+    hash size is: 1
+    hash empty? is: false
   }
 
-  it: "should contain 10 square values after 10 insertions" for: 'at: when: {
+  it: "contains 10 square values after 10 insertions" with: 'at: when: {
     hash = Hash new
     10 times: |i| {
       hash at: i put: (i * i)
     }
 
     10 times: |i| {
-      hash at: i . should == (i * i)
+      hash at: i . is: (i * i)
     }
   }
 
-  it: "should override the value for a given key" for: 'at: when: {
+  it: "overrides the value for a given key" with: 'at: when: {
     hash = <['foo => "bar"]>
-    hash at: 'foo . should == "bar"
+    hash at: 'foo . is: "bar"
     hash at: 'foo put: 'foobarbaz
-    hash at: 'foo . should == 'foobarbaz
+    hash at: 'foo . is: 'foobarbaz
   }
 
-  it: "should return all keys" for: 'keys when: {
+  it: "returns all keys" with: 'keys when: {
     hash = <['foo => "bar", 'bar => "baz", 'foobar => 112.21]>
-    hash keys should =? ['foo, 'bar, 'foobar]
+    hash keys is =? ['foo, 'bar, 'foobar]
   }
 
-  it: "should return all values" for: 'values when: {
+  it: "returns all values" with: 'values when: {
     hash = <['foo => "bar", 'bar => "baz", 'foobar => 112.21]>
-    hash values should =? ["bar", "baz", 112.21]
+    hash values is =? ["bar", "baz", 112.21]
   }
 
-  it: "should return value by the []-operator" for: "[]" when: {
+  it: "returns value by the []-operator" with: '[] when: {
     hash = <['foo => "bar", 'bar => "baz", 'foobar => 112.21]>
-    hash['foo] should == "bar"
-    hash['bar] should == "baz"
-    hash['foobar] should == 112.21
+    hash['foo] is: "bar"
+    hash['bar] is: "baz"
+    hash['foobar] is: 112.21
   }
 
-  it: "should return nil if the key isn't defined" for: '[] when: {
-    <['foo => "bar"]> ['bar] . should == nil
-    <[]> ['foobar] . should == nil
-    <['foo => "bar"]> [nil] . should == nil
+  it: "returns nil if the key isn't defined" with: '[] when: {
+    <['foo => "bar"]> ['bar] . is: nil
+    <[]> ['foobar] . is: nil
+    <['foo => "bar"]> [nil] . is: nil
   }
 
-  it: "should call the Block for each key and value" for: 'each: when: {
+  it: "calls the Block for each key and value" with: 'each: when: {
     hash = <['foo => "bar", 'bar => "baz", 'foobar => 112.21]>
     hash each: |key val| {
-      val should == (hash[key])
+      val is: (hash[key])
     }
   }
 
-  it: "should call the Block with each key" for: 'each_key: when: {
+  it: "calls the Block with each key" with: 'each_key: when: {
     hash = <['foo => "bar", 'bar => "baz", 'foobar => 112.21]>
     count = 0
     hash each_key: |key| {
-      key should == (hash keys[count])
+      key is: (hash keys[count])
       count = count + 1
     }
   }
 
-  it: "should call the Block with each value" for: 'each_value: when: {
+  it: "calls the Block with each value" with: 'each_value: when: {
     hash = <['foo => "bar", 'bar => "baz", 'foobar => 112.21]>
     count = 0
     hash each_value: |val| {
-      val should == (hash values[count])
+      val is: (hash values[count])
       count = count + 1
     }
   }
 
-  it: "should call most Enumerable methods with each pair" when: {
+  it: "calls Enumerable methods with each pair" when: {
     hash = <['hello => "world", 'fancy => "is cool"]>
 
-    hash map: |pair| { pair[0] } . should =? ['hello, 'fancy] # order does not matter
+    hash map: |pair| { pair[0] } . is =? ['hello, 'fancy] # order does not matter
 
     hash select: |pair| { pair[1] to_s includes?: "c" } .
-      should == [['fancy, "is cool"]]
+      is: [['fancy, "is cool"]]
 
     hash reject: |pair| { pair[0] to_s includes?: "l" } .
-      map: 'second . should == ["is cool"]
+      map: 'second . is: ["is cool"]
   }
 
-  it: "should return an Array of the key-value pairs" for: 'to_a when: {
-    <['foo => "bar", 'bar => "baz"]> to_a should =? [['foo, "bar"], ['bar, "baz"]]
+  it: "returns an Array of the key-value pairs" with: 'to_a when: {
+    <['foo => "bar", 'bar => "baz"]> to_a is =? [['foo, "bar"], ['bar, "baz"]]
+  }
+
+  it: "returns multiple values if given an array of keys" with: '[] when: {
+    hash = <['foo => 1, 'bar => "foobar", 'baz => 42, "hello world" => "hello!"]>
+    a, b, c = hash values_at: ('foo, 'bar, "hello world")
+    a is: 1
+    b is: "foobar"
+    c is: "hello!"
+  }
+
+  it: "includes a key" with: 'includes?: when: {
+    h = <['foo => "bar", 'bar => "baz"]>
+    h includes?: 'foo . is: true
+    h includes?: 'bar . is: true
+    h includes?: "foo" . is: false
+    h includes?: "bar" . is: false
+    h includes?: nil . is: false
   }
 }

data/tests/method.fy

@@ -1,9 +1,9 @@
 FancySpec describe: Method with: {
-  it: "should return a Method object" when: {
-    [1,2,3] method: "each:" . class should == Method
+  it: "returns a Method object" when: {
+    [1,2,3] method: "each:" . class is: Method
   }
 
-  # it: "should return the (correct) sender object of the MessageSend" when: {
+  # it: "returns the (correct) sender object of the MessageSend" when: {
   #   class SenderTest {
   #     def give_me_the_sender! {
   #       __sender__
@@ -11,10 +11,10 @@ FancySpec describe: Method with: {
   #   }
 
   #   x = SenderTest new
-  #   x give_me_the_sender! should == self
+  #   x give_me_the_sender! is: self
   # }
 
-  it: "should return the amount of arguments a Method takes" for: 'argcount when: {
+  it: "returns the amount of arguments a Method takes" with: 'arity when: {
     class Foo {
       def no_args {
       }
@@ -26,19 +26,19 @@ FancySpec describe: Method with: {
       }
     }
 
-    Foo instance_method: 'no_args . arity should == 0
-    Foo instance_method: "one_arg:" . arity should == 1
-    Foo instance_method: "two:args:" . arity should == 2
-    Foo instance_method: "three:args:ok:" . arity should == 3
+    Foo instance_method: 'no_args . arity is: 0
+    Foo instance_method: "one_arg:" . arity is: 1
+    Foo instance_method: "two:args:" . arity is: 2
+    Foo instance_method: "three:args:ok:" . arity is: 3
   }
 
-  it: "should return the return value" when: {
+  it: "returns the return value" when: {
     def foo: bar {
       return "returning!"
       bar # will never get executed
     }
 
-    foo: "yay" . should == "returning!"
+    foo: "yay" . is: "returning!"
 
     # another example
 
@@ -49,8 +49,8 @@ FancySpec describe: Method with: {
       0
     }
 
-    f: 10 . should == 0
-    f: 9 . should == 100
+    f: 10 . is: 0
+    f: 9 . is: 100
 
     # and another one
 
@@ -63,10 +63,10 @@ FancySpec describe: Method with: {
       return 0
     }
 
-    foo should == 8
+    foo is: 8
   }
 
-  it: "should return only from block-scope not from method-scope" when: {
+  it: "returns only from block-scope not from method-scope" when: {
     def self foo {
       10 times: |i| {
         i == 8 if_true: {
@@ -75,68 +75,75 @@ FancySpec describe: Method with: {
       }
       0
     }
-    foo should == 8
+    foo is: 8
   }
 
-  it: "should return locally (from block-scope not from method-scope" when: {
+  it: "returns locally (from block-scope not from method-scope" when: {
     def self foo {
       [1,2,3] select: |x| { return_local x != 3 }
     }
-    foo should == [1,2]
+    foo is: [1,2]
   }
 
   class Foo {
     def bar {
     }
-    def private private_bar {
+    def private_bar {
     }
-    def protected protected_bar {
+    private: 'private_bar
+    def protected_bar {
     }
+    protected: 'protected_bar
   }
 
-  it: "should be public" for: 'public? when: {
-    Foo instance_method: 'bar . public? should == true
-    Foo instance_method: 'private_bar . public? should == false
-    Foo instance_method: 'protected_bar . public? should == false
+  it: "is public" with: 'public? when: {
+    Foo instance_method: 'bar . public? is: true
+    Foo instance_method: 'private_bar . public? is: false
+    Foo instance_method: 'protected_bar . public? is: false
   }
 
-  it: "should be private" for: 'private? when: {
-    Foo instance_method: 'bar . private? should == false
-    Foo instance_method: 'private_bar . private? should == true
-    Foo instance_method: 'protected_bar . private? should == false
+  it: "is private" with: 'private? when: {
+    Foo instance_method: 'bar . private? is: false
+    Foo instance_method: 'private_bar . private? is: true
+    Foo instance_method: 'protected_bar . private? is: false
   }
 
-  it: "should be protected" for: 'protected? when: {
-    Foo instance_method: 'bar . protected? should == false
-    Foo instance_method: 'private_bar . protected? should == false
-    Foo instance_method: 'protected_bar . protected? should == true
+  it: "is protected" with: 'protected? when: {
+    Foo instance_method: 'bar . protected? is: false
+    Foo instance_method: 'private_bar . protected? is: false
+    Foo instance_method: 'protected_bar . protected? is: true
   }
 
-  it: "should set the default values for optional argument, when not passed in" when: {
+  it: "sets the default values for optional argument, when not passed in" when: {
     def foo: arg1 bar: arg2 ("foo") baz: arg3 (nil) {
       arg1 ++ arg2 ++ arg3
     }
 
-    foo: "hello" bar: "world" baz: "!" . should == "helloworld!"
-    foo: "hello" bar: "world" . should == "helloworld"
-    foo: "hello"  . should == "hellofoo"
+    foo: "hello" bar: "world" baz: "!" . is: "helloworld!"
+    foo: "hello" bar: "world" . is: "helloworld"
+    foo: "hello"  . is: "hellofoo"
   }
 
-  it: "should have default values for all arguments, if none given" when: {
+  it: "has default values for all arguments, if none given" when: {
     def a: arg1 ("foo") b: arg2 ("bar") c: arg3 ("baz") {
       [arg1, arg2, arg3]
     }
 
-    a: "hello" b: "world" c: "!" . should == ["hello", "world", "!"]
-    a: "hello" b: "world" . should == ["hello", "world", "baz"]
-    a: "hello" . should == ["hello", "bar", "baz"]
-    a should == ["foo", "bar", "baz"]
+    a: "hello" b: "world" c: "!" . is: ["hello", "world", "!"]
+    a: "hello" b: "world" . is: ["hello", "world", "baz"]
+    a: "hello" . is: ["hello", "bar", "baz"]
+    a is: ["foo", "bar", "baz"]
   }
 
-  it: "should return multiple values (as a Tuple)" when: {
+  it: "returns multiple values (as a Tuple)" when: {
     def multiple_return_values: x {
       (x, x + x, x + x + x)
     }
-    val = multiple_return_values: 3 . should == (3, 6, 9)
+    val = multiple_return_values: 3 . is: (3, 6, 9)
+  }
+
+  it: "parses methods without a body and default args correctly" when: {
+    def fooaa: bar ("fo");
+    fooaa: 10
   }
 }

data/tests/nil_class.fy

@@ -1,62 +1,62 @@
 FancySpec describe: NilClass with: {
-  it: "should be false for calling and: with any value" for: 'and: when: {
-    nil and: true . should == nil
-    nil and: 'foo . should == nil
-    nil and: nil . should == nil
-    false and: true . should == false
-    false and: 'foo . should == false
-    false and: nil . should == false
+  it: "is false for calling and: with any value" with: 'and: when: {
+    nil and: true . is: nil
+    nil and: 'foo . is: nil
+    nil and: nil . is: nil
+    false and: true . is: false
+    false and: 'foo . is: false
+    false and: nil . is: false
   }
 
-  it: "should be nil/false for calling && with any value" for: '&& when: {
-    (nil && true) should == nil
-    (nil && 'foo) should == nil
-    (nil && nil) should == nil
-    (false && true) should == false
-    (false && 'foo) should == false
-    (false && nil) should == false
+  it: "is nil/false for calling && with any value" with: '&& when: {
+    (nil && true) is: nil
+    (nil && 'foo) is: nil
+    (nil && nil) is: nil
+    (false && true) is: false
+    (false && 'foo) is: false
+    (false && nil) is: false
   }
 
-  it: "should be true for calling or: with any non-nil value" for: 'or: when: {
-    nil or: true . should == true
-    nil or: 'foo . should == 'foo
+  it: "is true for calling or: with any non-nil value" with: 'or: when: {
+    nil or: true . is: true
+    nil or: 'foo . is: 'foo
   }
 
-  it: "should be nil/false for calling or: with a nil/false value" for: 'or: when: {
-    nil or: nil . should == nil
-    nil or: false . should == false
+  it: "is nil/false for calling or: with a nil/false value" with: 'or: when: {
+    nil or: nil . is: nil
+    nil or: false . is: false
   }
 
-  it: "should be true for calling || with any non-nil value" for: '|| when: {
-    (nil || true) should == true
-    (nil || 'foo) should == 'foo
+  it: "is true for calling || with any non-nil value" with: '|| when: {
+    (nil || true) is: true
+    (nil || 'foo) is: 'foo
   }
 
-  it: "should be nil for calling || with a nil value" for: '|| when: {
-    (nil || nil) should == nil
+  it: "is nil for calling || with a nil value" with: '|| when: {
+    (nil || nil) is: nil
   }
 
-  it: "should NOT call the block" for: 'if_true: when: {
-    nil if_true: { 'then } . should == nil
+  it: "does not call the block" with: 'if_true: when: {
+    nil if_true: { 'then } . is: nil
   }
 
-  it: "should not call the block" for: 'if_false: when: {
-    nil if_false: { 'false } . should == nil
+  it: "does not call the block" with: 'if_false: when: {
+    nil if_false: { 'false } . is: nil
   }
 
-  it: "should be nil" for: 'nil? when: {
-    nil nil? should == true
+  it: "is nil" with: 'nil? when: {
+    nil nil? is: true
   }
 
-  it: "should be false" for: 'false? when: {
-    nil false? should == false
+  it: "is false" with: 'false? when: {
+    nil false? is: false
   }
 
-  it: "should NOT be true" for: 'true? when: {
-    nil true? should == false
+  it: "is not true" with: 'true? when: {
+    nil true? is: false
   }
 
-  it: "should call the block if nil" for: 'if_nil: when: {
-    nil if_nil: { 'is_nil } . should == 'is_nil
+  it: "calls the block if nil" with: 'if_nil: when: {
+    nil if_nil: { 'is_nil } . is: 'is_nil
   }
 }

data/tests/object.fy

@@ -1,39 +1,39 @@
 FancySpec describe: Object with: {
-  it: "should dynamically evaluate a message-send with no arguments" when: {
+  it: "dynamically evaluates a message-send with no arguments" when: {
     obj = 42
-    obj send_message: 'to_s . should == "42"
+    obj receive_message: 'to_s . is: "42"
   }
 
-  it: "should dynamically evaluate a message-send with a list of arguments" when: {
+  it: "dynamically evaluates a message-send with a list of arguments" when: {
     obj = "hello, world"
-    obj send_message: 'from:to: with_params: [0,4] . should == "hello"
+    obj receive_message: 'from:to: with_params: [0,4] . is: "hello"
   }
 
-  it: "should dynamically define slotvalues" when: {
+  it: "dynamically defines slotvalues" when: {
     obj = Object new
-    obj get_slot: 'foo . should == nil
+    obj get_slot: 'foo . is: nil
     obj set_slot: 'foo value: "hello, world"
-    obj get_slot: 'foo . should == "hello, world"
+    obj get_slot: 'foo . is: "hello, world"
   }
 
-  it: "should undefine a singleton method" when: {
+  it: "undefines a singleton method" when: {
     def self a_singleton_method {
       "a singleton method!"
     }
-    self a_singleton_method should == "a singleton method!"
+    self a_singleton_method is: "a singleton method!"
     self undefine_singleton_method: 'a_singleton_method
-    { self a_singleton_method } should raise: NoMethodError
+    { self a_singleton_method } raises: NoMethodError
   }
 
-  it: "should return its class" when: {
-    nil class should == NilClass
-    true class should == TrueClass
-    "foo" class should == String
-    'bar class should == Symbol
-    { 'a_block } class should == Block
+  it: "returns its class" when: {
+    nil class is: NilClass
+    true class is: TrueClass
+    "foo" class is: String
+    'bar class is: Symbol
+    { 'a_block } class is: Block
   }
 
-  it: "should call unkown_message:with_params: when calling an undefined method" when: {
+  it: "calls unkown_message:with_params: when calling an undefined method" when: {
     class UnknownMessage {
       def unknown_message: message with_params: params {
         "Got: " ++ message ++ " " ++ params
@@ -41,93 +41,102 @@ FancySpec describe: Object with: {
     }
 
     obj = UnknownMessage new
-    obj this_is_not_defined: "It's true!" . should == "Got: this_is_not_defined: It's true!"
+    obj this_is_not_defined: "It's true!" . is: "Got: this_is_not_defined: It's true!"
   }
 
-  it: "should return a correct string representation" when: {
-    3 to_s should == "3"
-    'foo to_s should == "foo"
-    nil to_s should == ""
+  it: "returns a correct string representation" when: {
+    3 to_s is: "3"
+    'foo to_s is: "foo"
+    nil to_s is: ""
   }
 
-  it: "should return a correct array representation" when: {
-    nil to_a should == []
-    'foo to_a should == ['foo]
-    <['foo => "bar", 'bar => "baz"]> to_a should =? [['bar, "baz"], ['foo, "bar"]]
+  it: "returns a correct array representation" when: {
+    nil to_a is: []
+    'foo to_a is: ['foo]
+    <['foo => "bar", 'bar => "baz"]> to_a is =? [['bar, "baz"], ['foo, "bar"]]
   }
 
-  it: "should return a correct fixnum representation" when: {
-    nil to_i should == 0
-    3 to_i should == 3
-    3.28437 to_i should == 3
+  it: "returns a correct fixnum representation" when: {
+    nil to_i is: 0
+    3 to_i is: 3
+    3.28437 to_i is: 3
   }
 
-  it: "should be an Object of the correct Class (or Superclass)" when: {
-    Object new is_a?: Object . should == true
-    "foo" is_a?: String . should == true
-    "foo" is_a?: Object . should == true
-    1123 is_a?: Fixnum . should == true
-    1123 is_a?: Object . should == true
-    132.123 is_a?: Float . should == true
-    132.123 is_a?: Object . should == true
+  it: "is an Object of the correct Class (or Superclass)" when: {
+    Object new is_a?: Object . is: true
+    "foo" is_a?: String . is: true
+    "foo" is_a?: Object . is: true
+    1123 is_a?: Fixnum . is: true
+    1123 is_a?: Object . is: true
+    132.123 is_a?: Float . is: true
+    132.123 is_a?: Object . is: true
   }
 
   # boolean messages
 
-  it: "should be true for calling and: with non-nil values" for: 'and: when: {
-    'foo and: 'bar . should == 'bar
+  it: "is true for calling and: with non-nil values" with: 'and: when: {
+    'foo and: 'bar . is: 'bar
   }
 
-  it: "should be false for calling and: with a nil value" for: 'and: when: {
-    'foo and: nil . should == nil
+  it: "is false for calling and: with a nil value" with: 'and: when: {
+    'foo and: nil . is: nil
   }
 
-  it: "should be true for calling && with non-nil values" for: '&& when: {
-    ('foo && 'bar) should == 'bar
+  it: "is true for calling && with non-nil values" with: '&& when: {
+    ('foo && 'bar) is: 'bar
   }
 
-  it: "should be false for calling && with a nil value" for: '&& when: {
-    ('foo && nil) should == nil
+  it: "is false for calling && with a nil value" with: '&& when: {
+    ('foo && nil) is: nil
   }
 
 
-  it: "should be true for calling or: with any value" for: 'or: when: {
-    'foo or: 'bar . should == 'foo
-    'foo or: nil . should == 'foo
+  it: "is true for calling or: with any value" with: 'or: when: {
+    'foo or: 'bar . is: 'foo
+    'foo or: nil . is: 'foo
   }
 
-  it: "should be true for calling || with any value" for: '|| when: {
-    ('foo || 'bar) should == 'foo
-    ('foo || nil) should == 'foo
+  it: "is true for calling || with any value" with: '|| when: {
+    ('foo || 'bar) is: 'foo
+    ('foo || nil) is: 'foo
+  }
+
+  it: "is true if only one of them is not true" with: 'xor: when: {
+    true xor: false . is: true
+    false xor: false . is: false
+    nil xor: nil . is: false
+    false xor: false . is: false
+    false xor: nil . is: false
+    1 xor: nil . is: true
   }
 
   # end boolean messages
 
-  it: "should NOT be nil for non-nil values" for: 'nil? when: {
-    'foo nil? should == false
-    1 nil? should == false
-    "hello" nil? should == false
+  it: "is not nil for non-nil values" with: 'nil? when: {
+    'foo nil? is: false
+    1 nil? is: false
+    "hello" nil? is: false
   }
 
-  it: "should NOT be false for non-nil values" for: 'false? when: {
-    'foo false? should == false
-    "hello, world" false? should == false
+  it: "is not false for non-nil values" with: 'false? when: {
+    'foo false? is: false
+    "hello, world" false? is: false
   }
 
-  it: "should not be true" for: 'true? when: {
-    'foo true? should == false
-    "hello, world" true? should == false
+  it: "is not true" with: 'true? when: {
+    'foo true? is: false
+    "hello, world" true? is: false
   }
 
-  it: "should return the correct value" for: 'returning:do: when: {
+  it: "returns the correct value" with: 'returning:do: when: {
     returning: [] do: |arr| {
       arr << 1
       arr << 2
       arr << 3
-    } . should == [1,2,3]
+    } . is: [1,2,3]
   }
 
-  it: "should only call a method if the receiver responds to it using a RespondsToProxy" for: 'if_responds? when: {
+  it: "only calls a method if the receiver responds to it using a RespondsToProxy" with: 'if_responds? when: {
     class SomeClass {
       def some_method {
         'it_works!
@@ -135,18 +144,91 @@ FancySpec describe: Object with: {
     }
 
     s = SomeClass new
-    s if_responds? some_method should == 'it_works!
-    s if_responds? some_undefined_method should == nil
+    s if_responds? some_method is: 'it_works!
+    s if_responds? some_undefined_method is: nil
   }
 
-  it: "should call the backtick: method when using the '`' syntax" for: 'backtick: when: {
-    `cat #{__FILE__}` should == (File read: __FILE__)
+  it: "calls the backtick: method when using the '`' syntax" with: 'backtick: when: {
+    `cat #{__FILE__}` is: (File read: __FILE__)
 
     # override backticks
     def backtick: str {
       str + " - NOT!"
     }
 
-    `ls -al` should == "ls -al - NOT!"
+    `ls -al` is: "ls -al - NOT!"
+  }
+
+  it: "overrides true and does some wacky stuff" with: 'true when: {
+    class MyClass {
+      def true {
+        false
+      }
+
+      def do_wacky_things {
+        4 == 5
+      }
+    }
+    MyClass new do_wacky_things is: false
+
+    {
+      true is: false
+    } call_with_receiver: (MyClass new)
+  }
+
+  it: "overrides nil" with: 'nil when: {
+    class MyClass {
+      def nil {
+        true
+      }
+    }
+
+    { nil is: true } call_with_receiver: (MyClass new)
+  }
+
+  it: "overrides false" with: 'false when: {
+    class MyClass2 {
+      def false {
+        true
+      }
+    }
+
+    { false is: true } call_with_receiver: (MyClass2 new)
+  }
+
+  it: "implicitly sends a message to self if no receiver is specified" when: {
+    def test { 42 }
+    test is: 42
+    self test is: 42
+    test is: (self test)
+  }
+
+  it: "calls a given block in the context of the receiver (like a message cascade)" with: 'do: when: {
+    arr = []
+    arr do: {
+      << 1
+      << 2
+      << 3
+      select!: 'even?
+    }
+    arr is: [2]
+    arr do: {
+      is: [2] # same
+    }
+  }
+
+  it: "returns a set of its slot names" with: 'slots when: {
+    class GotSlots {
+      def initialize {
+        @x, @y = 1, 2
+      }
+      def set_another_slot {
+        @z = 123
+      }
+    }
+    gs = GotSlots new
+    gs slots is: $ Set[['x, 'y]]
+    gs set_another_slot
+    gs slots is: $ Set[['x,'y,'z]]
   }
 }