structx 0.1.0

data/test/ruby/2.0/test_struct.rb

@@ -0,0 +1,284 @@
+# -*- coding: us-ascii -*-
+require 'test/unit'
+require 'timeout'
+require_relative 'envutil'
+
+class TestStruct < Test::Unit::TestCase
+  def test_struct
+    struct_test = Struct.new("Test", :foo, :bar)
+    assert_equal(Struct::Test, struct_test)
+
+    test = struct_test.new(1, 2)
+    assert_equal(1, test.foo)
+    assert_equal(2, test.bar)
+    assert_equal(1, test[0])
+    assert_equal(2, test[1])
+
+    a, b = test.to_a
+    assert_equal(1, a)
+    assert_equal(2, b)
+
+    test[0] = 22
+    assert_equal(22, test.foo)
+
+    test.bar = 47
+    assert_equal(47, test.bar)
+  end
+
+  # [ruby-dev:26247] more than 10 struct members causes segmentation fault
+  def test_morethan10members
+    list = %w( a b c d  e f g h  i j k l  m n o p )
+    until list.empty?
+      c = Struct.new(* list.map {|ch| ch.intern }).new
+      list.each do |ch|
+        c.__send__(ch)
+      end
+      list.pop
+    end
+  end
+
+  def test_small_structs
+    names = [:a, :b, :c, :d]
+    1.upto(4) {|n|
+      fields = names[0, n]
+      klass = Struct.new(*fields)
+      o = klass.new(*(0...n).to_a)
+      fields.each_with_index {|name, i|
+        assert_equal(i, o[name])
+      }
+      o = klass.new(*(0...n).to_a.reverse)
+      fields.each_with_index {|name, i|
+        assert_equal(n-i-1, o[name])
+      }
+    }
+  end
+
+  def test_inherit
+    klass = Struct.new(:a)
+    klass2 = Class.new(klass)
+    o = klass2.new(1)
+    assert_equal(1, o.a)
+  end
+
+  def test_members
+    klass = Struct.new(:a)
+    o = klass.new(1)
+    assert_equal([:a], klass.members)
+    assert_equal([:a], o.members)
+  end
+
+  def test_ref
+    klass = Struct.new(:a)
+    o = klass.new(1)
+    assert_equal(1, o[:a])
+    assert_raise(NameError) { o[:b] }
+  end
+
+  def test_modify
+    klass = Struct.new(:a)
+    o = klass.new(1)
+    assert_raise(SecurityError) do
+      Thread.new do
+        $SAFE = 4
+        o.a = 2
+      end.value
+    end
+  end
+
+  def test_set
+    klass = Struct.new(:a)
+    o = klass.new(1)
+    o[:a] = 2
+    assert_equal(2, o[:a])
+    assert_raise(NameError) { o[:b] = 3 }
+  end
+
+  def test_struct_new
+    assert_raise(NameError) { Struct.new("foo") }
+    assert_nothing_raised { Struct.new("Foo") }
+    Struct.instance_eval { remove_const(:Foo) }
+    assert_nothing_raised { Struct.new(:a) { } }
+    assert_raise(RuntimeError) { Struct.new(:a) { raise } }
+
+    assert_equal([:utime, :stime, :cutime, :cstime], Process.times.members)
+  end
+
+  def test_initialize
+    klass = Struct.new(:a)
+    assert_raise(ArgumentError) { klass.new(1, 2) }
+  end
+
+  def test_each
+    klass = Struct.new(:a, :b)
+    o = klass.new(1, 2)
+    assert_equal([1, 2], o.each.to_a)
+  end
+
+  def test_each_pair
+    klass = Struct.new(:a, :b)
+    o = klass.new(1, 2)
+    assert_equal([[:a, 1], [:b, 2]], o.each_pair.to_a)
+    bug7382 = '[ruby-dev:46533]'
+    a = []
+    o.each_pair {|x| a << x}
+    assert_equal([[:a, 1], [:b, 2]], a, bug7382)
+  end
+
+  def test_inspect
+    klass = Struct.new(:a)
+    o = klass.new(1)
+    assert_equal("#<struct a=1>", o.inspect)
+    o.a = o
+    assert_match(/^#<struct a=#<struct #<.*?>:...>>$/, o.inspect)
+
+    Struct.new("Foo", :a)
+    o = Struct::Foo.new(1)
+    assert_equal("#<struct Struct::Foo a=1>", o.inspect)
+    Struct.instance_eval { remove_const(:Foo) }
+
+    klass = Struct.new(:a, :b)
+    o = klass.new(1, 2)
+    assert_equal("#<struct a=1, b=2>", o.inspect)
+
+    klass = Struct.new(:@a)
+    o = klass.new(1)
+    assert_equal("#<struct :@a=1>", o.inspect)
+  end
+
+  def test_init_copy
+    klass = Struct.new(:a)
+    o = klass.new(1)
+    assert_equal(o, o.dup)
+  end
+
+  def test_aref
+    klass = Struct.new(:a)
+    o = klass.new(1)
+    assert_equal(1, o[0])
+    assert_raise(IndexError) { o[-2] }
+    assert_raise(IndexError) { o[1] }
+  end
+
+  def test_aset
+    klass = Struct.new(:a)
+    o = klass.new(1)
+    o[0] = 2
+    assert_equal(2, o[:a])
+    assert_raise(IndexError) { o[-2] = 3 }
+    assert_raise(IndexError) { o[1] = 3 }
+  end
+
+  def test_values_at
+    klass = Struct.new(:a, :b, :c, :d, :e, :f)
+    o = klass.new(1, 2, 3, 4, 5, 6)
+    assert_equal([2, 4, 6], o.values_at(1, 3, 5))
+    assert_equal([2, 3, 4, 3, 4, 5], o.values_at(1..3, 2...5))
+  end
+
+  def test_select
+    klass = Struct.new(:a, :b, :c, :d, :e, :f)
+    o = klass.new(1, 2, 3, 4, 5, 6)
+    assert_equal([1, 3, 5], o.select {|v| v % 2 != 0 })
+    assert_raise(ArgumentError) { o.select(1) }
+  end
+
+  def test_equal
+    klass1 = Struct.new(:a)
+    klass2 = Struct.new(:a, :b)
+    o1 = klass1.new(1)
+    o2 = klass1.new(1)
+    o3 = klass2.new(1)
+    assert(o1.==(o2))
+    assert(o1 != o3)
+  end
+
+  def test_hash
+    klass = Struct.new(:a)
+    o = klass.new(1)
+    assert(o.hash.is_a?(Fixnum))
+  end
+
+  def test_eql
+    klass1 = Struct.new(:a)
+    klass2 = Struct.new(:a, :b)
+    o1 = klass1.new(1)
+    o2 = klass1.new(1)
+    o3 = klass2.new(1)
+    assert(o1.eql?(o2))
+    assert(!(o1.eql?(o3)))
+  end
+
+  def test_size
+    klass = Struct.new(:a)
+    o = klass.new(1)
+    assert_equal(1, o.size)
+  end
+
+  def test_error
+    assert_raise(TypeError){
+      Struct.new(0)
+    }
+  end
+
+  def test_nonascii
+    struct_test = Struct.new("R\u{e9}sum\u{e9}", :"r\u{e9}sum\u{e9}")
+    assert_equal(Struct.const_get("R\u{e9}sum\u{e9}"), struct_test, '[ruby-core:24849]')
+    a = struct_test.new(42)
+    assert_equal("#<struct Struct::R\u{e9}sum\u{e9} r\u{e9}sum\u{e9}=42>", a.inspect, '[ruby-core:24849]')
+  end
+
+  def test_junk
+    struct_test = Struct.new("Foo", "a\000")
+    o = struct_test.new(1)
+    assert_equal(1, o.send("a\000"))
+    Struct.instance_eval { remove_const(:Foo) }
+  end
+
+  def test_comparison_when_recursive
+    klass1 = Struct.new(:a, :b, :c)
+
+    x = klass1.new(1, 2, nil); x.c = x
+    y = klass1.new(1, 2, nil); y.c = y
+    Timeout.timeout(1) {
+      assert x == y
+      assert x.eql? y
+    }
+
+    z = klass1.new(:something, :other, nil); z.c = z
+    Timeout.timeout(1) {
+      assert x != z
+      assert !x.eql?(z)
+    }
+
+    x.c = y; y.c = x
+    Timeout.timeout(1) {
+      assert x == y
+      assert x.eql?(y)
+    }
+
+    x.c = z; z.c = x
+    Timeout.timeout(1) {
+      assert x != z
+      assert !x.eql?(z)
+    }
+  end
+
+  def test_struct_subclass
+    bug5036 = '[ruby-dev:44122]'
+    st = Class.new(Struct)
+    s = st.new("S", :m).new
+    error = assert_raise(SecurityError) do
+      proc do
+        $SAFE = 4
+        s.m = 1
+      end.call
+    end
+    assert_equal("Insecure: can't modify #{st}::S", error.message, bug5036)
+  end
+
+  def test_to_h
+    klass = Struct.new(:a, :b, :c, :d, :e, :f)
+    o = klass.new(1, 2, 3, 4, 5, 6)
+    assert_equal({a:1, b:2, c:3, d:4, e:5, f:6}, o.to_h)
+  end
+end

data/test/run.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+bundle exec bacon -rsimplecov -I lib test/spec_*.rb
+BACON=$?
+
+bundle exec ruby -I lib test/compatibility-test.rb
+COMPAT=$?
+
+if [ ${BACON} -ne 0 ] || [ ${COMPAT} -ne 0 ]
+then
+    exit 1
+fi

data/test/spec_structx.rb

@@ -0,0 +1,193 @@
+require "structx"
+
+class A < StructX
+  member :x
+  member :y, default: 10
+  member :z, type: Integer, default: 100
+end
+
+describe "StructX" do
+  describe "StructX.new(:x, :y, :z)" do
+    before do
+      @class = StructX.new(:x, :y, :z)
+    end
+
+    it "should have 3 members" do
+      @class.members.size.should == 3
+    end
+
+    it "should create from StructX subclass" do
+      should.not.raise do
+        Class.new(StructX).new(:x).new(1)
+      end
+    end
+
+    it "should inherit members" do
+      Class.new(@class).members.should == [:x, :y, :z]
+    end
+
+    it "should create an instance" do
+      @class.new(1, 2, 3).tap do |obj|
+        obj.x.should == 1
+        obj.y.should == 2
+        obj.z.should == 3
+      end
+    end
+
+    it "should create an instance with key" do
+      @class.new(x: 1, y: 2, z: 3).tap do |obj|
+        obj.x.should == 1
+        obj.y.should == 2
+        obj.z.should == 3
+      end
+    end
+
+    it "should get members" do
+      @class.members.tap do |m|
+        m.should.include(:x)
+        m.should.include(:y)
+        m.should.include(:z)
+      end
+    end
+
+    it "should raise ArgumentError when number of values are greater than number of members" do
+      should.raise(ArgumentError) do
+        @class.new(1, 2, 3, 4)
+      end
+    end
+
+    it "should create an instance with #[]" do
+      @class[1, 2, 3].tap do |obj|
+        obj.x.should == 1
+        obj.y.should == 2
+        obj.z.should == 3
+      end
+    end
+
+    it "should equal" do
+      @class.new(1, 2, 3).should == @class.new(1, 2, 3)
+    end
+
+    it "should write and get member's value" do
+      @class.new(1, 2, 3).tap do |obj|
+        obj.x = 2
+        obj.y = 3
+        obj.z = 4
+        obj.x.should == 2
+        obj.y.should == 3
+        obj.z.should == 4
+      end
+    end
+
+    it "should get member's value with index" do
+      @class.new(1, 2, 3).tap do |x|
+        x[0].should == 1
+        x[1].should == 2
+        x[2].should == 3
+        should.raise(IndexError) { x[-4] }
+        should.raise(IndexError) { x[3] }
+        x[:x].should == 1
+        x[:y].should == 2
+        x[:z].should == 3
+        should.raise(NameError) { x[:a] }
+      end
+    end
+
+    it "should set member's value with index" do
+      @class.new(1, 2, 3).tap do |x|
+        x[0] = 2
+        x[1] = 3
+        x[2] = 4
+        x[0].should == 2
+        x[1].should == 3
+        x[2].should == 4
+        should.raise(IndexError) { x[-4] = 1 }
+        should.raise(IndexError) { x[3] = 1 }
+        x[:x] = 3
+        x[:y] = 4
+        x[:z] = 5
+        x[:x].should == 3
+        x[:y].should == 4
+        x[:z].should == 5
+        should.raise(NameError) { x[:a] = 1}
+      end
+    end
+
+    it "should iterate values" do
+      vals = []
+      @class.new(1, 2, 3).tap{|x| x.each {|val| vals << val}; vals.should == x.values}
+    end
+
+    it "should iterate pairs of key and value" do
+      vals = []
+      @class.new(1, 2, 3).tap{|x| x.each_pair {|k, v| vals << [k, v]}; vals.should == x.to_h.to_a}
+    end
+
+    it "should get size" do
+      @class.new(1, 2, 3).size.should == 3
+    end
+
+    it "should get members as strings" do
+      @class.new.members.should == [:x, :y, :z]
+    end
+
+    it "should select" do
+      @class.new(1, 2, 3).select{|i| i.odd?}.should == [1, 3]
+    end
+
+    it "should get values" do
+      @class.new(1, 2, 3).values.should == [1, 2, 3]
+    end
+
+    it "should get values at" do
+      @class.new(1, 2, 3).values_at(0..1).should == [1, 2]
+    end
+  end
+
+  StructX.new("TestName", :x, :y)
+
+  describe 'StructX.new("TestName", :x, :y)' do
+    it "should have 2 members" do
+      StructX::TestName.members.size.should == 2
+    end
+
+    it "should create class" do
+      should.not.raise {StructX::TestName}
+    end
+
+    it "should get values" do
+      StructX::TestName.new(1, 2).tap do |obj|
+        obj.x.should == 1
+        obj.y.should == 2
+      end
+    end
+  end
+
+  describe "A < StructX" do
+    it "should have 3 members" do
+      A.members.size.should == 3
+    end
+
+    it "should get members" do
+      A.new(x: 1, y: 2, z: 3).tap do |obj|
+        obj.x.should == 1
+        obj.y.should == 2
+        obj.z.should == 3
+      end
+    end
+
+    it "should get default value" do
+      A.new(1).tap do |obj|
+        obj.x.should == 1
+        obj.y.should == 10
+        obj.z.should == 100
+      end
+      A.new.tap do |obj|
+        obj.x.should == nil
+        obj.y.should == 10
+        obj.z.should == 100
+      end
+    end
+  end
+end
+