ffi-struct_ex 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4092e8230ac37c9885fe7fa0103252632d8aff4c
-  data.tar.gz: b7585d0ea88c05cec20c3cac0939fbecf54fd114
+  metadata.gz: 56f6bae584293791faa95b89f433bc4c507f102f
+  data.tar.gz: 85b5c35bb1e4b3856f27471afe5a28b70d788fb4
 SHA512:
-  metadata.gz: b90c7ec9a5a6e5d2fdcb84346a19c9882de73a601d9cb35d6e18c05455648f6e700c92a61ea2ca2007659c3fe830b031a3a4408111fd1c7a26e79c8c75c1f1b4
-  data.tar.gz: b2077caf64d8b31265a2b30ec2c72690181ac5cb1f5be710a56888a7f75a546eaa853be20be7cce7c5c8b7fd2e2edc60eda30e6b78c867dd7f436f728fb6d905
+  metadata.gz: f16a542162f3f97513d5abf8a147beae7f0c17106f68c2ea4327098c72b44ab290ff0950c10601abb6097d02280ec30760a4c82c7f9048b2b491bbdff2b768af
+  data.tar.gz: c9f4858659612519aece832f58cbcbd708a7596d0688016ee46be9646308fc22b88dad18bc58fcb92692499611251e05bc6469b2b35921a8e98268759c6e33dc

data/.gitignore

@@ -1,17 +1,18 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.project
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/README.md

@@ -38,13 +38,13 @@ subject[:bits_0_2] #=> 1
 subject[:bits_5_7] #=> -4
 ```
 
-* Struct (embedded bit fields)
+* Struct (embedded struct)
 
 ```ruby
 require 'ffi/struct_ex'
 
 class Subject < FFI::StructEx
-  layout :field_0, bit_fields(:bits_0_2, 3,
+  layout :field_0, struct_ex(:bits_0_2, 3,
                               :bit_3,    1,
                               :bit_4,    1,
                               :bits_5_7, 3),
@@ -56,19 +56,17 @@ end
 subject[:field_0].class.superclass #=> FFI::StructEx
 
 subject[:field_0] = 0b0110_1001
-subject[:field_0].read #=> 0b0110_1001
+subject[:field_0].pointer.read_uint8 #=> 0b0110_1001
 
 subject[:field_0][:bits_0_2] = 0b101
 subject[:field_0][:bits_0_2] #=> 0b101
-subject[:field_0].read #=> 0b0110_1101
+subject[:field_0].pointer.read_uint8 #=> 0b0110_1101
 
 subject[:field_0] = {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011}
-subject[:field_0].read #=> 0b0110_1001
+subject[:field_0].pointer.read_uint8 #=> 0b0110_1001
 
 #Equality check
 subject[:field_0] == {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011} #=> true
-subject[:field_0] == 0b0110_1001 #=> true
-subject[:field_0] == '0b0110_1001' #=> true
 ```
 
 ## Contributing

data/Rakefile

@@ -1,8 +1,8 @@
 require 'rubygems'
 require 'bundler/setup'
 require "bundler/gem_tasks"
-require 'rake/testtask'
+require 'rspec/core/rake_task'
 
-Rake::TestTask.new do |t|
-  t.libs << 'lib' << 'test'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.ruby_opts = "-w -I\"#{['lib', 'spec'].join(File::PATH_SEPARATOR)}\""
 end

data/ffi-struct_ex.gemspec

@@ -22,4 +22,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rspec'
+
 end

data/lib/ffi/struct_ex/version.rb

@@ -1,5 +1,5 @@
 module Ffi
   module StructEx
-    VERSION = "0.1.1"
+    VERSION = "0.1.2"
   end
 end

data/spec/ffi/struct_ex_spec.rb

@@ -0,0 +1,328 @@
+require 'ffi/spec_helper'
+require 'ffi/struct_ex/struct_ex'
+
+
+describe FFI::StructEx do
+  describe "#size and #alignment" do
+    def test_size_and_alignment(specs, size, alignment)
+      klass = Class.new(described_class) do
+        layout(*specs)
+      end
+
+      klass.size.should == size
+      klass.alignment.should == alignment
+    end
+
+    it "should work by declaring ffi type" do
+      test_size_and_alignment([:f0, :short,
+                               :f1, :char,
+                               :f2, :char], 4, 2)
+
+      test_size_and_alignment([:f0, :short,
+                               :f1, :char], 4, 2)
+    end
+
+    it "should work by only declaring bit field with default type" do
+      test_size_and_alignment([:f0, 31,
+                               :f1, 31], 8, 4)
+
+      test_size_and_alignment([:f0, 8,
+                               :f1, 16], 4, 2)
+      test_size_and_alignment([:f0, 16,
+                               :f1, 8], 4, 2)
+
+      test_size_and_alignment([:f0, 1,
+                               :f1, 16,
+                               :f2, 1], 6, 2)
+    end
+
+    it "should work by declaring bit field with descriptors and offset" do
+      test_size_and_alignment([:f0, 31, {'1st' => 0xff},
+                               :f1, 31], 8, 4)
+
+      test_size_and_alignment([:f0, 8, {'1st' => 0xff},
+                               :f1, :short, 4, {'1st' => 0xff}], 6, 2)
+    end
+
+    it "should work by only declaring bit field with explicit type" do
+      test_size_and_alignment([:f0, 'uint8: 1'], 1, 1)
+      test_size_and_alignment([:f0, 'uint16: 1'], 2, 2)
+      test_size_and_alignment([:f0, 'uint32: 1'], 4, 4)
+
+      test_size_and_alignment([:f0, 'uint16: 3',
+                               :f1, 'uint16: 1',
+                               :f2, 'uint16: 1',
+                               :f3, 'uint16: 3',
+                               :f4, 'uint16: 8'], 2, 2)
+
+      test_size_and_alignment([:f0, 'uint8: 1',
+                               :f1, 'uint8: 1'], 1, 1)
+
+      test_size_and_alignment([:f0, 'uint8: 1',
+                               :f1, 'int8: 1'], 1, 1)
+
+      test_size_and_alignment([:f0, 'uint8: 1',
+                               :f1, 'uint32: 1'], 8, 4)
+      test_size_and_alignment([:f0, 'uint32: 1',
+                               :f1, 'uint8: 1'], 8, 4)
+    end
+
+    it "should work by declaring bit field and ffi type" do
+      test_size_and_alignment([:f0, 31,
+                               :f1, :uint8], 8, 4)
+
+      test_size_and_alignment([:f0, 1,
+                               :f1, :uint32], 8, 4)
+
+      test_size_and_alignment([:f0, 4,
+                               :f1, 4,
+                               :f2, 8,
+                               :f3, :uint8], 3, 1)
+
+      test_size_and_alignment([:f0, 1,
+                               :f1, 1,
+                               :f2, :uint8], 2, 1)
+
+      test_size_and_alignment([:f0, 1,
+                               :f1, 1,
+                               :f2, :uint8,
+                               :f3, 1,
+                               :f4, 1], 3, 1)
+
+      test_size_and_alignment([:f0, 1,
+                               :f1, 1,
+                               :f2, :uint16,
+                               :f3, 1,
+                               :f4, 1], 6, 2)
+
+      test_size_and_alignment([:f0, 1,
+                               :f1, 1,
+                               :f2, :uint16,
+                               :f3, 1,
+                               :f4, 8], 6, 2)
+
+      test_size_and_alignment([:f0, 'uint32: 1',
+                               :f1, :uint16], 8, 4)
+
+      test_size_and_alignment([:f0, 'uint8: 1',
+                               :f1, :uint32], 8, 4)
+
+      test_size_and_alignment([:f0, :short,
+                               :f1, 'char: 1'], 4, 2)
+
+      test_size_and_alignment([:f0, :char,
+                               :f1, 'short: 1'], 4, 2)
+    end
+
+    it "should work by declaring bit field with typedefed type and ffi type" do
+      FFI.typedef :uint8, :UINT8
+      test_size_and_alignment([:f0, 'UINT8: 8',
+                               :f1, 'int: 1'], 8, 4)
+    end
+  end
+
+  describe "#==" do
+    context "when given embedded struct" do
+      let(:hash) { {f0: {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011}, f1: 0x1} }
+
+      subject {
+        Class.new(described_class) do
+          layout :f0, struct_ex(:bits_0_2, 3,
+                                     :bit_3,    1,
+                                     :bit_4,    1,
+                                     :bits_5_7, 3),
+                 :f1, :uint8
+        end.new(hash)
+      }
+
+      it "should equal to hash" do
+        subject.should == hash
+        subject[:f0].to_ptr.read_uint8.should == 0b0110_1001
+        subject[:f1].should == hash[:f1]
+      end
+    end
+  end
+
+  describe "#initialize" do
+    let(:klass) {
+      Class.new(described_class) do
+        layout :f0, struct_ex(:bits_0_2, 3,
+                              :bit_3,    1,
+                              :bit_4,    1,
+                              :bits_5_7, 3),
+               :f1, :uint8
+      end
+    }
+
+    context "when given empty parameters" do
+      subject { klass.new }
+
+      it "should be initialized as 0" do
+        subject[:f0].pointer.read_uint8.should == 0
+        subject[:f1].should == 0
+      end
+    end
+
+    context "when given hash" do
+      let(:hash) { {f0: {bits_0_2: 0b111, bit_3: 0b0, bit_4: 0b0, bits_5_7: 0b101}, f1: 0x12} }
+      subject { klass.new(hash) }
+
+      it "should be initialized as hash" do
+        subject.should == hash
+        subject[:f0].should == hash[:f0]
+        subject[:f0].pointer.read_uint8.should == 0b101_0_0_111
+        subject[:f1].should == hash[:f1]
+      end
+    end
+  end
+
+  describe "#[]" do
+    context "when given signed integer type" do
+      let(:klass) {
+        Class.new(FFI::StructEx) do
+          layout :f0, 'uint8: 3',
+                 :f1, 'char: 1',
+                 :f2, 'uint8: 1',
+                 :f3, 'char: 3'
+        end
+      }
+
+      subject { klass.new(f0: 0b001, f1: 0b1, f2: 0b1, f3: 0b100) }
+
+      it "should be read as signed integer" do
+        subject[:f0].should == 1
+        subject[:f1].should == -1
+        subject[:f2].should == 1
+        subject[:f3].should == -4
+
+        subject[:f3] = 0b010
+        subject[:f3].should == 2
+
+        subject[:f3] = 0
+        subject[:f3].should == 0
+
+        subject[:f3] = 0b110
+        subject[:f3].should == -2
+      end
+    end
+  end
+
+  describe "#[]=" do
+    context "when given ffi type struct with textual descriptors" do
+      let(:klass) {
+        Class.new(FFI::StructEx) do
+          layout :f0, :uint8, {'all_1' => 0xff, 'all_0' => 0x00},
+                 :f1, :uint8, {3 => 1}
+        end
+      }
+
+      subject { klass.new(f0: 'all_1', f1: 0x12) }
+
+      it "should be written with textual descriptor" do
+        subject[:f0].should == 0xff
+        subject[:f1].should == 0x12
+
+        subject[:f0] = 'all_0'
+        subject[:f0].should == 0x00
+
+        subject[:f0] = 0x12
+        subject[:f0].should == 0x12
+
+        subject[:f1] = 3
+        subject[:f1].should == 1
+      end
+    end
+
+    context "when given bit field type struct with textual descriptors" do
+      let(:klass) {
+        Class.new(FFI::StructEx) do
+          layout :f0, 3, {'all_1' => 0b111, 'all_0' => 0b000},
+                 :f1, 1, {'yes' => 0b1, 'no' => 0b0},
+                 :f2, 1,
+                 :f3, :uint8
+        end
+      }
+
+      subject { klass.new(f0: 'all_1', f1: 'yes') }
+
+      it "should be written with textual descriptor" do
+        subject[:f0].should == 0b111
+        subject[:f1].should == 0b1
+        subject[:f2].should == 0
+        subject[:f3].should == 0
+
+        subject[:f0] = 'all_0'
+        subject[:f0].should == 0x00
+
+        subject[:f0] = 0b010
+        subject[:f0].should == 0b010
+
+        subject[:f1] = 'no'
+        subject[:f1].should == 0
+
+        subject[:f1] = 1
+        subject[:f1].should == 1
+      end
+    end
+
+    context "when given embedded struct" do
+      let(:klass) {
+        Class.new(FFI::StructEx) do
+          layout :f0, struct_ex(:bits_0_2, 'uint16: 3',
+                                :bit_3,    'uint16: 1',
+                                :bit_4,    'uint16: 1',
+                                :bits_5_7, 'uint16: 3',
+                                :bits_8_15, :uint8),
+                 :f1, :uint8,
+                 :f2, :uint8,
+                 :f3, :uint8
+        end
+      }
+
+      subject { klass.new }
+
+      it "should be written for embeded field" do
+        klass.offset_of(:f1).should == 4
+
+        subject[:f0].class.superclass.should == FFI::StructEx
+        subject[:f0].size.should == 4
+        subject[:f0].alignment.should == 2
+
+        subject[:f0].to_ptr.write_uint16(0b0110_1001)
+        subject[:f0].to_ptr.read_uint16.should == 0b0110_1001
+        subject[:f0][:bits_0_2].should == 0b001
+
+        subject[:f0][:bits_0_2] = 0b101
+        subject[:f0][:bits_0_2].should == 0b101
+        subject[:f0].to_ptr.read_uint16.should == 0b0110_1101
+
+        subject[:f0] = {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011}
+        subject[:f0].to_ptr.read_uint16.should == 0b0110_1001
+        subject[:f0][:bits_0_2].should == 0b001
+      end
+    end
+  end
+
+  describe "#pointer.write" do
+    let(:klass) {
+      Class.new(FFI::StructEx) do
+        layout :f0, 3,
+               :f1, 1,
+               :f2, 1,
+               :f3, 3
+      end
+    }
+
+    subject { klass.new }
+
+    it "should write" do
+      subject.pointer.write_uint8(0b0110_1001)
+
+      subject[:f0].should == 0b001
+      subject[:f1].should == 0b1
+      subject[:f2].should == 0b0
+      subject[:f3].should == 0b011
+    end
+  end
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi-struct_ex
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Ruijia Li
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-26 00:00:00.000000000 Z
+date: 2014-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -52,6 +52,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A module to add extra functionalities to FFI::Struct
 email:
 - ruijia.li@gmail.com
@@ -61,7 +75,6 @@ extra_rdoc_files: []
 files:
 - .gitattributes
 - .gitignore
-- .project
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -70,8 +83,8 @@ files:
 - lib/ffi/struct_ex.rb
 - lib/ffi/struct_ex/struct_ex.rb
 - lib/ffi/struct_ex/version.rb
-- test/test_helper.rb
-- test/test_struct_ex.rb
+- spec/ffi/spec_helper.rb
+- spec/ffi/struct_ex_spec.rb
 homepage: https://github.com/rli9/ffi-struct_ex
 licenses:
 - MIT
@@ -97,5 +110,5 @@ signing_key:
 specification_version: 4
 summary: A module to add extra functionalities to FFI::Struct
 test_files:
-- test/test_helper.rb
-- test/test_struct_ex.rb
+- spec/ffi/spec_helper.rb
+- spec/ffi/struct_ex_spec.rb

data/.project

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>ffi-struct_ex</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>com.aptana.ide.core.unifiedBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>com.aptana.ruby.core.rubynature</nature>
-		<nature>com.aptana.projects.webnature</nature>
-	</natures>
-</projectDescription>

data/test/test_helper.rb

@@ -1 +0,0 @@
-

data/test/test_struct_ex.rb

@@ -1,348 +0,0 @@
-require 'test_helper'
-require 'test/unit'
-require 'ffi/struct_ex'
-
-class TestStructEx < Test::Unit::TestCase
-  def test_struct_ex
-    subject_class = Class.new(FFI::StructEx) do
-      layout :field_0, struct_ex(:bits_0_2, 'uint16: 3',
-                                  :bit_3,    'uint16: 1',
-                                  :bit_4,    'uint16: 1',
-                                  :bits_5_7, 'uint16: 3',
-                                  :bits_8_15, :uint8),
-             :field_1, :uint8,
-             :field_2, :uint8,
-             :field_3, :uint8
-    end
-
-    assert_equal(8, subject_class.size)
-    assert_equal(2, subject_class.alignment)
-    assert_equal(4, subject_class.offset_of(:field_1))
-
-    subject = subject_class.new
-
-    assert_equal(FFI::StructEx, subject[:field_0].class.superclass)
-    assert_equal(4, subject[:field_0].size)
-    assert_equal(2, subject[:field_0].alignment)
-
-    subject[:field_0].to_ptr.write_uint16(0b0110_1001)
-    assert_equal(0b0110_1001, subject[:field_0].to_ptr.read_uint16)
-    assert_equal(0b001, subject[:field_0][:bits_0_2])
-
-    subject[:field_0][:bits_0_2] = 0b101
-    assert_equal(0b101, subject[:field_0][:bits_0_2])
-    assert_equal(0b0110_1101, subject[:field_0].to_ptr.read_uint16)
-
-    subject[:field_0] = {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011}
-    assert_equal(0b0110_1001, subject[:field_0].to_ptr.read_uint16)
-    assert_equal(0b001, subject[:field_0][:bits_0_2])
-
-    assert_equal(subject[:field_0], {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011, bits_8_15: 0b0})
-    assert_equal(subject[:field_0].to_ptr.read_uint16, 0b0110_1001)
-
-    subject[:field_1] = 1
-    subject[:field_2] = 2
-    subject[:field_3] = 3
-    assert_equal(subject, {field_0: {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011, bits_8_15: 0b0}, field_1: 1, field_2: 2, field_3: 3})
-
-    subject[:field_0] = subject[:field_0].class.new(bits_0_2: 0b111, bit_3: 0b0, bit_4: 0b0, bits_5_7: 0b101, bits_8_15: 0b10011100)
-    assert_equal(subject[:field_0].to_ptr.read_uint32, 0b10011100_00000000_10100111)
-  end
-
-  def test_pure_struct_ex
-    subject_class = Class.new(FFI::StructEx) do
-      layout :bits_0_2, 3,
-             :bit_3,    1,
-             :bit_4,    1,
-             :bits_5_7, 3
-    end
-
-    assert_equal(1, subject_class.size)
-    assert_equal(1, subject_class.alignment)
-
-    subject = subject_class.new
-
-    subject[:bits_0_2] = 0b101
-    assert_equal(0b101, subject[:bits_0_2])
-
-    subject[:bit_3] = 0b1
-    assert_equal(0b1, subject[:bit_3])
-    assert_equal(0b101, subject[:bits_0_2])
-
-    subject = subject_class.new
-    subject.to_ptr.write_uint8(0b0110_1001)
-    assert_equal(0b001, subject[:bits_0_2])
-    assert_equal(0b1, subject[:bit_3])
-    assert_equal(0b0, subject[:bit_4])
-    assert_equal(0b011, subject[:bits_5_7])
-
-    subject = subject_class.new(bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011)
-    assert_equal(0b001, subject[:bits_0_2])
-    assert_equal(0b1, subject[:bit_3])
-    assert_equal(0b0, subject[:bit_4])
-    assert_equal(0b011, subject[:bits_5_7])
-    assert_equal(0b0110_1001, subject.to_ptr.read_uint8)
-  end
-
-  def test_interpreted_struct_ex
-    subject_class = Class.new(FFI::StructEx) do
-      layout :bits_0_2, 3, {'all_1' => 0b111, 'all_0' => 0b000},
-             :bit_3,    1, {'yes' => 0b1, 'no' => 0b0},
-             :bit_4,    1,
-             :bits_5_7, 3
-    end
-
-    subject = subject_class.new(bits_0_2: 'all_1', bit_3: 'yes')
-    assert_equal(0b111, subject[:bits_0_2])
-    assert_equal(0b1, subject[:bit_3])
-    assert_equal(0b0, subject[:bit_4])
-    assert_equal(0b0, subject[:bits_5_7])
-
-    subject[:bits_0_2] = 'all_0'
-    assert_equal(0b000, subject[:bits_0_2])
-
-    subject[:bits_0_2] = 0b010
-    assert_equal(0b010, subject[:bits_0_2])
-
-    subject[:bit_3] = 'no'
-    assert_equal(0b0, subject[:bit_3])
-
-    subject[:bit_3] = 1
-    assert_equal(0b1, subject[:bit_3])
-  end
-
-  def test_equality
-    subject_class = Class.new(FFI::StructEx) do
-      layout :field_0, struct_ex(:bits_0_2, 3,
-                                  :bit_3,    1,
-                                  :bit_4,    1,
-                                  :bits_5_7, 3),
-             :field_1, :uint8
-    end
-
-    subject = subject_class.new(field_0: {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011}, field_1: 0x1)
-
-    assert_equal(FFI::StructEx, subject[:field_0].class.superclass)
-    assert_equal(1, subject[:field_0].size)
-    assert_equal(0b0110_1001, subject[:field_0].to_ptr.read_uint8)
-    assert_equal(subject[:field_1], subject.map_field_value(:field_1, '0x1'))
-  end
-
-  def test_descriptors
-    subject_class = Class.new(FFI::StructEx) do
-      layout :field_0, :uint8, {'all_1' => 0xff, 'all_0' => 0x00},
-             :field_1, :uint8, {3 => 1}
-    end
-
-    assert_equal(2, subject_class.size)
-    assert_equal(1, subject_class.alignment)
-    assert_equal(1, subject_class.offset_of(:field_1))
-
-    subject = subject_class.new(field_0: 'all_1', field_1: 0x12)
-
-    assert_equal(0xff, subject[:field_0])
-    assert_equal(0x12, subject[:field_1])
-
-    subject[:field_0] = 'all_0'
-    assert_equal(0x00, subject[:field_0])
-
-    subject[:field_0] = 0x12
-    assert_equal(0x12, subject[:field_0])
-
-    subject[:field_1] = 3
-    assert_equal(0x1, subject[:field_1])
-  end
-
-  def test_initialized_memory_should_be_zero
-    subject_class = Class.new(FFI::StructEx) do
-      layout :field_0, struct_ex(:bits_0_2, 3,
-                                  :bit_3,    1,
-                                  :bit_4,    1,
-                                  :bits_5_7, 3),
-             :field_1, :uint8
-    end
-
-    subject = subject_class.new
-
-    assert_equal(0x00, subject[:field_0].to_ptr.read_uint8)
-    assert_equal(0x00, subject[:field_1])
-  end
-
-  def test_sizeof
-    assert_equal(4, Class.new(FFI::StructEx) do
-                      layout :field_0, :short,
-                             :field_1, :char,
-                             :field_2, :char
-                    end.size)
-
-    assert_equal(8, Class.new(FFI::StructEx) do
-                      layout :field_0, 31,
-                             :field_1, 31
-                    end.size)
-
-    assert_equal(8, Class.new(FFI::StructEx) do
-                      layout :field_0, 31,
-                             :field_1, :uint8
-                    end.size)
-
-    assert_equal(8, Class.new(FFI::StructEx) do
-                      layout :field_0, 1,
-                             :field_1, :uint32
-                    end.size)
-
-    assert_equal(3, Class.new(FFI::StructEx) do
-                      layout :field_0, 4,
-                             :field_1, 4,
-                             :field_2, 8,
-                             :field_3, :uint8
-                    end.size)
-
-    assert_equal(2, Class.new(FFI::StructEx) do
-                      layout :field_0, 1,
-                             :field_1, 1,
-                             :field_2, :uint8
-                    end.size)
-
-    assert_equal(3, Class.new(FFI::StructEx) do
-                      layout :field_0, 1,
-                             :field_1, 1,
-                             :field_2, :uint8,
-                             :field_3, 1,
-                             :field_4, 1
-                    end.size)
-
-    assert_equal(6, Class.new(FFI::StructEx) do
-                      layout :field_0, 1,
-                             :field_1, 1,
-                             :field_2, :uint16,
-                             :field_3, 1,
-                             :field_4, 1
-                    end.size)
-
-    assert_equal(6, Class.new(FFI::StructEx) do
-                      layout :field_0, 1,
-                             :field_1, 1,
-                             :field_2, :uint16,
-                             :field_3, 1,
-                             :field_4, 8
-                    end.size)
-
-    assert_equal(4, Class.new(FFI::StructEx) do
-                      layout :field_0, 8,
-                             :field_1, 16
-                    end.size)
-
-    assert_equal(4, Class.new(FFI::StructEx) do
-                      layout :field_0, 16,
-                             :field_1, 8
-                    end.size)
-
-    assert_equal(6, Class.new(FFI::StructEx) do
-                      layout :field_0, 1,
-                             :field_1, 16,
-                             :field_2, 1
-                    end.size)
-
-    assert_equal(1, Class.new(FFI::StructEx) do
-                      layout :field_0, 'uint8: 1'
-                    end.size)
-
-    assert_equal(2, Class.new(FFI::StructEx) do
-                      layout :field_0, 'uint16: 1'
-                    end.size)
-
-    assert_equal(4, Class.new(FFI::StructEx) do
-                      layout :field_0, 'uint32: 1'
-                    end.size)
-
-    assert_equal(2, Class.new(FFI::StructEx) do
-                      layout :bits_0_2, 'uint16: 3',
-                             :bit_3,    'uint16: 1',
-                             :bit_4,    'uint16: 1',
-                             :bits_5_7, 'uint16: 3',
-                             :bits_8_15, 'uint16: 8'
-                    end.size)
-
-    assert_equal(1, Class.new(FFI::StructEx) do
-                      layout :field_0, 'uint8: 1',
-                             :field_1, 'uint8: 1'
-                    end.size)
-
-    assert_equal(1, Class.new(FFI::StructEx) do
-                      layout :field_0, 'uint8: 1',
-                             :field_1, 'int8: 1'
-                    end.size)
-
-    assert_equal(8, Class.new(FFI::StructEx) do
-                      layout :field_0, 'uint32: 1',
-                             :field_1, :uint16
-                    end.size)
-
-    assert_equal(8, Class.new(FFI::StructEx) do
-                      layout :field_0, 'uint8: 1',
-                             :field_1, :uint32
-                    end.size)
-
-    assert_equal(8, Class.new(FFI::StructEx) do
-                      layout :field_0, 'uint8: 1',
-                             :field_1, 'uint32: 1'
-                    end.size)
-
-    assert_equal(4, Class.new(FFI::StructEx) do
-                      layout :field_0, :short,
-                             :field_1, :char
-                    end.size)
-
-    assert_equal(4, Class.new(FFI::StructEx) do
-                      layout :field_0, :short,
-                             :field_1, 'char: 1'
-                    end.size)
-
-    subject_class = Class.new(FFI::StructEx) do
-                      layout :field_0, :char,
-                             :field_1, 'short: 1'
-                    end
-    assert_equal(4, subject_class.size)
-
-    subject_class = Class.new(FFI::StructEx) do
-                      layout :field_0, 'uint: 8',
-                             :field_1, 'int: 1'
-                    end
-    assert_equal(4, subject_class.size)
-    subject = subject_class.new
-    subject[:field_0] = 0b0110_1001
-    assert_equal(0b0110_1001, subject[:field_0])
-    subject[:field_0] = 0b1111_1111
-    assert_equal(0b1111_1111, subject[:field_0])
-
-    subject[:field_1] = 1
-    assert_equal(-1, subject[:field_1])
-    subject[:field_1] = 0
-    assert_equal(0, subject[:field_1])
-    subject[:field_1] = -1
-    assert_equal(-1, subject[:field_1])
-
-    #Check no impact for typedef type
-    FFI.typedef :uint8, :UINT8
-    subject_class = Class.new(FFI::StructEx) do
-                      layout :field_0, 'UINT8: 8',
-                             :field_1, 'int: 1'
-                    end
-
-    subject_class = Class.new(FFI::StructEx) do
-      layout :bits_0_2, 'uint8: 3',
-             :bit_3,    'char: 1',
-             :bit_4,    'uint8: 1',
-             :bits_5_7, 'char: 3'
-    end
-
-    assert_equal(1, subject_class.size)
-
-    subject = subject_class.new(bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b1, bits_5_7: 0b100)
-    assert_equal(1, subject[:bits_0_2])
-    assert_equal(-1, subject[:bit_3])
-    assert_equal(1, subject[:bit_4])
-    assert_equal(-4, subject[:bits_5_7])
-
-  end
-end