soc_maker 0.1.1

data/spec/lib_spec.rb

@@ -0,0 +1,209 @@
+###############################################################
+#   
+#  File:      soc_lib_spec.rb
+#
+#  Author:    Christian Hättich
+#
+#  Project:   System-On-Chip Maker
+#
+#  Target:    Linux / Windows / Mac
+#
+#  Language:  ruby
+#
+#
+###############################################################
+#
+#
+#   Copyright (C) 2014  Christian Hättich  - feddischson [ at ] opencores.org
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+###############################################################
+#
+#   Description:
+#
+#
+#
+#
+###############################################################
+require_relative( 'spec_helper' )
+
+
+describe SOCMaker::Lib do
+
+  before( :each )do
+     @lib = SOCMaker::Lib.new
+  end
+
+  describe "#initialize"  do
+    subject { SOCMaker::Lib.new }
+    its( :class ) { should == SOCMaker::Lib }
+  end
+
+
+
+
+  describe "#refresh" do
+
+    context "path loading" do
+      it "calls process_include for each path given as argument" do
+        paths_res = []
+        @lib.stub( :process_include ) do |arg|
+           paths_res << arg 
+        end
+        paths = [ "first_path", "second_path" ]
+        @lib.refresh( paths )
+        expect( paths_res ).to eq( paths )
+      end
+
+      it "cals process_include for each path from config, if no argument is given" do
+        paths_res = []
+        @lib.stub( :process_include ) do |arg|
+           paths_res << arg 
+        end
+        paths = [ "first_path", "second_path" ]
+        SOCMaker::conf[ :cores_search_path ] = paths
+        @lib.refresh( )
+        expect( paths_res ).to eq( paths )
+      end
+    end
+
+    context "yaml include loading" do
+      it "returns two objects" do
+
+        obs = []
+        @lib.stub( :get_all_yaml_in_str ) do |arg|
+           "SOCM_INCLUDE\ndirs:\n- folder_a\n- folder_b\n- folder_c\nSOCM_INCLUDE\ndirs:\n- folder_d\n- folder_e\n- folder_f\n" 
+        end
+        @lib.stub( :add_include ) do |arg|
+           obs << arg
+        end
+        @lib.refresh( [ "some_path" ] )
+        expect( obs ).to eq ( [ SOCMaker::LibInc.new( 'dirs' => ["folder_a", "folder_b", "folder_c"] ), 
+                                SOCMaker::LibInc.new( 'dirs' => ["folder_d", "folder_e", "folder_f"] ) ] )
+      end
+    end
+  end
+
+  describe "#process_include" do
+
+    it "raises an ProcessingError if a folder is included twice" do
+      expect do
+        @lib.process_include( "./empty_soc_lib_folder" ) 
+        @lib.process_include( "./empty_soc_lib_folder" ) 
+      end.
+      to raise_error( SOCMaker::ERR::InitError )
+    end
+  end
+
+  describe "#add_core/#rm_core/#add_ifc/#rm_ifc" do
+
+    it "should be possible to add, get and remove a core" do
+      c = SOCMaker::CoreDef.new( "A core", "acore,v1", "top" )
+      @lib.add_core( c )
+      @lib.get_core( :"acore,v1" ).should be == c
+      @lib.rm_core( c )
+      @lib.add_core( c )
+      @lib.rm_core( c.id )
+      expect { @lib.get_core( :"acore,v1" ) }.
+        to raise_error( SOCMaker::ERR::ProcessingError ) 
+      expect { @lib.rm_core( 123 ) }.
+        to raise_error( SOCMaker::ERR::ProcessingError ) 
+    end
+
+    it "should be possible to add, get and remove an interface" do
+      i = SOCMaker::IfcSpc.new( "My Interface", "myifc,v2" )
+
+      # removing with instance
+      @lib.add_ifc( i )
+      @lib.get_ifc( :"myifc,v2" ).should be == i
+      @lib.rm_ifc( i )
+
+      expect { @lib.get_ifc( :"myifc,v2" ) }. 
+        to raise_error( SOCMaker::ERR::ProcessingError ) 
+
+      # removing with id
+      @lib.add_ifc( i )
+      @lib.get_ifc( :"myifc,v2" ).should be == i
+      @lib.rm_ifc( i.id )
+
+      expect { @lib.get_ifc( :"myifc,v2" ) }
+        .to raise_error( SOCMaker::ERR::ProcessingError ) 
+
+      expect { @lib.rm_ifc( 4 ) }
+        .to raise_error( SOCMaker::ERR::ProcessingError )
+
+    end
+  end
+
+  describe  "#add_include" do
+    it "should process all folders in add_include" do
+      all_folders = ["folder_a", "folder_b", "folder_c" ]
+      i = SOCMaker::LibInc.new( 'dirs' => all_folders  )
+      all_folders_res = []
+      @lib.stub( :process_include ) do |arg|
+        all_folders_res << arg
+      end
+      @lib.send( :add_include, i, "./" )
+      all_folders.each_with_index do |f,index|
+        File.expand_path( File.join( "./", f ) ).should be == all_folders_res[ index ]
+      end
+    end
+  end
+
+
+  describe "#refresh" do
+    it "should load all elements from our test library" do
+      @lib.refresh( './spec/test_soc_lib' )
+      core_A      = @lib.get_core( :"core_A,rel1"  )
+      core_B      = @lib.get_core( :"core_B,rel1"  )
+      core_AB_ifc = @lib.get_ifc( :"core_AB_ifc,1" )
+      expect( core_A.class                  ).to be( SOCMaker::CoreDef )
+      expect( core_B.class                  ).to be( SOCMaker::CoreDef )
+      expect( core_AB_ifc.class             ).to be( SOCMaker::IfcSpc  )
+      expect( core_A.static_parameters.size ).to be( 3 )
+    end
+  end
+
+
+  describe "#to_s" do
+
+    context "string creation" do
+      it{ expect( @lib.to_s ).not_to be_nil }
+      it{ expect( @lib.to_s.size ).to be > 0 }
+    end
+  end
+
+  describe "#cores" do
+
+    it "should be possible to add, get and remove a core" do
+      c1 = SOCMaker::CoreDef.new( "A core", "acore,v1", "top" )
+      c2 = SOCMaker::CoreDef.new( "A core", "acore,v2", "top" )
+      c3 = SOCMaker::CoreDef.new( "A core", "acore,v3", "top" )
+
+      @lib.add_core( c1 )
+      @lib.add_core( c2 )
+      @lib.add_core( c3 )
+      cores = {}
+      @lib.cores { |k,v| cores[k] = v }
+      expect( cores ).to eq( "acore,v1" => c1, 
+                             "acore,v2" => c2,
+                             "acore,v3" => c3 )
+    end
+  end
+end
+
+# vim: noai:ts=2:sw=2
+

data/spec/parameter_spec.rb

@@ -0,0 +1,86 @@
+###############################################################
+#   
+#  File:      parameter_spec.rb
+#
+#  Author:    Christian Hättich
+#
+#  Project:   System-On-Chip Maker
+#
+#  Target:    Linux / Windows / Mac
+#
+#  Language:  ruby
+#
+#
+###############################################################
+#
+#
+#   Copyright (C) 2014  Christian Hättich  - feddischson [ at ] opencores.org
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+###############################################################
+#
+#   Description:
+#     Test specification for SOCMaker::Parameter
+#
+#
+#
+#
+###############################################################
+require_relative( 'spec_helper' )
+
+require "yaml_examples.rb"
+
+
+describe SOCMaker::Parameter do
+
+  describe "#initialize" do
+
+    it "returns an object of type SOCMaker::Parameter when creating it with new" do
+      o = SOCMaker::Parameter.new( "integer" )
+      expect( o.class).to be( SOCMaker::Parameter )
+    end
+
+    it "raises an error if the type is not a string" do
+      expect{ SOCMaker::Parameter.new( 3 ) }.
+      to raise_error( SOCMaker::ERR::InitError )
+    end
+
+    it "raises an error if the type is a string with zero length" do
+      expect{ SOCMaker::Parameter.new( "" ) }.
+      to raise_error( SOCMaker::ERR::InitError )
+    end
+
+    it "raises an error if the type is nil" do
+      expect{ SOCMaker::Parameter.new( "" ) }.
+      to raise_error( SOCMaker::ERR::InitError )
+    end
+  end
+
+  describe "SOCMaker::from_s" do
+    include_context "yaml examples"
+
+    it 'raises an error if the type value of an instance param. is empty' do
+      expect{ SOCMaker::from_s( @F_YAML_INSTP_TYPE ) }.
+      to raise_error( SOCMaker::ERR::InitError )
+    end
+  end
+end
+
+
+# vim: noai:ts=2:sw=2
+
+
+

data/spec/soc_def_spec.rb

@@ -0,0 +1,611 @@
+###############################################################
+#   
+#  File:      soc_def_spec.rb
+#
+#  Author:    Christian Hättich
+#
+#  Project:   System-On-Chip Maker
+#
+#  Target:    Linux / Windows / Mac
+#
+#  Language:  ruby
+#
+#
+###############################################################
+#
+#
+#   Copyright (C) 2014  Christian Hättich  - feddischson [ at ] opencores.org
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+###############################################################
+#
+#   Description:
+#     Test spec. for SOCMaker::SOCDef
+#
+######################
+#
+# Some helpful links about rspec:
+#
+#   http://lmws.net/describe-vs-context-in-rspec
+#   http://betterspecs.org/
+#   https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
+#
+#
+#
+###############################################################
+require_relative( 'spec_helper' )
+
+require "yaml_examples.rb"
+
+describe SOCMaker::SOCDef do
+
+  include_context "yaml examples"
+
+  # not implemented at the moment
+
+  # test for invalid path
+  # it "should raise an error if a non-existing path is given" do
+  #   expect { SOCMaker::from_f( 'blabla.txt' ) }.
+  #       to raise_error( IOError )
+  # end
+
+  describe "loading via SOCMaker::from_s" do
+
+    after( :each ){ SOCMaker::lib.clear }
+
+    it 'returns a class of type SOCDef when loading a full soc-def' do
+      SOCMaker::from_s( @FULL_SOC_YAML ).class.should == SOCMaker::SOCDef
+    end
+
+    it "raises ConsistenceError when a core-def. doesn't exist" do
+      expect { SOCMaker::from_s( @SOC_YAML_WITH_CORE ).consistence_check }.
+        to raise_error( SOCMaker::ERR::ConsistenceError )
+    end
+
+    it "returns an SOC-object" do
+      core = SOCMaker::CoreDef.new( "mycore", "rel1", "top" )
+      SOCMaker::lib.add_core( core )
+      soc = SOCMaker::from_s( @SOC_YAML_WITH_CORE ) 
+      expect( soc.class ).to be SOCMaker::SOCDef
+    end
+
+  end
+
+
+  describe "#initialize" do
+      subject{ @soc = SOCMaker::SOCDef.new( "Test SOC", "test-soc,v1", "my_soc_top" ) }
+      its( :name      ) { should == "Test SOC"     }
+      its( :id        ) { should == :"test-soc,v1" }
+      its( :toplevel  ) { should == "my_soc_top"   }
+      its( :cores     ) { should == {}             }
+      its( :static    ) { should == {}             }
+      its( :cons      ) { should == {}             }
+  end
+
+
+
+
+  describe "core, interface, parameter and connection handling" do
+
+    before( :each )do
+      @core = SOCMaker::CoreDef.new( "My Core", "mycore,rel1", "top" )
+
+      @ifc_spc1 = SOCMaker::IfcSpc.new( "myifc", "myifc,v1", 'ports' => { port_a: {dir:1}, port_b: {dir:0} }, 'multiplicity' => [ 2, 1 ] )
+      @ifc_spc2 = SOCMaker::IfcSpc.new( "myifc", "myifc,v2", 'ports' => { port_a: {dir:1}, port_b: {dir:0} } )
+
+      @ifc_def_1 = SOCMaker::IfcDef.new( "myifc", "myifc,v1", 0, { a: SOCMaker::IfcPort.new( "port_a", 1 ), 
+                                                                   b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
+
+      @ifc_def_0 = SOCMaker::IfcDef.new( "myifc", "myifc,v1", 1, { a: SOCMaker::IfcPort.new( "port_a", 1 ), 
+                                                                   b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
+
+
+      @core.interfaces[ :ifc_a ] = @ifc_def_0
+      @core.interfaces[ :ifc_b ] = @ifc_def_1
+      @core.interfaces[ :ifc_c ] = @ifc_def_0
+      @core.interfaces[ :ifc_d ] = @ifc_def_1
+      @core.interfaces[ :ifc_e ] = @ifc_def_0
+      @core.interfaces[ :ifc_f ] = @ifc_def_1
+
+      SOCMaker::lib.add_ifc( @ifc_spc1 )
+      SOCMaker::lib.add_ifc( @ifc_spc2 )
+      SOCMaker::lib.add_core( @core )
+      @soc = SOCMaker::SOCDef.new( "Test SOC", "test-soc,v1", "my_soc_top" )
+    end
+
+    after( :each ) do
+      SOCMaker::lib.clear
+    end
+
+    describe "#inst_in_use?" do
+
+      it "returns true, if there is already an core instance with that name" do
+        @soc.cores[ :core_inst ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        expect( @soc.inst_in_use?( :core_inst ) ).to be( true ) 
+      end
+
+      it "returns false, if there is no core instance with that name" do
+        expect( @soc.inst_in_use?( :core_inst ) ).to be( false )
+      end
+
+      it "inst_in_use should return true, if there is already an connection instance with that name" do
+        @soc.cons[ :a_con ] = { mapping: [ { :core_a => :ifc_a }, { :core_b => :ifc_b } ] }
+        expect( @soc.inst_in_use?( :a_con ) ).to be( true )
+      end
+
+    end
+
+    describe "#ifc_in_use?" do
+      it "should return false, when an interface is not used" do
+        # setup interface ifc_b and ifc_c, test for ifc_a
+        a_con = { mapping: [ { :core_a => :ifc_b }, { :core_b => :ifc_c } ] }
+        @soc.cons[ :my_con ] = a_con
+        expect( @soc.ifc_in_use?( :core_a, :ifc_a ) ).to be( false )
+      end
+
+      it "should return true, if an interface is used" do
+        a_con = { mapping: [ { :core_a => :ifc_a }, { :core_b => :ifc_b } ] }
+        @soc.cons[ :my_con ] = a_con
+        expect( @soc.ifc_in_use?( :core_a, :ifc_a ) ).to be( true )
+      end
+    end
+
+
+    describe "#rm and #inst_in_use" do
+
+      it do
+        @soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.cores[ :core_b ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.add_connection(  :new_connection, :core_a, :ifc_a, :core_b, :ifc_b ) 
+
+        expect( @soc.inst_in_use?( :core_a ) ).to be( true )
+
+        @soc.rm( :core_a )
+        expect( @soc.inst_in_use?( :core_a ) ).to be( false )
+        expect( @soc.cons[ :new_connection ][:mapping][ 1 ].size ).to be( 0 )  
+        expect( @soc.cons[ :new_connection ][:mapping][ 0 ].size ).to be( 1 )  
+      end
+
+
+      it do
+        @soc.cons[ :a_con ] = { mapping: [ { :core_a => :ifc_a }, { :core_b => :ifc_b } ] }
+        expect( @soc.inst_in_use?( :a_con ) ).to be( true )
+        @soc.rm( :a_con )
+        expect( @soc.inst_in_use?( :a_con ) ).to be( false )
+      end
+
+      it "raises an error, when removing a non-existance instance" do
+        expect{ @soc.rm( :a_con ) }.to raise_error( SOCMaker::ERR::ConsistenceError )
+      end
+
+    end
+
+
+    describe "#add_core" do
+
+      it "should raise an error if an instance is added twice" do
+        @soc.cores[ :core_inst ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        expect{ @soc.add_core(  :"mycore,rel1", :core_inst ) }
+            .to raise_error( SOCMaker::ERR::ConsistenceError )
+      end
+
+      it "should return non-nil value, if a instance is added once" do
+        expect( @soc.add_core(  :"mycore,rel1", :core_inst ) ).not_to be( false )
+      end
+
+      it "should raise a processing error when adding an unknown core" do
+        expect{ @soc.add_core( :"some_unknown_core,v_xyz", :test ) }.
+          to raise_error( SOCMaker::ERR::ProcessingError )
+      end 
+
+    end
+
+    describe "#add_connection" do
+
+      it "raises an error, if a wrong number of arguments is given" do
+
+        @soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.cores[ :core_b ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.cores[ :core_c ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.cores[ :core_d ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.cores[ :core_e ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.cores[ :core_f ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.cores[ :core_g ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+
+        expect{ @soc.add_connection(  :new_connection ) }
+            .to raise_error( SOCMaker::ERR::ProcessingError )
+
+        expect{ @soc.add_connection(  :new_connection, :core_a ) }
+            .to raise_error( SOCMaker::ERR::ProcessingError )
+
+        expect{ @soc.add_connection(  :new_connection, :core_a, :ifc_a, :core_b ) }
+            .to raise_error( SOCMaker::ERR::ProcessingError )
+
+      end
+
+      it "raises an error, if a core doesn't exist in a SOC" do
+
+        @soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        expect{ @soc.add_connection(  :new_connection, :core_a, :ifc_a, :core_b, :ifc_b ) }
+            .to raise_error( SOCMaker::ERR::ConsistenceError )
+
+      end
+
+      it "raises an error, if an interface doesn't exist in a core" do
+
+        @soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        expect{ @soc.add_connection(  :new_connection, :core_a, :ifc_x ) }
+            .to raise_error( SOCMaker::ERR::ConsistenceError )
+
+      end
+
+
+      it "raises an error, if the location of a connection entry is not the direction" do
+
+        @soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.cons[ :a_con ] = { mapping: [ { :core_a => :ifc_a }, { } ] }
+        expect{ @soc.consistence_check }
+            .to raise_error( SOCMaker::ERR::ConsistenceError )
+
+      end
+
+      it "raises an error, if an interface is used twice" do
+
+        @soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.cons[ :a_con ] = { mapping: [ {} ,{ :core_a => :ifc_a } ] }
+        expect{ @soc.add_connection(  :new_connection, :core_a, :ifc_a ) }
+            .to raise_error( SOCMaker::ERR::ConsistenceError )
+
+      end
+
+      it "connects two instances" do
+
+        @soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.cores[ :core_b ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.add_connection(  :new_connection, :core_a, :ifc_a, :core_b, :ifc_b ) 
+        con_entry = @soc.cons[ :new_connection ]
+        expect( con_entry.class ).to be ( Hash )
+        expect( con_entry[ :mapping ].class ).to be ( Array )
+        expect( con_entry[ :mapping ].size ).to be ( 2 )
+        expect( con_entry[ :mapping ][0].class ).to be ( Hash )
+        expect( con_entry[ :mapping ][1].class ).to be ( Hash )
+        expect( con_entry[ :mapping ][0].size ).to be ( 1 )
+        expect( con_entry[ :mapping ][1].size ).to be ( 1 )
+        expect( con_entry[ :mapping ][0][ :core_b ] ).to be ( :ifc_b )
+        expect( con_entry[ :mapping ][1][ :core_a ] ).to be ( :ifc_a )
+
+      end
+
+      it "limits the number of connections entries" do
+        # the multiplicity is defined at the beginning (see above)
+
+        @soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.cores[ :core_b ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.add_connection(  :new_connection, :core_a, :ifc_a, :core_b, :ifc_b ) 
+        expect{ @soc.add_connection(  :new_connection, :core_a, :ifc_c  )  }
+          .to raise_error( SOCMaker::ERR::ConsistenceError )
+
+      end
+
+
+
+
+      it "raises a ConsistenceError if the ifc.-version is wrong" do
+
+        ifc_spc1 = SOCMaker::IfcSpc.new( "myifc", "myifc,v1", 'ports' => { port_a: {dir:1}, port_b: {dir:0} } )
+        ifc_spc2 = SOCMaker::IfcSpc.new( "myifc", "myifc,v2", 'ports' => { port_a: {dir:1}, port_b: {dir:0} } )
+        ifc_def_1 = SOCMaker::IfcDef.new( "myifc", "myifc,v1", 0, { a: SOCMaker::IfcPort.new( "port_a", 1 ) } )
+        ifc_def_0 = SOCMaker::IfcDef.new( "myifc", "myifc,v2", 1, { b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
+        core_a = SOCMaker::CoreDef.new( "core_a", "core_a,v1", "top" )
+        core_b = SOCMaker::CoreDef.new( "core_b", "core_a,v1", "top" )
+        core_a.interfaces[ :ifc_a ] = ifc_def_0
+        core_a.interfaces[ :ifc_b ] = ifc_def_1
+        core_b.interfaces[ :ifc_a ] = ifc_def_0
+        core_b.interfaces[ :ifc_b ] = ifc_def_1
+
+        SOCMaker::lib.add_ifc( ifc_spc1 )
+        SOCMaker::lib.add_ifc( ifc_spc2 )
+        SOCMaker::lib.add_core( core_a ) 
+        SOCMaker::lib.add_core( core_b ) 
+        @soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "core_a,v1" )
+        @soc.cores[ :core_b ] = SOCMaker::CoreInst.new( "core_b,v1" )
+        expect { @soc.add_connection( :a_new_con, :inst_a, :ifc_a, :inst_b, :ifc_b ) }.
+          to raise_error( SOCMaker::ERR::ConsistenceError )
+      end
+
+
+
+      it "adds a connection entry, which connects the toplevel ports" do
+
+       @soc.interfaces[ :t1 ] = @ifc_def_0
+       @soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+       @soc.add_connection(  :another_con, :inst_a, :ifc_a, @soc.toplevel.to_sym, :t1, )
+       expect( @soc.cons[ :another_con ] ).to eq( {  mapping: [ { @soc.toplevel.to_sym => :t1}, {inst_a: :ifc_a} ] } )
+     end
+
+
+    end
+
+
+    describe "#set_param and #get_param" do
+
+      it "raises an error, if a parameter of unkonwn core is set" do
+        expect{ @soc.set_param( :a_unknown_core, :p1, 1234 ) }.
+          to raise_error( SOCMaker::ERR::ConsistenceError )
+      end
+
+      it "raises an error, if a parameter of unkonwn core is requested" do
+        expect{ @soc.get_param( :a_unknown_core, :p1 ) }.
+          to raise_error( SOCMaker::ERR::ConsistenceError )
+      end
+
+      it "raises an error, if a unknown parameter is set and requested" do
+        core_a = SOCMaker::CoreDef.new( "core_a", "core_a,v1", "top" )
+        parameter = SOCMaker::Parameter.new( "integer" )
+        core_a.inst_parameters[ :p1 ] = parameter
+        SOCMaker::lib.add_core( core_a ) 
+        @soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_a,v1" )
+        expect{ @soc.set_param( :inst_a, :px, 1234 ) }.
+          to raise_error( SOCMaker::ERR::ConsistenceError )
+        expect{ @soc.get_param( :inst_a, :px ) }.
+          to raise_error( SOCMaker::ERR::ConsistenceError )
+      end
+
+      it "sets a parameter and provides a parameter" do
+        core_a = SOCMaker::CoreDef.new( "core_a", "core_a,v1", "top" )
+        parameter = SOCMaker::Parameter.new( "integer" )
+        core_a.inst_parameters[ :p1 ] = parameter
+        SOCMaker::lib.add_core( core_a ) 
+        @soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_a,v1" )
+        @soc.set_param( :inst_a, :p1, 1234 )
+        expect( @soc.cores[ :inst_a ].params[ :p1 ] ).to be( 1234 )
+        expect( @soc.get_param( :inst_a, :p1 ) ).to be( 1234 )
+      end
+    end
+
+    describe "#set_sparam and #get_sparam" do
+
+      it "raise an error, if a static-parameter of unkonwn core is set" do
+        expect{ @soc.set_sparam( :a_unknown_core, :p1, 1234 ) }.
+          to raise_error( SOCMaker::ERR::ProcessingError )
+      end
+
+      it "raise an error, if a statoc-parameter of unkonwn core is requested" do
+        expect{ @soc.get_sparam( :a_unknown_core, :p1 ) }.
+          to raise_error( SOCMaker::ERR::ConsistenceError )
+      end
+
+      it "raises an error, a static parameter doesn't exist" do
+
+        core_a = SOCMaker::CoreDef.new( "core_a", "core_a,v1", "top" )
+        SOCMaker::lib.add_core( core_a ) 
+        @soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_a,v1" )
+
+        expect{ @soc.set_sparam( :"core_a,v1", :p1, 1234 ) }.
+          to raise_error( SOCMaker::ERR::ProcessingError )
+        expect{ @soc.get_sparam( :"core_a,v1", :p1 ) }.
+          to raise_error( SOCMaker::ERR::ConsistenceError )
+      end
+
+      it "sets a static-parameter and provides this static parameter" do
+
+        core_a = SOCMaker::CoreDef.new( "core_a", "core_a,v1", "top" )
+        pentry = SOCMaker::SParameterEntry.new( "integer", "TOK" )
+        parameter = SOCMaker::SParameter.new( "file/path.vhd.src", 
+                                              "file/path.vhd", 
+                                              'parameters' => { p1: pentry } )
+        core_a.static_parameters[ :p1 ] = parameter
+        SOCMaker::lib.add_core( core_a ) 
+        @soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_a,v1" )
+
+        @soc.set_sparam( :"core_a,v1", :p1, 1234 )
+        @soc.static[ "core_a,v1".to_sym ][ :p1 ].should be == 1234
+        @soc.get_sparam( :"core_a,v1", :p1 ).should be == 1234
+      end
+
+    end
+
+    describe "#to_s" do
+      it "creates some string representation" do
+        ifc_spc = SOCMaker::IfcSpc.new( "myifc", "v1", 'ports' => { port_a: {dir:1}, port_b: {dir:0} } )
+        ifc_def_0 = SOCMaker::IfcDef.new( "myifc", "v1", 1, { a: SOCMaker::IfcPort.new( "port_a", 1 ), 
+                                                              b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
+        SOCMaker::lib.add_ifc( ifc_spc )
+        @soc.interfaces[ :t1 ] = ifc_def_0
+        @soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.cores[ :core_b ] = SOCMaker::CoreInst.new( "mycore,rel1" )
+        @soc.add_connection(  :new_connection, :core_a, :ifc_a, :core_b, :ifc_b ) 
+        expect( @soc.to_s ).not_to be_nil 
+        expect( @soc.to_s.size ).to be > 0 
+      end
+    end
+
+
+
+    describe "object handling and en/decoding:" do
+
+      it "should be possible to encode and decode a core instance" do
+        yaml_str = @soc.to_yaml
+        o2 = YAML::load( yaml_str )
+        @soc.should be == o2
+      end
+
+      it "should return false for two non-equal objects" do
+        o2 = Marshal::load(Marshal.dump(@soc))
+        o2.name << "X"
+        ( o2 == @soc ).should be == false
+      end
+
+    end
+
+
+  end
+
+
+  describe "#consistence_check" do
+    before( :each )do
+      @soc = SOCMaker::SOCDef.new( "Test SOC", "test-soc,v1", "my_soc_top" )
+    end
+    context "error handling" do
+      it "raises an error, if a inconsistent connection exists" do
+        @soc.cons[ :a_con ] = {  mapping: [ {inst_a: :ifc01}, {inst_b: :ifc01} ] }
+        expect{ @soc.consistence_check }.to raise_error( SOCMaker::ERR::ConsistenceError )
+      end
+    end
+  end
+
+
+
+  describe "#gen_toplevel" do
+
+    before( :each ) do
+
+      @soc = SOCMaker::SOCDef.new( "test_soc", "test_soc,v1", "my_soc_top" )
+
+
+      @coder = double()
+
+      @added_cores = {}
+      @coder.stub( :add_core_component ) do |name_arg, def_arg|
+        @added_cores[ name_arg.to_sym ] = def_arg
+      end
+
+      @added_instances = {} 
+      @coder.stub( :add_core_instance ) do |name_arg, inst_arg|
+        @added_instances[ name_arg.to_sym ] = inst_arg
+      end
+
+      @coder.stub( :get_hdl_code ){ |arg_coder| }
+
+      @coder.stub( :is_a? ){ SOCMaker::VHDLCoder }
+
+      @coder.stub( :filename ){ |x| x + ".vhd" }
+
+      @coder.stub( :add_ifc_default_assignment )
+
+      @coder.stub( :add_ifc_connection )
+
+      @coder.stub( :add_toplevel_sig )
+
+      @added_cons = {}
+
+      @dir_path = ""
+      FileUtils.stub( :mkdir_p ) { |arg| @dir_path = arg }
+      SOCMaker::conf[ :build_dir ] = 'a'
+      SOCMaker::conf[ :hdl_dir   ] = 'b'
+      @dir_path_ref = "a/b/test_soc_v1"
+
+
+
+
+      @core_a = SOCMaker::CoreDef.new( "core_a", "core_a,v1", "top" )
+      @core_b = SOCMaker::CoreDef.new( "core_b", "core_b,v1", "top" )
+      SOCMaker::lib.add_core( @core_a ) 
+      SOCMaker::lib.add_core( @core_b ) 
+
+      ifc_spc = SOCMaker::IfcSpc.new( "myifc", "myifc,v1", 'ports' => { port_a: { dir: 1}, port_b: { dir: 0 } } )
+      SOCMaker::lib.add_ifc( ifc_spc )
+      ifc_def_1 = SOCMaker::IfcDef.new( "myifc", "myifc,v1", 0, { a: SOCMaker::IfcPort.new( "port_a", 1 ), 
+                                                                  b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
+
+      ifc_def_0 = SOCMaker::IfcDef.new( "myifc", "myifc,v1", 1, { a: SOCMaker::IfcPort.new( "port_a", 1 ), 
+                                                                  b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
+
+
+      @core_a.interfaces[ :ifc_a ] = ifc_def_0
+      @core_a.interfaces[ :ifc_b ] = ifc_def_1
+      @core_b.interfaces[ :ifc_a ] = ifc_def_0
+      @core_b.interfaces[ :ifc_b ] = ifc_def_1
+
+
+      @i1 = SOCMaker::CoreInst.new( "core_a,v1" )
+      @i2 = SOCMaker::CoreInst.new( "core_a,v1" )
+      @i3 = SOCMaker::CoreInst.new( "core_b,v1" )
+      @i4 = SOCMaker::CoreInst.new( "core_b,v1" )
+
+      @soc.cores[ :inst_a ] = @i1 
+      @soc.cores[ :inst_b ] = @i2 
+      @soc.cores[ :inst_c ] = @i3 
+      @soc.cores[ :inst_d ] = @i4 
+      @soc.add_connection( :a_new_con, :inst_a, :ifc_a, :inst_b, :ifc_b  )
+
+      @soc.stub( :gen_toplevel_con ) do |name_arg,
+                                         m0_arg,
+                                         m1_arg |
+        @added_cons[ name_arg.to_sym ] = { m0: m0_arg, m1: m1_arg }
+      end
+
+      # file writing stub
+      file_mock = double()
+      file_mock.stub( :write )
+      File.should_receive(:open).and_yield(file_mock)
+    end
+
+    after( :each ) do
+      SOCMaker::lib.clear
+    end
+
+    it "calls all necessary coder functions (stub-version)" do
+
+      @soc.gen_toplevel( @coder );
+      expect( @added_cores )    .to eq( { "core_a,v1".to_sym => @core_a, "core_b,v1".to_sym => @core_b } )
+      expect( @added_instances ).to eq( { inst_a: @i1, inst_b: @i2, inst_c: @i3, inst_d: @i4 }           )
+      expect( @added_cons )     .to eq( { a_new_con: { m0: {inst_b: :ifc_b } , m1: {inst_a: :ifc_a} } }  )
+      expect( @dir_path )       .to eq( File.expand_path( @dir_path_ref )                                )
+    end
+  end
+
+  describe "#deploy" do
+
+    after( :each ) do
+      SOCMaker::lib.clear
+    end
+
+    it "creates valid vhdl output with our test library" do
+
+      SOCMaker::conf[ :build_dir ] = 'spec/tmp_build'
+      SOCMaker::conf[ :hdl_dir   ] = 'b'
+      coder = SOCMaker::VHDLCoder.new
+      SOCMaker::lib.refresh( './spec/test_soc_lib' )
+      soc = SOCMaker::from_f( './spec/test_soc.yaml' );
+      SOCMaker::lib.add_core( soc )
+
+      SOCMaker::deploy_soc( soc, coder )
+    end
+
+
+    it "creates valid vhdl output with our test library (hierarchical example)" do
+
+      SOCMaker::conf[ :build_dir ] = 'spec/tmp_build'
+      SOCMaker::conf[ :hdl_dir   ] = 'xyz'
+
+      SOCMaker::lib.refresh( './spec/test_soc_lib' )
+      soc = SOCMaker::from_f( './spec/test_soc.yaml' );
+      SOCMaker::lib.add_core( soc )
+
+      soc_top = SOCMaker::from_f( './spec/test_soc2.yaml' );
+      SOCMaker::lib.add_core( soc_top )
+      SOCMaker::deploy_soc( soc_top, SOCMaker::VHDLCoder.new )
+    end
+  end
+
+
+end
+
+
+
+
+# vim: noai:ts=2:sw=2