torigoya_kit 0.0.11 → 0.2.0

data/lib/torigoya_kit/ticket.rb

@@ -1,7 +1,8 @@
-# Copyright (c) 2014 yutopp
+# Copyright (c) 2014 - 2015 yutopp
 # Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
 
 require 'msgpack'
+require_relative 'typeutil'
 
 module TorigoyaKit
   # contains source codes / inputs data
@@ -12,7 +13,8 @@ module TorigoyaKit
 
     def initialize(name, code, is_compressed = false)
       @name = name
-      @code = if is_compressed then
+      @data = if is_compressed then
+                # NOT: implemented
               else
                 code
               end
@@ -20,22 +22,23 @@ module TorigoyaKit
 
       validate
     end
-    attr_reader :name, :code, :is_compressed
+    attr_reader :name, :data, :is_compressed
 
-    def to_tuple
-      return [@name,
-              @code,
-              @is_compressed
-             ]
+    def to_hash
+      return {
+        name: @name,
+        data: @data,
+        is_compressed: @is_compressed,
+      }
     end
 
     def to_msgpack(out = '')
-      return to_tuple.to_msgpack(out)
+      return to_hash.to_msgpack(out)
     end
 
     def ==(rhs)
       return @name == rhs.name &&
-        @code == rhs.code
+        @data == rhs.data
         @is_compressed == rhs.is_compressed
     end
 
@@ -44,116 +47,51 @@ module TorigoyaKit
       if @name.nil?
         @name = "*default*"
       else
-        raise InvalidFormatError.new("#{self.class}: name must be String (but #{@name.class})") unless @name.is_a?(String)
+        TypeUtil.nonnull_type_check(self, "name", @name, String)
       end
-      raise InvalidFormatError.new("#{self.class}: code must be String (but #{@code.class})") unless @code.is_a?(String)
-      raise InvalidFormatError.new("#{self.class}: is_compressed must be Boolean (but #{@is_compressed.class})") unless @is_compressed.is_a?(TrueClass) || @is_compressed.is_a?(FalseClass)
-    end
-  end
-
-  #
-  class Command
-    def initialize(key_or_value, value=nil)
-      unless value.nil?
-        @key = key_or_value
-        @value = value
-      else
-        @value = key_or_value
-      end
-
-      validate
-    end
-    attr_reader :key, :value
-
-    def to_tuple
-      unless @key.nil?
-        return [@key, @value]
-      else
-        return [@value]
-      end
-    end
-
-    def ==(rhs)
-      return @key == rhs.key && @value == rhs.value
-    end
-
-    private
-    def validate
-      unless @key.nil?
-        raise InvalidFormatError.new("#{self.class}: key must be String (but #{@key.class})") unless @key.is_a?(String)
-      end
-      raise InvalidFormatError.new("#{self.class}: value must be String (but #{@value.class})") unless @value.is_a?(String)
+      TypeUtil.nonnull_type_check(self, "data", @data, String)
+      TypeUtil.nonnull_boolean_type_check(self, "is_compressed", @is_compressed)
     end
   end
 
   #
   class ExecutionSetting
-    def initialize(command_line, structured_command, cpu_limit, memory_limit)
-      @command_line = command_line              # String
-      @structured_command = structured_command  # Array!Command
-      @cpu_limit = cpu_limit                    # uint64 / sec
-      @memory_limit = memory_limit              # uint64 / bytes
+    def initialize(args, envs, cpu_limit, memory_limit)
+      @args = args                  # Array!String
+      @envs = envs                  # Array!String
+      @cpu_limit = cpu_limit        # uint64 / sec
+      @memory_limit = memory_limit  # uint64 / bytes
 
       validate
     end
-    attr_reader :command_line, :structured_command, :cpu_limit, :memory_limit
+    attr_reader :args, :envs, :cpu_limit, :memory_limit
 
-    def to_tuple
-      return [@command_line,
-              @structured_command.map {|x| x.to_tuple},
-              @cpu_limit,
-              @memory_limit
-             ]
+    def to_hash
+      return {
+        args: @args,
+        envs: @envs,
+        cpu_time_limit: @cpu_limit,
+        memory_bytes_limit: @memory_limit
+      }
     end
 
     def to_msgpack(out = '')
-      return to_tuple.to_msgpack(out)
+      return to_hash.to_msgpack(out)
     end
 
     def ==(rhs)
-      return @command_line == rhs.command_line &&
-        @structured_command == rhs.structured_command &&
+      return @args == rhs.args &&
+        @envs == rhs.envs &&
         @cpu_limit == rhs.cpu_limit &&
         @memory_limit == rhs.memory_limit
     end
 
     private
     def validate
-      unless @command_line.nil?
-        raise InvalidFormatError.new("#{self.class}: type of command_line must be String (but #{@command_line.class})") unless @command_line.is_a?(String)
-      else
-        @command_line = ""
-      end
-
-      unless @structured_command.nil?
-        raise InvalidFormatError.new("#{self.class}: type of structured_command must be Array (but #{@structured_command.class})") unless @structured_command.is_a?(Array)
-        @structured_command.map! do |e|
-          if e.is_a?(Hash)
-            raise InvalidFormatError.new("#{self.class}: couln't convert type of element of structured_command (Hash: size is not 1)") unless e.size == 1
-            fl = e.flatten
-            if fl[1].nil?
-              Command.new(fl[0])
-            else
-              Command.new(fl[0], fl[1])
-            end
-          elsif e.is_a?(Array)
-            raise InvalidFormatError.new("#{self.class}: couln't convert type of element of structured_command (Array: length is not 1 or 2)") unless e.length == 1 || e.length == 2
-            if e.length == 1
-              Command.new(e[0])
-            elsif e.length == 2
-              Command.new(e[0], e[1])
-            end
-          else
-            raise InvalidFormatError.new("#{self.class}: type of element of structured_command must be Command (but #{e.class})") unless e.is_a?(Command)
-            e
-          end
-        end
-      else
-        @structured_command = []
-      end
-
-      raise InvalidFormatError.new("#{self.class}: type of cpu_limit must be Integer (but #{@cpu_limit.class})") unless @cpu_limit.is_a?(Integer)
-      raise InvalidFormatError.new("#{self.class}: type of memory_limit must be Integer (but #{@memory_limit.class})") unless @memory_limit.is_a?(Integer)
+      TypeUtil.nonnull_array_type_check(self, "args", @args, String)
+      TypeUtil.nonnull_array_type_check(self, "envs", @envs, String)
+      TypeUtil.nonnull_type_check(self, "cpu_limit", @cpu_limit, Integer)
+      TypeUtil.nonnull_type_check(self, "memory_limit", @memory_limit, Integer)
     end
   end
 
@@ -161,20 +99,21 @@ module TorigoyaKit
   class BuildInstruction
     def initialize(compile_setting, link_setting)
       @compile_setting = compile_setting    # ExecutionSetting
-      @link_setting = link_setting          # ExecutionSetting
+      @link_setting = link_setting          # ExecutionSetting?
 
       validate
     end
     attr_reader :compile_setting, :link_setting
 
-    def to_tuple
-      return [@compile_setting.to_tuple,
-              unless @link_setting.nil? then @link_setting.to_tuple else nil end
-             ]
+    def to_hash
+      return {
+        compile_setting: @compile_setting.to_hash,
+        link_setting: unless @link_setting.nil? then @link_setting.to_hash else nil end
+      }
     end
 
     def to_msgpack(out = '')
-      return to_tuple.to_msgpack(out)
+      return to_hash.to_msgpack(out)
     end
 
     def ==(rhs)
@@ -184,29 +123,30 @@ module TorigoyaKit
 
     private
     def validate()
-      raise InvalidFormatError.new("#{self.class}: type of compile_setting must be ExecutionSetting (but #{@compile_setting.class})") unless @compile_setting.is_a?(ExecutionSetting)
-      unless @link_setting.nil?
-        raise InvalidFormatError.new("#{self.class}: type of link_setting must be ExecutionSetting (but #{@link_setting.class})") unless @link_setting.is_a?(ExecutionSetting)
-      end
+      TypeUtil.nonnull_type_check(self, "compile_setting", @compile_setting, ExecutionSetting)
+      TypeUtil.type_check(self, "link_setting", @link_setting, ExecutionSetting)
     end
   end
 
   #
   class Input
     def initialize(stdin, run_setting)
-      @stdin = stdin                # SourceData
+      @stdin = stdin                # SourceData?
       @run_setting = run_setting    # ExecutionSetting
 
       validate
     end
     attr_reader :stdin, :run_setting
 
-    def to_tuple
-      return [@stdin, @run_setting]
+    def to_hash
+      return {
+        stdin: @stdin,
+        run_setting: @run_setting.to_hash
+      }
     end
 
     def to_msgpack(out = '')
-      return to_tuple.to_msgpack(out)
+      return to_hash.to_msgpack(out)
     end
 
     def ==(rhs)
@@ -216,10 +156,8 @@ module TorigoyaKit
 
     private
     def validate()
-      unless @stdin.nil?
-        raise InvalidFormatError.new("#{self.class}: type of stdin must be SourceData (but #{@stdin.class})") unless @stdin.is_a?(SourceData)
-      end
-      raise InvalidFormatError.new("#{self.class}: type of run_setting must be ExecutionSetting (but #{@run_setting.class})") unless @run_setting.is_a?(ExecutionSetting)
+      TypeUtil.type_check(self, "stdin", @stdin, SourceData)
+      TypeUtil.nonnull_type_check(self, "run_setting", @run_setting, ExecutionSetting)
     end
   end
 
@@ -232,12 +170,12 @@ module TorigoyaKit
     end
     attr_reader :inputs
 
-    def to_tuple
-      return [@inputs.map {|x| x.to_tuple}]
+    def to_hash
+      return [@inputs.map {|x| x.to_hash}]
     end
 
     def to_msgpack(out = '')
-      return to_tuple.to_msgpack(out)
+      return to_hash.to_msgpack(out)
     end
 
     def ==(rhs)
@@ -246,45 +184,37 @@ module TorigoyaKit
 
     private
     def validate()
-      raise InvalidFormatError.new("#{self.class}: type of inputs must be Array (but #{@inputs.class})") unless @inputs.is_a?(Array)
-      @inputs.each do |e|
-        raise InvalidFormatError.new("#{self.class}: type of element of inputs must be Input (but #{e.class})") unless e.is_a?(Input)
-      end
+      TypeUtil.nonnull_array_type_check(self, "inputs", @inputs, Input)
     end
   end
 
   #
   class Ticket
-    def initialize(base_name, proc_id, proc_version, source_codes, build_inst, run_inst)
-      @base_name = base_name
-      @proc_id = proc_id
-      @proc_version = proc_version
+    def initialize(base_name, source_codes, build_inst, run_inst)
+      @base_name = base_name            # String
       @source_codes = source_codes      # Array!SourceData
-      @build_inst = build_inst          # BuildInstruction
-      @run_inst = run_inst              # RunInstruction
+      @build_inst = build_inst          # BuildInstruction?
+      @run_inst = run_inst              # RunInstruction?
 
       validate
     end
-    attr_reader :base_name, :proc_id, :proc_version, :source_codes, :build_inst, :run_inst
+    attr_reader :base_name, :source_codes, :build_inst, :run_inst
 
-    def to_tuple
-      return [@base_name,
-              @proc_id,
-              @proc_version,
-              @source_codes.map {|x| x.to_tuple},
-              unless @build_inst.nil? then @build_inst.to_tuple else nil end,
-              unless @run_inst.nil? then @run_inst.to_tuple else nil end
-             ]
+    def to_hash
+      return {
+        base_inst: @base_name,
+        sources: @source_codes.map {|x| x.to_hash},
+        build_inst: unless @build_inst.nil? then @build_inst.to_hash else nil end,
+        run_inst: unless @run_inst.nil? then @run_inst.to_hash else nil end,
+      }
     end
 
     def to_msgpack
-      return to_tuple.to_msgpack()
+      return to_hash.to_msgpack()
     end
 
     def ==(rhs)
       return @base_name == rhs.base_name &&
-        @proc_id == rhs.proc_id &&
-        @proc_version == rhs.proc_version &&
         @source_codes == rhs.source_codes &&
         @build_inst == rhs.build_inst &&
         @run_inst == rhs.run_inst
@@ -292,19 +222,10 @@ module TorigoyaKit
 
     private
     def validate()
-      raise InvalidFormatError.new("#{self.class}: type of base_name must be String (but #{@base_name.class})") unless @base_name.is_a?(String)
-      raise InvalidFormatError.new("#{self.class}: type of proc_id must be Integer (but #{@proc_id.class})") unless @proc_id.is_a?(Integer)
-      raise InvalidFormatError.new("#{self.class}: type of proc_version must be String (but #{@proc_version.class})") unless @proc_version.is_a?(String)
-      raise InvalidFormatError.new("#{self.class}: type of source_codes must be Array (but #{@source_codes.class})") unless @source_codes.is_a?(Array)
-      @source_codes.each do |e|
-        raise InvalidFormatError.new("#{self.class}: type of element of source_codes must be SourceData (but #{e.class})") unless e.is_a?(SourceData)
-      end
-      unless @build_inst.nil?
-        raise InvalidFormatError.new("#{self.class}: type of build_inst must be BuildInstruction (but #{@build_inst.class})") unless @build_inst.is_a?(BuildInstruction)
-      end
-      unless @run_inst.nil?
-        raise InvalidFormatError.new("#{self.class}: type of run_inst must be RunInstruction (but #{@run_inst.class})") unless @run_inst.is_a?(RunInstruction)
-      end
+      TypeUtil.nonnull_type_check(self, "base_name", @base_name, String)
+      TypeUtil.nonnull_array_type_check(self, "source_codes", @source_codes, SourceData)
+      TypeUtil.type_check(self, "build_inst", @build_inst, BuildInstruction)
+      TypeUtil.type_check(self, "run_inst", @run_inst, RunInstruction)
     end
   end
 
@@ -314,4 +235,5 @@ module TorigoyaKit
       super(*args)
     end
   end
+
 end # module TorigoyaKit

data/lib/torigoya_kit/typeutil.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2015 - yutopp
+# Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+module TorigoyaKit
+  class TypeUtil
+    def self.nil_check(tag, name, elem)
+      raise InvalidFormatError.new("#{tag.class}: type of `#{name}` must NOT be nil") if elem.nil?
+    end
+
+    def self.type_check(tag, name, elem, expect)
+      return if elem.nil?
+      raise InvalidFormatError.new("#{tag.class}: type of `#{name}` must be #{expect} (but #{elem.class})") unless elem.is_a?(expect)
+    end
+
+    def self.nonnull_type_check(tag, name, elem, expect)
+      nil_check(tag, name, elem)
+      type_check(tag, name, elem, expect)
+    end
+
+    def self.boolean_type_check(tag, name, elem)
+      return if elem.nil?
+      raise InvalidFormatError.new("#{tag.class}: type of `#{name}` must be Boolean (but #{elem.class})") unless elem.is_a?(TrueClass) || elem.is_a?(FalseClass)
+    end
+
+    def self.nonnull_boolean_type_check(tag, name, elem)
+      nil_check(tag, name, elem)
+      boolean_type_check(tag, name, elem)
+    end
+
+    def self.array_type_check(tag, name, elem, expect)
+      return if elem.nil?
+      type_check(tag, name, elem, Array)
+      elem.each do |e|
+        type_check(tag, "element of #{name}", e, expect)
+      end
+    end
+
+    def self.nonnull_array_type_check(tag, name, elem, expect)
+      nonnull_type_check(tag, name, elem, Array)
+      elem.each do |e|
+        nonnull_type_check(tag, "element of #{name}", e, expect)
+      end
+    end
+  end
+
+end # module TorigoyaKit

data/lib/torigoya_kit/version.rb

@@ -1,3 +1,3 @@
 module TorigoyaKit
-  VERSION = "0.0.11"
+  VERSION = "0.2.0"
 end

data/spec/cases/protocol_spec.rb

@@ -3,29 +3,41 @@
 require_relative '../spec_helper'
 
 describe :request_protocol do
-  b = TorigoyaKit::Protocol::Packet.new(TorigoyaKit::Protocol::MessageKindAcceptRequest, 12345)
+  b = TorigoyaKit::Protocol::Packet.new(
+    TorigoyaKit::Protocol::MessageKindTicketRequest,    # kind
+    42,             # version
+    {"test": 42}    # data
+  )
 
-  it "size of kind should be 1" do
+  it "size of @kind should be 1" do
     expect(b.kind.size).to eq 1
   end
 
-  it "kind should be TorigoyaKit::Protocol::MessageKindAcceptRequest" do
-    expect(b.kind.bytes).to eq [0x00]
+  it "@kind should be TorigoyaKit::Protocol::MessageKindAcceptRequest" do
+    expect(b.kind.bytes).to eq [0x01]
   end
 
-  it "size of size should be 3" do
-    expect(b.size.size).to eq 4
+  it "size of @version should be 4" do
+    expect(b.version.size).to eq 4
   end
 
-  it "size should be [0x03, 0x00, 0x00, 0x00]" do
-    expect(b.size.bytes).to eq [0x03, 0x00, 0x00, 0x00]
+  it "@version should be 42" do
+    expect(b.version.bytes).to eq [0x2a, 0x00, 0x00, 0x00]
   end
 
-  it "size of encoded_data should be 3" do
-    expect(b.encoded_data.size).to eq 3
+  it "size of @length should be 4" do
+    expect(b.length.size).to eq 4
   end
 
-  it "encoded_data should be [205, 48, 57]" do
-    expect(b.encoded_data.bytes).to eq [205, 48, 57]
+  it "@length should be 3" do
+    expect(b.length.bytes).to eq [0x07, 0x00, 0x00, 0x00]
+  end
+
+  it "size of @message should be 7" do
+    expect(b.message.size).to eq 7
+  end
+
+  it "@message should be [129, 164, 116, 101, 115, 116, 42]" do
+    expect(b.message.bytes).to eq [129, 164, 116, 101, 115, 116, 42]
   end
 end

data/spec/cases/session_spec.rb

@@ -3,16 +3,27 @@
 require_relative '../spec_helper'
 
 describe :session do
+  port = 23432
+
   it "session proc exec_ticket" do
-    s = TorigoyaKit::Session.new("localhost", 49800)
-    # p s.exec_ticket(make_ticket())
+    s = TorigoyaKit::Session.new("localhost", port)
+    t = s.exec_ticket(make_ticket())
+    p t
+    expect(t.compile.result.system_error_status).to eq 0
+    expect(t.compile.result.exited).to eq true
+    expect(t.compile.result.exit_status).to eq 0
+
+    expect(t.link.result.system_error_status).to eq 0
+    expect(t.link.result.exited).to eq true
+    expect(t.link.result.exit_status).to eq 0
+
+    expect(t.run[0].result.system_error_status).to eq 0
+    expect(t.run[0].result.exited).to eq true
+    expect(t.run[0].result.exit_status).to eq 0
   end
 
-  it "session proc update_proc_table" do
-    #s = TorigoyaKit::Session.new("localhost", 22222)
-    #s.update_packages()
-    #s.exec_ticket(make_ticket())
-    #s.update_proc_table()
-    #p s.get_proc_table()
+  it "session proc update_packages" do
+    s = TorigoyaKit::Session.new("localhost", port)
+    expect(s.update_packages()).to eq 0
   end
 end

data/spec/cases/ticket_spec.rb

@@ -14,73 +14,67 @@ describe :ticket do
   end
 
   #
-  dummy_es = TorigoyaKit::ExecutionSetting.new("", [], 0, 0)
+  dummy_es = TorigoyaKit::ExecutionSetting.new([], [], 0, 0)
   dummy_bi = TorigoyaKit::BuildInstruction.new(dummy_es, dummy_es)
   dummy_ri = TorigoyaKit::RunInstruction.new([])
 
   it "construct ticket" do
     expect do
-      TorigoyaKit::Ticket.new(nil, nil, nil, nil, nil, nil)
+      TorigoyaKit::Ticket.new(nil, nil, nil, nil)
     end.to raise_error(TorigoyaKit::InvalidFormatError)
 
     expect do
-      TorigoyaKit::Ticket.new("", nil, nil, nil, nil, nil)
+      TorigoyaKit::Ticket.new("", nil, nil, nil)
     end.to raise_error(TorigoyaKit::InvalidFormatError)
 
     expect do
-      TorigoyaKit::Ticket.new("", 0, nil, nil, nil, nil)
+      TorigoyaKit::Ticket.new("", [], "", nil)
     end.to raise_error(TorigoyaKit::InvalidFormatError)
 
     expect do
-      TorigoyaKit::Ticket.new("", 0, "", nil, nil, nil)
+      TorigoyaKit::Ticket.new("", [], "", "")
     end.to raise_error(TorigoyaKit::InvalidFormatError)
 
     expect do
-      TorigoyaKit::Ticket.new("", 0, "", [], nil, 2)
+      TorigoyaKit::Ticket.new(0, [], "", "")
     end.to raise_error(TorigoyaKit::InvalidFormatError)
 
     expect do
-      TorigoyaKit::Ticket.new("", 0, "", [], dummy_bi, 2)
+      TorigoyaKit::Ticket.new("", 0, "", "")
     end.to raise_error(TorigoyaKit::InvalidFormatError)
 
     expect do
-      TorigoyaKit::Ticket.new("", 0, "", [], dummy_bi, dummy_ri)
+      TorigoyaKit::Ticket.new("", [], dummy_bi, dummy_ri)
     end.to_not raise_error
 
     expect do
-      TorigoyaKit::Ticket.new("", 0, "", [], dummy_bi, dummy_ri).to_msgpack
+      TorigoyaKit::Ticket.new("", [], dummy_bi, dummy_ri).to_msgpack
     end.to_not raise_error
 
     expect do
-      TorigoyaKit::Ticket.new("", 0, "", [], nil, dummy_ri)
+      TorigoyaKit::Ticket.new("", [], nil, dummy_ri)
     end.to_not raise_error
 
     expect do
-      TorigoyaKit::Ticket.new("", 0, "", [], nil, dummy_ri).to_msgpack
+      TorigoyaKit::Ticket.new("", [], nil, dummy_ri).to_msgpack
     end.to_not raise_error
-  end
-
-  it "construct execution setting" do
-    commands = [TorigoyaKit::Command.new("A=", "B"),
-                TorigoyaKit::Command.new("unit")
-               ]
-    expected = TorigoyaKit::ExecutionSetting.new("test command", commands, 100, 200)
 
-    cloned_commands = [TorigoyaKit::Command.new("A=", "B"),
-                    TorigoyaKit::Command.new("unit")
-                   ]
-    cloned_dummy = TorigoyaKit::ExecutionSetting.new("test command", cloned_commands, 100, 200)
+    expect do
+      TorigoyaKit::Ticket.new("", [], dummy_bi, nil)
+    end.to_not raise_error
 
-    expect(cloned_dummy).to eq expected
+    expect do
+      TorigoyaKit::Ticket.new("", [], dummy_bi, nil).to_msgpack
+    end.to_not raise_error
   end
 
   it "setting" do
-    cloned_es = TorigoyaKit::ExecutionSetting.new("", [], 0, 0)
+    cloned_es = TorigoyaKit::ExecutionSetting.new([], [], 0, 0)
     expect(cloned_es).to eq dummy_es
   end
 
   it "build inst" do
-    cloned_es = TorigoyaKit::ExecutionSetting.new("", [], 0, 0)
+    cloned_es = TorigoyaKit::ExecutionSetting.new([], [], 0, 0)
     cloned_bi = TorigoyaKit::BuildInstruction.new(cloned_es, cloned_es)
 
     expect(cloned_bi).to eq dummy_bi
@@ -91,24 +85,6 @@ describe :ticket do
     expect(cloned_ri).to eq dummy_ri
   end
 
-  it "setting conversion list" do
-    commands = [TorigoyaKit::Command.new("A=", "B"),
-                TorigoyaKit::Command.new("unit")
-               ]
-    expected = TorigoyaKit::ExecutionSetting.new("test command", commands, 100, 200)
-
-    expect(TorigoyaKit::ExecutionSetting.new("test command", [["A=", "B"], ["unit"]], 100, 200)).to eq expected
-  end
-
-  it "setting conversion list" do
-    commands = [TorigoyaKit::Command.new("A=", "B"),
-                TorigoyaKit::Command.new("unit")
-               ]
-    expected = TorigoyaKit::ExecutionSetting.new("test command", commands, 100, 200)
-
-    expect(TorigoyaKit::ExecutionSetting.new("test command", [{"A=" => "B"}, {"unit"=>nil}], 100, 200)).to eq expected
-  end
-
   it "source default" do
     expected = TorigoyaKit::SourceData.new("*default*", "hoge")
     expect(TorigoyaKit::SourceData.new(nil, "hoge")).to eq expected