stupidedi 1.1.0

data/spec/examples/ruby/array.example

@@ -0,0 +1,476 @@
+require 'spec_helper'
+
+describe Array do
+  include QuickCheck::Macro
+
+  # Creates an array with length `2*n-1` containing elements
+  # 1, 2, 3, ..., n-1, n, n-1, ..., 3, 2, 1
+  def mkarray(n)
+    (1..n).to_a.bind{|as| as.concat(as.init.reverse) }
+  end
+
+  describe "#defined_at?(n)" do
+    context "on an empty array" do
+      property("is false") do
+        integer
+      end.check{|n| [].should_not be_defined_at(n) }
+    end
+  end
+
+  describe "#head" do
+    context "of an empty array" do
+      it "is an error" do
+        lambda { [].head }.should raise_error
+      end
+    end
+
+    context "of a one-element array" do
+      it "is the first element" do
+        [1].head.should == 1
+      end
+
+      property("is the first element") do
+        integer
+      end.check{|x| [x].head.should == x }
+    end
+
+    context "of a two-element array" do
+      it "is the first element" do
+        [1, 2].head.should == 1
+      end
+
+      property("is the first element") do
+        [integer, integer]
+      end.check{|x,y| [x,y].head.should == x }
+    end
+  end
+
+  describe "#tail(n)" do
+    context "of an empty array" do
+      it "is an empty array" do
+        [].tail.should == []
+      end
+    end
+
+    context "of a one-element array" do
+      it "is an empty array" do
+        [1].tail.should == []
+      end
+
+      property("is an empty array") do
+        integer
+      end.check{|x| [x].tail.should == [] }
+    end
+
+    context "of a two-element array" do
+      it "contains only the second element" do
+        [1, 2].tail.should == [2]
+      end
+
+      property("contains only the second element") do
+        [integer, integer]
+      end.check{|x,y| [x,y].tail.should == [y] }
+    end
+  end
+
+  describe "#init(n)" do
+    context "of an empty array" do
+      it "is an empty array" do
+        [].init.should == []
+      end
+    end
+
+    context "of a one-element array" do
+      it "is an empty array" do
+        [1].init.should == []
+      end
+
+      property("is an empty array") do
+        integer
+      end.check{|x| [x].init.should == [] }
+    end
+
+    context "of a two-element array" do
+      it "contains only the first element" do
+        [1, 2].init.should == [1]
+      end
+
+      property("contains only the first element") do
+        [integer, integer]
+      end.check{|x,y| [x,y].init.should == [x] }
+    end
+  end
+
+  describe "#drop(n)" do
+    context "of an empty array" do
+      it "is an empty array" do
+        [].drop(10).should == []
+      end
+
+      property("is an empty array") do
+        integer.abs
+      end.check{|n| [].drop(n).should == [] }
+    end
+
+    context "a negative number of elements" do
+      property("raises an error") do
+        integer.abs
+      end.check do |n|
+        lambda { %w(a b).drop(-n) }.should raise_error
+      end
+    end
+
+    context "zero elements" do
+      it "returns the original array" do
+        %w(a b).drop(0).should == %w(a b)
+      end
+
+      property("returns the original array") do
+        with(:size, between(0, 25)) { array { integer }}
+      end.check do |as|
+        as.drop(0).should == as
+      end
+    end
+
+    context "one element" do
+      context "from a one-element array" do
+        it "is an empty array" do
+          %w(a).drop(1).should == []
+        end
+
+        property("is an empty array") do
+          integer
+        end.check{|x| [x].drop(1).should == [] }
+      end
+
+      context "from a two-element array" do
+        it "contains only the second element" do
+          %w(a b).drop(1).should == %w(b)
+        end
+
+        property("contains only the second element") do
+          [integer, integer]
+        end.check{|x,y| [x,y].drop(1).should == [y] }
+      end
+    end
+
+    context "two elements" do
+      context "from a one-element array" do
+        it "is an empty array" do
+          %w(a).drop(2).should == []
+        end
+
+        property("is an empty array") do
+          integer
+        end.check{|x| [x].drop(2).should == [] }
+      end
+
+      context "from a two-element array" do
+        it "is an empty array" do
+          %w(a b).drop(2).should == []
+        end
+
+        property("is an empty array") do
+          [integer, integer]
+        end.check{|x,y| [x,y].drop(2).should == [] }
+      end
+    end
+  end
+
+  describe "#drop_while" do
+    context "when predicate is always satisfied" do
+      it "is an empty array" do
+        [1, 2, 3, 2, 1].drop_while{|x| x >= 1 }.should == []
+      end
+
+      property("is an empty array") do
+        mkarray(between(0, 10))
+      end.check do |as|
+        as.drop_while { true }.should == []
+      end
+    end
+
+    context "when the first element does not satisfy the predicate" do
+      it "is the original array" do
+        [1, 2, 3, 2, 1].drop_while{|x| x <= 0 }.should == [1, 2, 3, 2, 1]
+      end
+
+      property("is the original array") do
+        mkarray(between(0, 10))
+      end.check do |as|
+        as.drop_while { false }.should == as
+      end
+    end
+
+    context "when the second element does not satisfy the predicate" do
+      it "contains all except the first element" do
+        [1, 2, 3, 2, 1].drop_while{|x| x <= 1 }.should == [2, 3, 2, 1]
+      end
+
+      property("contains all except the first element") do
+        mkarray(between(2, 10))
+      end.check do |as|
+        as.drop_while{|x| x <= 1 }.should == as.tail
+      end
+    end
+
+    context "when the third element does not satisfy the predicate" do
+      it "contains all except the first two elements" do
+        [1, 2, 3, 2, 1].drop_while{|x| x <= 2 }.should == [3, 2, 1]
+      end
+
+      property("contains all except the first two elements") do
+        mkarray(between(3, 10))
+      end.check do |as|
+        as.drop_while {|x| x <= 2 }.should == as.tail.tail
+      end
+    end
+  end
+
+  describe "#drop_until" do
+    context "when predicate is always satisfied" do
+      property("is the original array") do
+        mkarray(between(0, 10))
+      end.check do |as|
+        as.drop_until { true }.should == as
+      end
+    end
+
+    context "when predicate is never satisfied" do
+      property("is an empty array") do
+        mkarray(between(0, 10))
+      end.check do |as|
+        as.drop_until { false }.should == []
+      end
+    end
+  end
+
+  describe "#take(n)" do
+    context "from an empty array" do
+      it "is an empty array" do
+        [].take(10).should == []
+      end
+
+      property("is an empty array") do
+        integer.abs
+      end.check{|n| [].take(n).should == [] }
+    end
+
+    context "a negative number of elements" do
+      property("raises an error") do
+        integer.abs
+      end.check do |n|
+        lambda { %w(a b).take(-n) }.should raise_error
+      end
+    end
+
+    context "zero elements" do
+      context "from a one-element array" do
+        it "is an empty array" do
+          %w(a).take(0).should == []
+        end
+
+        property("is an empty array") do
+          integer
+        end.check{|x| [x].take(0).should == [] }
+      end
+
+      context "from a two-element array" do
+        it "is an empty array" do
+          %w(a b).take(0).should == []
+        end
+
+        property("is an empty array") do
+          [integer, integer]
+        end.check{|x,y| [x,y].take(0).should == [] }
+      end
+    end
+
+    context "one element" do
+      context "from a one-element array" do
+        it "contains only the first element" do
+          %w(a).take(1).should == %w(a)
+        end
+
+        property("contains only the first element") do
+          integer
+        end.check{|x| [x].take(1).should == [x] }
+      end
+
+      context "from a two-element array" do
+        it "contains only the first element" do
+          %w(a b).take(1).should == %w(a)
+        end
+
+        property("contains only the first element") do
+          [integer, integer]
+        end.check{|x,y| [x,y].take(1).should == [x] }
+      end
+    end
+
+    context "two elements" do
+      context "from a one-element array" do
+        it "contains only the first element" do
+          %w(a).take(2).should == %w(a)
+        end
+
+        property("contains only the first element") do
+          integer
+        end.check{|x| [x].take(2).should == [x] }
+      end
+
+      context "from a two-element array" do
+        it "contains only both the elements" do
+          %w(a b).take(2).should == %w(a b)
+        end
+
+        property("contains only both the elements") do
+          [integer, integer]
+        end.check{|x,y| [x,y].take(2).should == [x,y] }
+      end
+    end
+  end
+
+  describe "#take_while" do
+    context "when predicate is always satisfied" do
+      it "is the original array" do
+        [1, 2, 3, 2, 1].take_while{|x| x >= 1 }.should == [1, 2, 3, 2, 1]
+      end
+
+      property("is the original array") do
+        mkarray(between(0, 10))
+      end.check do |as|
+        as.take_while { true }.should == as
+      end
+    end
+
+    context "when the first element does not satisfy the predicate" do
+      it "is the empty array" do
+        [1, 2, 3, 2, 1].take_while{|x| x <= 0 }.should == []
+      end
+
+      property("is the empty array") do
+        mkarray(between(1, 10))
+      end.check do |as|
+        as.take_while { false }.should == []
+      end
+    end
+
+    context "when the second element does not satisfy the predicate" do
+      it "contains only the first element" do
+        [1, 2, 3, 2, 1].take_while{|x| x <= 1 }.should == [1]
+      end
+
+      property("contains only the first element") do
+        mkarray(between(2, 10))
+      end.check do |as|
+        as.take_while{|x| x <= 1 }.should == as[0, 1]
+      end
+    end
+
+    context "when the third element does not satisfy the predicate" do
+      it "contains only the first two elements" do
+        [1, 2, 3, 2, 1].take_while{|x| x <= 2 }.should == [1, 2]
+      end
+
+      property("contains only the first two elements") do
+        mkarray(between(3, 10))
+      end.check do |as|
+        as.take_while {|x| x <= 2 }.should == as[0, 2]
+      end
+    end
+  end
+
+  describe "#take_until" do
+    pending
+  end
+
+  describe "#split_at" do
+    context "index zero" do
+      context "on an empty array" do
+        it "returns [], []" do
+          [].split_at(0).should == [[], []]
+        end
+      end
+
+      context "on a one-element array" do
+        it "returns [], [a]" do
+          %w(a).split_at(0).should == [[], %w(a)]
+        end
+      end
+
+      context "on a two-element array" do
+        it "returns [], [a, b]" do
+          %w(a b).split_at(0).should == [[], %w(a b)]
+        end
+      end
+    end
+
+    context "index one" do
+      context "at a negative index" do
+        property("is an error") do
+          integer.abs
+        end.check do |n|
+          lambda { [].split_at(-n) }.should raise_error
+        end
+      end
+
+      context "on an empty array" do
+        it "returns [], []" do
+          [].split_at(1).should == [[], []]
+        end
+      end
+
+      context "on a one-element array" do
+        it "returns [a], []" do
+          %w(a).split_at(1).should == [%w(a), []]
+        end
+      end
+
+      context "on a two-element array" do
+        it "returns [a], [b]" do
+          %w(a b).split_at(1).should == [%w(a), %w(b)]
+        end
+      end
+    end
+
+    context "index two" do
+      context "on an empty array" do
+        it "returns [], []" do
+          [].split_at(2).should == [[], []]
+        end
+      end
+
+      context "on a one-element array" do
+        it "returns [a], []" do
+          %w(a).split_at(2).should == [%w(a), []]
+        end
+      end
+
+      context "on a two-element array" do
+        it "returns [a, b], []" do
+          %w(a b).split_at(2).should == [%w(a b), []]
+        end
+      end
+    end
+
+    context "at a a non-negative index" do
+      property("is equal to [take(n), drop(n)]") do
+        with(:size, between(0, 25)) do
+          [array { integer }, integer.abs]
+        end
+      end.check do |as, n|
+        as.split_at(n).should == [as.take(n), as.drop(n)]
+      end
+    end
+  end
+
+  describe "#split_until" do
+    pending
+  end
+
+  describe "#split_when" do
+    pending
+  end
+
+end

data/spec/examples/ruby/blank.example

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+describe Object do
+  describe "#blank?" do
+    it "is false" do
+      Object.new.should_not be_blank
+    end
+  end
+end
+
+describe String do
+  describe "#blank?" do
+    context "if string contains non-whitespace characters" do
+      specify "then is string.blank? is false" do
+        "abc".should_not be_blank
+        "  x".should_not be_blank
+        " x ".should_not be_blank
+        "x  ".should_not be_blank
+      end
+    end
+
+    context "if string is #empty?" do
+      specify "then string.blank? is true" do
+        "".should be_blank
+      end
+    end
+
+    context "if string contains only whitespace characters" do
+      specify "then string.blank? is true" do
+        "  ".should be_blank
+        "\t".should be_blank
+        "\n".should be_blank
+        "\r".should be_blank
+        "\f".should be_blank
+      end
+    end
+  end
+end
+
+describe Enumerable do
+  describe "#blank?" do
+    context "if enum.empty?" do
+      specify "then enum.blank? is true" do
+        [].should be_blank
+      end
+    end
+
+    context "if not enum.empty?" do
+      specify "then enum.blank? is false" do
+        [0].should_not be_blank
+      end
+    end
+  end
+end
+
+describe NilClass do
+  describe "#blank?" do
+    it "is true" do
+      nil.should be_blank
+    end
+  end
+end

data/spec/examples/ruby/count.example

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+describe "Enumerable#count" do
+  include QuickCheck::Macro
+
+  context "with no given arguments" do
+    property("returns #length") do
+      with(:size, between(0, 20)) { array { integer }}
+    end.check do |enumerable|
+      enumerable.count.should == enumerable.length
+    end
+  end
+
+  context "with a given literal" do
+    let(:enumerable) { %w(a b a b c d a) }
+
+    it "returns the number of occurrences" do
+      enumerable.count("g").should == 0
+      enumerable.count("a").should == 3
+      enumerable.count("b").should == 2
+      enumerable.count("c").should == 1
+      enumerable.count("d").should == 1
+    end
+  end
+
+  context "with a given block argument" do
+    context "that always evaluates false" do
+      it "returns 0" do
+        %w(a b c d e f).count { false }.should == 0
+      end
+
+      property("returns 0") do
+        with(:size, between(0, 20)) { array { integer }}
+      end.check do |enumerable|
+        enumerable.count { false }.should == 0
+      end
+    end
+
+    context "that always evaluates true" do
+      it "returns #length" do
+        %w(a b c d e f).count { true }.should == 6
+      end
+
+      property("returns #length") do
+        with(:size, between(0, 20)) { array { integer }}
+      end.check do |enumerable|
+        enumerable.count { true }.should == enumerable.length
+      end
+    end
+
+    context "that evaluates true or false" do
+      it "returns the number of elements that satisfy the predicate" do
+        %w(a bc d ef g hi).count{|s| s.length == 2 }.should == 3
+      end
+
+      property("returns the number of elements that satisfy the predicate") do
+        divisor    = choose([1,2,3,4])
+        enumerable = with(:size, between(0, 20)) { array { integer }}
+
+        [enumerable, divisor]
+      end.check do |enumerable, divisor|
+        enumerable.count{|n| n.modulo(divisor).zero? }.should ==
+          enumerable.inject(0){|sum,n| sum + ((n.modulo(divisor).zero?) ? 1 : 0) }
+      end
+    end
+
+  end
+end

data/spec/examples/ruby/object.example

@@ -0,0 +1,99 @@
+require "spec_helper" do
+end
+
+describe "Object#cons" do
+  include QuickCheck::Macro
+
+  context "with no argument" do
+    it "creates a singleton list" do
+      0.cons.should == [0]
+    end
+  end
+
+  context "with an array argument" do
+    it "prepends the object" do
+      "a".cons(%w(b c d)).should == %w(a b c d)
+    end
+
+    property("prepends the object") do
+      [character, array { character }]
+    end.check do |a, as|
+      a.cons(as).length.should == 1 + as.length
+      a.cons(as).first.should  == a
+    end
+
+    it "does not destructively modify the argument" do
+      array = %w(b c d)
+        "a".cons(array)
+      array.should == %w(b c d)
+    end
+  end
+end
+
+describe "Object#snoc" do
+  context "with no argument" do
+    it "creates a singleton list" do
+      0.snoc.should == [0]
+    end
+  end
+
+  context "with an array argument" do
+    it "appends the object" do
+      "d".snoc(%w(a b c)).should == %w(a b c d)
+    end
+
+    it "does not destructively modify the argument" do
+      array = %w(a b c)
+        "d".snoc(array)
+      array.should == %w(a b c)
+    end
+  end
+end
+
+describe "Object#bind" do
+  it "provides an alternative syntax to local variables and parethesized expressions" do
+    (1.bind{|a| a + 2 } * 3).
+      should == ((1 + 2) * 3)
+  end
+
+  it "provides an alternative syntax to local variables and parethesized expressions" do
+    1.bind{|a| (a + 2).bind{|b| b * 3 }}.
+      should == ((1 + 2) * 3)
+  end
+
+  it "provides an alternative syntax to local variables and parethesized expressions" do
+    1.bind{|a| a.bind{|b| b + 2 }.bind{|c| c * 3 }}.
+      should == ((1 + 2) * 3)
+  end
+end
+
+describe "Object#tap" do
+  let(:object) { mock("object") }
+
+  it "requires a block argument" do
+    lambda { object.tap }.should raise_error(LocalJumpError)
+  end
+
+  it "yields the object to a block argument" do
+    object.should_receive(:message).with(:argument)
+    object.tap{|o| o.message(:argument) }
+  end
+
+  it "returns the object" do
+    object.tap { :whatever }.should eq(object)
+  end
+end
+
+describe "Object#eigenclass" do
+  let(:object) { mock("object") }
+
+  it "returns a Class" do
+    object.eigenclass.should be_a(Class)
+  end
+
+  it "cannot be instantiated" do
+    lambda { object.eigenclass.new }.should raise_error(TypeError)
+  end
+
+  specify { object.eigenclass.should == (class << object; self; end) }
+end