Subversion Repositories soc_maker

###############################################################

#

#  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 .

#

#

###############################################################

#

#   Description:

#     Test spec. for SOCMaker::SOCDef

#

#

#

###############################################################

require_relative( 'spec_helper' )

describe SOCMaker::SOCDef, "structure verification for loading a core-definition" do

  # 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

  #

  # A yaml example, which contains

  #   - a full definition

  #   - an interface with one port

  #   - one hdl file

  #   - one instance parameter

  #   - one static parameter

  #

  FULL_SOC_YAML = '''SOCM_SOC

name: my_soc

description: A test SOC

version: rel2

date: 1.1.2014

license: LGPL

licensefile:

toplevel: soc_top

author: Christian Haettich

authormail: feddischson@opencores.org

repocmd: svn co http://some-address/

'''

SOC_YAML_WITH_CORE = '''SOCM_SOC

name: my_soc

description: A test SOC

version: rel2

date: 1.1.2014

license: LGPL

licensefile:

author: Christian Haettich

authormail: feddischson@opencores.org

repocmd: svn co http://some-address/

toplevel: soc_top

cores:

  :inst1: SOCM_INST

    type: mycorerel1

'''

  # process all valid YAMLs

  #  each should result in a CoreDef

  it 'should return a class of type SOCDef when loading a full soc-def' do

    SOCMaker::from_s( FULL_SOC_YAML ).class.should == SOCMaker::SOCDef

  end

  it "should rise an error if soc is loaded with a core, which is not in our library" do

    SOCMaker::lib.clear

    expect { SOCMaker::from_s( SOC_YAML_WITH_CORE ) }.

      to raise_error( SOCMaker::ERR::LibError )

  end

  it "should return an SOC-object if soc is loaded with a core, which is in our library" do

    file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }

    core = SOCMaker::CoreDef.new( "mycore", "rel1", file, "top" )

    SOCMaker::lib.add_core( core )

    soc = SOCMaker::from_s( SOC_YAML_WITH_CORE )

    soc.class.should be SOCMaker::SOCDef

  end

end

describe SOCMaker::SOCDef, "processing verification" do

    before( :each )do

      file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }

      core = SOCMaker::CoreDef.new( "mycore", "rel1", file, "top" )

      SOCMaker::lib.add_core( core )

      @soc = SOCMaker::SOCDef.new( "test-soc", "v1", "my_soc_top" )

    end

    describe "adding/removing cores, connections etc." do

      it "inst_in_use should return true, if there is already an core instance with that name" do

        @soc.cores[ :core_inst ] = SOCMaker::CoreInst.new( "mycorerel1" )

        @soc.inst_in_use?( "core_inst" ).should be == true

      end

      it "inst_in_use should return false, if there is no core instance with that name" do

        @soc.inst_in_use?( "core_inst" ).should 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 ] = { rule: "or", mapping: [ { :core_a => :ifc_a }, { :core_b => :ifc_b } ] }

        @soc.inst_in_use?( "a_con" ).should be == true

      end

      it "removing a core instance should be possible" do

        @soc.cores[ :core_inst ] = SOCMaker::CoreInst.new( "mycorerel1" )

        @soc.inst_in_use?( "core_inst" ).should be == true

        @soc.rm( "core_inst" ).should be == true

        @soc.inst_in_use?( "core_inst" ).should be == false

      end

      it "removing a connection instance should be possible" do

        @soc.cons[ :a_con ] = { rule: "or", mapping: [ { :core_a => :ifc_a }, { :core_b => :ifc_b } ] }

        @soc.inst_in_use?( "a_con" ).should be == true

        @soc.rm( "a_con" ).should be == true

        @soc.inst_in_use?( "a_con" ).should be == false

      end

      it "should return false, when removing a non-existance instance" do

        @soc.rm( "a_con" ).should be == false

      end

      it "should return nil if a instance is added twice" do

        @soc.cores[ :core_inst ] = SOCMaker::CoreInst.new( "mycorerel1" )

        @soc.add_core(  "mycore", "rel1", "core_inst" ).should be == false

      end

      it "should return non-nil value, if a instance is added once" do

        @soc.add_core(  "mycore", "rel1", "core_inst" ).should_not be == false

      end

      it "should return nil if a connection is added twice" do

        @soc.cons[ :a_con ] = { rule: "or", mapping: [ { :core_a => :ifc_a }, { :core_b => :ifc_b } ] }

        @soc.add_connection(  "core_a", "ifc_a", "core_c", "ifc_b", "a_con" ).should be == nil

      end

      it "should raise a library error when adding an unknown core" do

        expect{ @soc.add_core( "some_unknown_core", "v_xyz", "test" ) }.

          to raise_error( SOCMaker::ERR::LibError )

      end

      it "should create a dir and return the absolute path for a core inside the build/hdl dir" do

        SOCMaker::conf[ :build_dir ] = "./spec/tmp_build"

        SOCMaker::conf[ :hdl_dir   ] = "hdl"

        path = File.expand_path "./spec/tmp_build/hdl/a_core"

        FileUtils.rmdir( path ) if File.directory?( path )

        res = @soc.get_and_ensure_dst_dir!( "a_core" )

        File.directory?( path ).should be == true

        res.should be == path

      end

      it "should return false, when an interface is not used" do

        # setup interface ifc_b and ifc_c, test for ifc_a

        a_con = { rule: "or", mapping: [ { :core_a => :ifc_b }, { :core_b => :ifc_c } ] }

        @soc.cons[ :my_con ] = a_con

        @soc.ifc_in_use?( "core_a", "ifc_a" ).should be == false

      end

      it "should return true, if an interface is used" do

        a_con = { rule: "or", mapping: [ { :core_a => :ifc_a }, { :core_b => :ifc_b } ] }

        @soc.cons[ :my_con ] = a_con

        @soc.ifc_in_use?( "core_a", "ifc_a" ).should be == true

      end

      it "should raise an SOCMaker::ERR::ProcessingError add_connection tries to add a interface, wich is already used" do

        a_con = { rule: "or", mapping: [ { :core_a => :ifc_a }, { :core_b => :ifc_b } ] }

        @soc.cons[ :my_con ] = a_con

        expect{ @soc.add_connection(  "core_a", "ifc_a", "core_b", "ifc_c", "a_new_con" ) }.

          to raise_error( SOCMaker::ERR::ProcessingError )

        expect{ @soc.add_connection(  "core_a", "ifc_a", "core_c", "ifc_b", "a_new_con" ) }.

          to raise_error( SOCMaker::ERR::ProcessingError )

      end

      it "should raise an SOCMaker::ERR::ProcessingError if a connection is added from a non-existing core instance" do

        expect{ @soc.add_connection(  "core_a", "ifc_a", "core_c", "ifc_b", "a_new_con" ) }.

          to raise_error( SOCMaker::ERR::ProcessingError )

      end

      it "should raise an ProcessingError if a interface doesn't exist" do

        @soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "mycorerel1" )

        @soc.cores[ :core_b ] = SOCMaker::CoreInst.new( "mycorerel1" )

        expect{ @soc.add_connection(  "core_a", "ifc_a", "core_b", "ifc_c", "a_new_con" ) }.

          to raise_error( SOCMaker::ERR::ProcessingError )

      end

      it "should raise an ProcessingError if the ifc.-version is wrong" do

        ifc_spc1 = SOCMaker::IfcSpc.new( "myifc", "v1", 'ports' => { port_a: 1, port_b: 0 } )

        ifc_spc2 = SOCMaker::IfcSpc.new( "myifc", "v2", 'ports' => { port_a: 1, port_b: 0 } )

        ifc_def_1 = SOCMaker::IfcDef.new( "myifc", "v1", 0, { a: SOCMaker::IfcPort.new( "port_a", 1 ) } )

        ifc_def_0 = SOCMaker::IfcDef.new( "myifc", "v2", 1, { b: SOCMaker::IfcPort.new( "port_b", 1 ) } )

        file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }

        core_a = SOCMaker::CoreDef.new( "core_a", "v1", file, "top" )

        core_b = SOCMaker::CoreDef.new( "core_b", "v1", file, "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_av1" )

        @soc.cores[ :core_b ] = SOCMaker::CoreInst.new( "core_bv1" )

        expect { @soc.add_connection(  "inst_a", "ifc_a", "inst_b", "ifc_b", "a_new_con" ) }.

          to raise_error( SOCMaker::ERR::ProcessingError )

      end

      it "should add a connection entry" do

        ifc_spc = SOCMaker::IfcSpc.new( "myifc", "v1", 'ports' => { port_a: 1, port_b: 0 } )

        ifc_def_1 = SOCMaker::IfcDef.new( "myifc", "v1", 0, { a: SOCMaker::IfcPort.new( "port_a", 1 ) } )

        ifc_def_0 = SOCMaker::IfcDef.new( "myifc", "v1", 1, { b: SOCMaker::IfcPort.new( "port_b", 1 ) } )

        file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }

        core_a = SOCMaker::CoreDef.new( "core_a", "v1", file, "top" )

        core_b = SOCMaker::CoreDef.new( "core_b", "v1", file, "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_spc )

        SOCMaker::lib.add_core( core_a )

        SOCMaker::lib.add_core( core_b )

        @soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_av1" )

        @soc.cores[ :inst_b ] = SOCMaker::CoreInst.new( "core_bv1" )

        @soc.add_connection(  "inst_a", "ifc_a", "inst_b", "ifc_b", "a_new_con" )

        @soc.cons[ :a_new_con ].should be == { rule:'or', mapping: [ {inst_a: :ifc_a},{inst_b: :ifc_b} ] }

      end

      it "should raise 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::ProcessingError )

      end

      it "should raise an error, if a parameter of unkonwn core is requested" do

        expect{ @soc.get_param( "a_unknown_core", "p1" ) }.

          to raise_error( SOCMaker::ERR::ProcessingError )

      end

      it "should raise an error, if a unknown parameter is set and requested" do

        file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }

        core_a = SOCMaker::CoreDef.new( "core_a", "v1", file, "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_av1" )

        expect{ @soc.set_param( "inst_a", "px", 1234 ) }.

          to raise_error( SOCMaker::ERR::ProcessingError )

        expect{ @soc.get_param( "inst_a", "px" ) }.

          to raise_error( SOCMaker::ERR::ProcessingError )

      end

      it "should set a parameter and provide a parameter" do

        file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }

        core_a = SOCMaker::CoreDef.new( "core_a", "v1", file, "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_av1" )

        @soc.set_param( "inst_a", "p1", 1234 )

        @soc.cores[ :inst_a ].params[ :p1 ].should be == 1234

        @soc.get_param( "inst_a", "p1" ).should be == 1234

      end

      it "should 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 "should 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::ProcessingError )

      end

      it "should an error, a static parameter doesn't exist" do

        file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }

        core_a = SOCMaker::CoreDef.new( "core_a", "v1", file, "top" )

        SOCMaker::lib.add_core( core_a )

        @soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_av1" )

        expect{ @soc.set_sparam( "core_av1", "p1", 1234 ) }.

          to raise_error( SOCMaker::ERR::ProcessingError )

        expect{ @soc.get_sparam( "core_av1", "p1" ) }.

          to raise_error( SOCMaker::ERR::ProcessingError )

      end

      it "should set a static-parameter and provide this static parameter" do

        file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }

        core_a = SOCMaker::CoreDef.new( "core_a", "v1", file, "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_av1" )

        @soc.set_sparam( "core_av1", "p1", 1234 )

        @soc.static[ :core_av1 ][ :p1 ].should be == 1234

        @soc.get_sparam( "core_av1", "p1" ).should be == 1234

      end

      it "should call coder functions for each core-def. (stub-version)" do

        coder = double()

        added_cores = {}

        coder.stub( :add_core_declaration ) do |name_arg, def_arg|

          added_cores[ name_arg.to_sym ] = def_arg

        end

        added_instances = {}

        coder.stub( :add_core_inst ) do |name_arg, inst_arg|

          added_instances[ name_arg.to_sym ] = inst_arg

        end

        coder.stub( :get_entity ){ |arg_soc,arg_str| }

        coder.stub( :is_a? ){ SOCMaker::VHDLCoder }

        added_cons = {}

        @soc.stub( :gen_toplevel_con ) do |name_arg,

                                           rule_arg,

                                           m0_arg,

                                           m1_arg |

          added_cons[ name_arg.to_sym ] = { rule: rule_arg,

                                            m0: m0_arg, m1: m1_arg }

        end

        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"

        file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }

        core_a = SOCMaker::CoreDef.new( "core_a", "v1", file, "top" )

        core_b = SOCMaker::CoreDef.new( "core_b", "v1", file, "top" )

        SOCMaker::lib.add_core( core_a )

        SOCMaker::lib.add_core( core_b )

        ifc_spc = SOCMaker::IfcSpc.new( "myifc", "v1", 'ports' => { port_a: 1, port_b: 0 } )

        SOCMaker::lib.add_ifc( ifc_spc )

        ifc_def_1 = SOCMaker::IfcDef.new( "myifc", "v1", 0, { a: SOCMaker::IfcPort.new( "port_a", 1 ) } )

        ifc_def_0 = SOCMaker::IfcDef.new( "myifc", "v1", 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_av1" )

        i2 = SOCMaker::CoreInst.new( "core_av1" )

        i3 = SOCMaker::CoreInst.new( "core_bv1" )

        i4 = SOCMaker::CoreInst.new( "core_bv1" )

        @soc.cores[ :inst_a ] = i1

        @soc.cores[ :inst_b ] = i2

        @soc.cores[ :inst_c ] = i3

        @soc.cores[ :inst_d ] = i4

        @soc.add_connection(  "inst_a", "ifc_a", "inst_b", "ifc_b", "a_new_con" )

        # file writing stub

        file_mock = double()

        file_mock.stub( :write )

        File.should_receive(:open).and_yield(file_mock)

        @soc.gen_toplevel( coder )

        added_cores.should be == { :core_av1 => core_a, :core_bv1 => core_b }

        added_instances.should be == { inst_a: i1, inst_b: i2, inst_c: i3, inst_d: i4 }

        added_cons.should be == { a_new_con: { rule: "or", m0: {inst_a: :ifc_a}, m1: {inst_b: :ifc_b } } }

        dir_path.should be == dir_path_ref

      end

      it "should create valid vhdl output with our test library" do

        SOCMaker::conf[ :build_dir ] = 'spec/tmp_build2'

        SOCMaker::conf[ :hdl_dir   ] = 'b'

        coder = SOCMaker::VHDLCoder.new

        SOCMaker::lib.refresh( './spec/test_soc_lib' )

        soc = SOCMaker::from_f( './spec/test_soc.yaml' );

        soc.gen_toplevel( coder );

        soc.copy_files

       #p soc.cons

       #puts soc.to_yaml

      end

    end

  describe SOCMaker::SOCDef, "object handling, 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

# vim: noai:ts=2:sw=2