Subversion Repositories soc_maker

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

#

#  File:      core_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 specification for SOCMaker::CoreDef

#

#

#

#

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

require_relative( 'spec_helper' )

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

  valid_yamls = []

  invalid_v_yamls = []

  invalid_s_yamls = []

  #

  # A yaml example, which contains

  #   - a full definition

  #   - an interface with one port

  #   - one hdl file

  #   - one instance parameter

  #   - one static parameter

  #

  FULL_YAML = '''SOCM_CORE

name: core_A

description: A test IP-core

id: core_A,rel1

date: 1.1.2014

license: LGPL

licensefile:

author: Christian Haettich

authormail: feddischson@opencores.org

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

toplevel: core_a

interfaces:

  :ifc01: SOCM_IFC

    name: core_AB_ifc

    dir: 0

    id: core_AB_ifc,1

    ports:

      :sig_con1a: SOCM_PORT

         defn: sig_a

         len:  param1

hdlfiles:

   :core_a.vhd: SOCM_HDL_FILE

      use_syn: true

      use_sys_sim: true

      use_mod_sim: true

      type: vhdl

      path: ./core_a.vhd

inst_parameters:

  :param1: SOCM_PARAM

    type: integer

    default: 8

    min: 0

    max: 10

    visible: true

    editable: true

    description: More setup

static_parameters:

  :core_a_pkg.vhd.src: SOCM_SPARAM

    path: ./core_a.pkg.src

    file_dst: core_a_pkg.vhd

    parameters:

      :p1: SOCM_SENTRY

        token: TOK1

        type: integer

        min:  0

        max:  100

        visible: true

        editable: true

        default: 3

        description: Some setup

'''

  valid_yamls << {  desc: 'should return a class of type CoreDef when loading a full core-def',

                    yaml: FULL_YAML }

  # minimalistic def with one vhdl file

  MIN_YAML1 = '''SOCM_CORE

name: core_A

id: core_A,rel1

toplevel: top_A

hdlfiles:

   :core_a.vhd: SOCM_HDL_FILE

      path: ./core_a.vhd

'''

  valid_yamls << {  desc: 'should return a class of type CoreDef when loading a minimal core-def',

                    yaml: MIN_YAML1 }

  # minimalistic def with one

  # vhdl and one verilog file

  MIN_YAML2 = '''SOCM_CORE

name: core_A

id: core_A,rel1

toplevel: top_A

hdlfiles:

   :core_a.vhd: SOCM_HDL_FILE

      path: ./core_a.vhd

   :core_b.v: SOCM_HDL_FILE

      path: ./core_b.v

'''

  valid_yamls << {  desc: 'should return a class of type CoreDef when loading a core-def with two files',

                    yaml: MIN_YAML2 }

#    # def with version.size == 0

#    F_YAML_VERSION = '''SOCM_CORE

#  name: core_A

#  version: ''

#  toplevel: top_A

#  hdlfiles:

#     :core_a.vhd: SOCM_HDL_FILE

#        path: ./core_a.vhd

#  '''

#    invalid_s_yamls << {  desc: 'should raise an error if version is a string with length 0',

#                          yaml: F_YAML_VERSION }

#    # def with name.size == 0

#    F_YAML_NAME = '''SOCM_CORE

#  name: ''

#  version: rel1

#  toplevel: top_A

#  hdlfiles:

#     :core_a.vhd: SOCM_HDL_FILE

#        path: ./core_a.vhd

#  '''

#    invalid_s_yamls << {  desc: 'should raise an error if name is a string with length 0',

#                          yaml: F_YAML_NAME }

  # def with toplevel.size == 0

  F_YAML_TOPLEVEL = '''SOCM_CORE

name: core_A

id: core_A,rel1

toplevel: ''

hdlfiles:

   :core_a.vhd: SOCM_HDL_FILE

      path: ./core_a.vhd

'''

  invalid_s_yamls << {  desc: 'should raise an error if toplevel is a string with length 0',

                        yaml: F_YAML_TOPLEVEL }

  # def with hdlfiles.class != Hash

  F_YAML_FILE_HASH = '''SOCM_CORE

name: core_A

id: core_A,rel1

toplevel: top_A

hdlfiles:

   - test1.vhd

   - test2.vhd

'''

  invalid_s_yamls << {  desc: 'should raise an error if hdlfiles is not a hash',

                        yaml: F_YAML_FILE_HASH }

  # minimal setup with one interface

  MIN_YAML_IFC = '''SOCM_CORE

name: core_A

id: core_A,rel1

toplevel: top_A

hdlfiles:

   :core_a.vhd: SOCM_HDL_FILE

      path: ./core_a.vhd

interfaces:

  :ifc01: SOCM_IFC

    name: a_ifc_def

    dir: 0

    id: a_ifc_def,1

    ports:

      :sig_con1a: SOCM_PORT

         defn: sig_a

'''

  valid_yamls << { desc: 'should return a class of type CoreDef when loading a minimal core-def with a minimal interface',

                   yaml: MIN_YAML_IFC }

  # minimal setup with one instance parameter

  MIN_YAML_INSTP = '''SOCM_CORE

name: core_A

id: core_A,rel1

toplevel: top_A

hdlfiles:

   :core_a.vhd: SOCM_HDL_FILE

      path: ./core_a.vhd

inst_parameters:

  :param1: SOCM_PARAM

    type: integer

'''

  valid_yamls << {  desc: 'should return a class of type CoreDef when loading a minimal core-def (with instance param.)',

                    yaml: MIN_YAML_INSTP }

  # empty hash for param1

  F_YAML_INSTP_EMPTY = '''SOCM_CORE

name: core_A

id: core_A,rel1

toplevel: top_A

hdlfiles:

   :core_a.vhd: SOCM_HDL_FILE

      path: ./core_a.vhd

inst_parameters:

  :param1: SOCM_PARAM

'''

  invalid_s_yamls << {  desc: 'should raise an error if an instance param. is empty',

                        yaml: F_YAML_INSTP_EMPTY }

  # minimal def with one static parameter

  MIN_YAML_STATIC = '''SOCM_CORE

name: core_A

id: core_A,rel1

toplevel: top_A

hdlfiles:

   :core_a.vhd: SOCM_HDL_FILE

      path: ./core_a.vhd

static_parameters:

  :a_file.vhd.src: SOCM_SPARAM

    file_dst: a_file.vhd

    path: ./core_a.vhd

    parameters:

      :p1:  SOCM_SENTRY

        type: integer

        token: T1

'''

  valid_yamls << {  desc: 'should return a class of type CoreDef when loading a minimal core-def (with static param.)',

                    yaml: MIN_YAML_STATIC }

  # empty static parameter

  F_YAML_STATIC_EMPTY = '''SOCM_CORE

name: core_A

id: core_A,rel1

toplevel: top_A

hdlfiles:

   :core_a.vhd: SOCM_HDL_FILE

      path: ./core_a.vhd

static_parameters:

  :a_file.vhd: SOCM_SPARAM

'''

  invalid_s_yamls << {  desc: 'should raise an error if a static parameters is empty',

                        yaml: F_YAML_STATIC_EMPTY }

  # removed: 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

  it "should return a CoreDef object, if the object is created via new" do

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

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

    c.class.should be == SOCMaker::CoreDef

  end

  # process all valid YAMLs

  #  each should result in a CoreDef

  valid_yamls.each do |setup|

    it setup[:desc] do

      SOCMaker::from_s( setup[:yaml] ).class.should == SOCMaker::CoreDef

    end

  end

  # process all invalid YAMLs

  #  each should result in a StructureError

  invalid_s_yamls.each do |setup|

    it setup[:desc] do

      expect { SOCMaker::from_s( setup[ :yaml ] ) }.

        to raise_error( SOCMaker::ERR::StructureError )

    end

  end

  # process all invalid YAMLs

  #  each should result in a ValueError

  invalid_v_yamls.each do |setup|

    it setup[:desc] do

      expect { SOCMaker::from_s( setup[ :yaml ] ) }.

        to raise_error( SOCMaker::ERR::ValueError )

    end

  end

  #

  # remove some entries in the basic definition

  #   It is ok, when the first line is not available:

  #   In this case, we assume, that something unrelated

  #   to SOCMaker is loaded

  #

  min_yaml_lines = MIN_YAML1.lines

  (1..min_yaml_lines.size-1).each do |i|

    min_yaml_lines.delete_at( i )

    inval_yaml = min_yaml_lines.join

    it 'should raise an error if loading of an invalid yaml is done (A)' do

      expect { SOCMaker::from_s( inval_yaml ) }.

        to raise_error

    end

    min_yaml_lines = MIN_YAML1.lines

  end

  # remove entries in the interface definition

  #

  min_yaml_lines = MIN_YAML_IFC.lines

  (9..min_yaml_lines.size-1).each do |i|

    min_yaml_lines.delete_at( i )

    inval_yaml = min_yaml_lines.join

    it 'should raise an error if loading of an invalid yaml is done (B)' do

      expect { SOCMaker::from_s( inval_yaml ) }.

        to raise_error

    end

    min_yaml_lines = MIN_YAML_IFC.lines

  end

  # auto-completion of basic info

  #

  it 'should return an CoreDef object with non-nil parameters, even if parameters are not specified' do

    tmp = SOCMaker::from_s( MIN_YAML2 )

    tmp.class.should be                 == SOCMaker::CoreDef

    tmp.vccmd.should_not be             == nil

    tmp.description.should_not be       == nil

    tmp.date.should_not be              == nil

    tmp.license.should_not be           == nil

    tmp.licensefile.should_not be       == nil

    tmp.author.should_not be            == nil

    tmp.authormail.should_not be        == nil

    tmp.vccmd.should_not be             == nil

    tmp.interfaces.should_not be        == nil

    tmp.functions.should_not be         == nil

    tmp.inst_parameters.should_not be   == nil

    tmp.static_parameters.should_not be == nil

    tmp.hdlfiles[ 'core_a.vhd'.to_sym ].type        .should be == 'vhdl'

    tmp.hdlfiles[ 'core_b.v'.to_sym   ].type        .should be == 'verilog'

    tmp.hdlfiles[ 'core_a.vhd'.to_sym ].use_syn     .should be == true

    tmp.hdlfiles[ 'core_a.vhd'.to_sym ].use_sys_sim .should be == true

    tmp.hdlfiles[ 'core_a.vhd'.to_sym ].use_mod_sim .should be == true

  end

  # auto-completion of interface setups

  #

  it 'should auto-complete the field length to 1 when loading a minimal core-def with a minimal interface' do

    tmp = SOCMaker::from_s( MIN_YAML_IFC )

    tmp.interfaces[ :ifc01 ].ports[ :sig_con1a ].len.should == 1

  end

  # auto-completion of static-parameters

  #

  it 'should auto-complete static parameter setup to non-nil values when loading a minimal core-def' do

    tmp = SOCMaker::from_s( MIN_YAML_STATIC )

    tmp.static_parameters[ :'a_file.vhd.src'].parameters[ :p1 ].default.should be     == 0

    tmp.static_parameters[ :'a_file.vhd.src'].parameters[ :p1 ].min.should be         == 0

    tmp.static_parameters[ :'a_file.vhd.src'].parameters[ :p1 ].max.should be         == 0

    tmp.static_parameters[ :'a_file.vhd.src'].parameters[ :p1 ].visible.should be     == true

    tmp.static_parameters[ :'a_file.vhd.src'].parameters[ :p1 ].editable.should be    == false

    tmp.static_parameters[ :'a_file.vhd.src'].parameters[ :p1 ].description.should be == ''

  end

  # auto-completion of instance-parameters

  #

  it 'should auto-complete inst. parameter setup to non-nil values when a minimal core-def' do

    tmp = SOCMaker::from_s( MIN_YAML_INSTP )

    tmp.inst_parameters[ :param1 ].min          .should be  == 0

    tmp.inst_parameters[ :param1 ].max          .should be  == 0

    tmp.inst_parameters[ :param1 ].default      .should be  == 0

    tmp.inst_parameters[ :param1 ].visible      .should be  == true

    tmp.inst_parameters[ :param1 ].editable     .should be  == false

    tmp.inst_parameters[ :param1 ].description  .should be  == ''

  end

  # This is a valid version which we manipulate and

  # test, if the manipulation is detected/corrected

# tmp = SOCMaker::from_s( FULL_YAML )

#

#

#

#

# it 'should raise an error if ifc-name is not a string' do

#   tmp.interfaces[ :ifc01 ].name  = 4

#   expect { SOCMaker::from_s( SOCMaker::YPP.from_yaml( tmp.to_yaml ) ) }.

#     to raise_error( SOCMaker::ERR::ValueError )

#   tmp.interfaces[ :ifc01 ].name = 'name'

# end

#

# it 'should raise an error if ifc-dir is not 0 or 1' do

#   tmp.interfaces[ :ifc01 ].dir  = 4

#   expect { SOCMaker::from_s( SOCMaker::YPP.from_yaml( tmp.to_yaml ) ) }.

#     to raise_error( SOCMaker::ERR::ValueError )

#

#   tmp.interfaces[ :ifc01 ].dir  = "test"

#   expect { SOCMaker::from_s( SOCMaker::YPP.from_yaml( tmp.to_yaml )  ) }.

#     to raise_error( SOCMaker::ERR::ValueError )

#   tmp.interfaces[ :ifc01 ].dir = 0

# end

#

# it 'should convert an interface version from numerical to string' do

#   tmp.interfaces[ :ifc01 ].version = 4

#   tmp2 = SOCMaker::from_s( SOCMaker::YPP.from_yaml( tmp.to_yaml ) )

#   tmp2.interfaces[ :ifc01 ].version.class.should be == String

# end

end

describe SOCMaker::CoreDef, "object handling, en-decoding:" do

  it "should be possible to encode and decode a core definition" do

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

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

    yaml_str = o1.to_yaml

    o2 = YAML::load( yaml_str )

    o1.should be == o2

  end

  it "should return false for two non-equal objects" do

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

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

    o2 = Marshal::load(Marshal.dump(o1))

    o2.id = "acore,v2"

    ( o2 == o1 ).should be == false

    o2 = Marshal::load(Marshal.dump(o1))

    o2.hdlfiles[ "file.vhd".to_sym ].use_syn = false

    ( o2 == o1 ).should be == false

  end

# tmp = SOCMaker::from_s( FULL_YAML )

# tmp.save_def( "./test.yaml" )

end

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