github.com/blueinnovationsgroup/can-go@v0.0.0-20230518195432-d0567cda0028/internal/generate/compile_test.go (about)

     1  package generate
     2  
     3  import (
     4  	"os"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/blueinnovationsgroup/can-go/pkg/descriptor"
     9  	examplecan "github.com/blueinnovationsgroup/can-go/testdata/gen/go/example"
    10  	"gotest.tools/v3/assert"
    11  )
    12  
    13  func TestCompile_ExampleDBC(t *testing.T) {
    14  	finish := runTestInDir(t, "../..")
    15  	defer finish()
    16  	const exampleDBCFile = "testdata/dbc/example/example.dbc"
    17  	const examplePackageName = "example"
    18  	exampleDatabase := &descriptor.Database{
    19  		SourceFile:  exampleDBCFile,
    20  		PackageName: examplePackageName,
    21  		Version:     "",
    22  		Nodes: []*descriptor.Node{
    23  			{
    24  				Name: "DBG",
    25  			},
    26  			{
    27  				Name:        "DRIVER",
    28  				Description: "The driver controller driving the car",
    29  			},
    30  			{
    31  				Name: "IO",
    32  			},
    33  			{
    34  				Name:        "MOTOR",
    35  				Description: "The motor controller of the car",
    36  			},
    37  			{
    38  				Name:        "SENSOR",
    39  				Description: "The sensor controller of the car",
    40  			},
    41  		},
    42  
    43  		Messages: []*descriptor.Message{
    44  			{
    45  				ID:         1,
    46  				Name:       "EmptyMessage",
    47  				SenderNode: "DBG",
    48  			},
    49  
    50  			{
    51  				ID:          100,
    52  				Name:        "DriverHeartbeat",
    53  				Length:      1,
    54  				SenderNode:  "DRIVER",
    55  				Description: "Sync message used to synchronize the controllers",
    56  				SendType:    descriptor.SendTypeCyclic,
    57  				CycleTime:   time.Second,
    58  				Signals: []*descriptor.Signal{
    59  					{
    60  						Name:          "Command",
    61  						Start:         0,
    62  						Length:        8,
    63  						Scale:         1,
    64  						ReceiverNodes: []string{"SENSOR", "MOTOR"},
    65  						ValueDescriptions: []*descriptor.ValueDescription{
    66  							{Value: 0, Description: "None"},
    67  							{Value: 1, Description: "Sync"},
    68  							{Value: 2, Description: "Reboot"},
    69  							{Value: 3, Description: "Headlights On"},
    70  						},
    71  					},
    72  				},
    73  			},
    74  
    75  			{
    76  				ID:         101,
    77  				Name:       "MotorCommand",
    78  				Length:     1,
    79  				SenderNode: "DRIVER",
    80  				SendType:   descriptor.SendTypeCyclic,
    81  				CycleTime:  100 * time.Millisecond,
    82  				Signals: []*descriptor.Signal{
    83  					{
    84  						Name:          "Steer",
    85  						Start:         0,
    86  						Length:        4,
    87  						IsSigned:      true,
    88  						Scale:         1,
    89  						Offset:        -5,
    90  						Min:           -5,
    91  						Max:           5,
    92  						ReceiverNodes: []string{"MOTOR"},
    93  					},
    94  					{
    95  						Name:          "Drive",
    96  						Start:         4,
    97  						Length:        4,
    98  						Scale:         1,
    99  						Max:           9,
   100  						ReceiverNodes: []string{"MOTOR"},
   101  					},
   102  				},
   103  			},
   104  
   105  			{
   106  				ID:         200,
   107  				Name:       "SensorSonars",
   108  				Length:     8,
   109  				SenderNode: "SENSOR",
   110  				SendType:   descriptor.SendTypeCyclic,
   111  				CycleTime:  100 * time.Millisecond,
   112  				Signals: []*descriptor.Signal{
   113  					{
   114  						Name:          "Mux",
   115  						IsMultiplexer: true,
   116  						Start:         0,
   117  						Length:        4,
   118  						Scale:         1,
   119  						ReceiverNodes: []string{"DRIVER", "IO"},
   120  					},
   121  					{
   122  						Name:          "ErrCount",
   123  						Start:         4,
   124  						Length:        12,
   125  						Scale:         1,
   126  						ReceiverNodes: []string{"DRIVER", "IO"},
   127  					},
   128  					{
   129  						Name:             "Left",
   130  						IsMultiplexed:    true,
   131  						MultiplexerValue: 0,
   132  						Start:            16,
   133  						Length:           12,
   134  						Scale:            0.1,
   135  						ReceiverNodes:    []string{"DRIVER", "IO"},
   136  					},
   137  					{
   138  						Name:             "NoFiltLeft",
   139  						IsMultiplexed:    true,
   140  						MultiplexerValue: 1,
   141  						Start:            16,
   142  						Length:           12,
   143  						Scale:            0.1,
   144  						ReceiverNodes:    []string{"DBG"},
   145  					},
   146  					{
   147  						Name:             "Middle",
   148  						IsMultiplexed:    true,
   149  						MultiplexerValue: 0,
   150  						Start:            28,
   151  						Length:           12,
   152  						Scale:            0.1,
   153  						ReceiverNodes:    []string{"DRIVER", "IO"},
   154  					},
   155  					{
   156  						Name:             "NoFiltMiddle",
   157  						IsMultiplexed:    true,
   158  						MultiplexerValue: 1,
   159  						Start:            28,
   160  						Length:           12,
   161  						Scale:            0.1,
   162  						ReceiverNodes:    []string{"DBG"},
   163  					},
   164  					{
   165  						Name:             "Right",
   166  						IsMultiplexed:    true,
   167  						MultiplexerValue: 0,
   168  						Start:            40,
   169  						Length:           12,
   170  						Scale:            0.1,
   171  						ReceiverNodes:    []string{"DRIVER", "IO"},
   172  					},
   173  					{
   174  						Name:             "NoFiltRight",
   175  						IsMultiplexed:    true,
   176  						MultiplexerValue: 1,
   177  						Start:            40,
   178  						Length:           12,
   179  						Scale:            0.1,
   180  						ReceiverNodes:    []string{"DBG"},
   181  					},
   182  					{
   183  						Name:             "Rear",
   184  						IsMultiplexed:    true,
   185  						MultiplexerValue: 0,
   186  						Start:            52,
   187  						Length:           12,
   188  						Scale:            0.1,
   189  						ReceiverNodes:    []string{"DRIVER", "IO"},
   190  					},
   191  					{
   192  						Name:             "NoFiltRear",
   193  						IsMultiplexed:    true,
   194  						MultiplexerValue: 1,
   195  						Start:            52,
   196  						Length:           12,
   197  						Scale:            0.1,
   198  						ReceiverNodes:    []string{"DBG"},
   199  					},
   200  				},
   201  			},
   202  
   203  			{
   204  				ID:         400,
   205  				Name:       "MotorStatus",
   206  				Length:     3,
   207  				SenderNode: "MOTOR",
   208  				SendType:   descriptor.SendTypeCyclic,
   209  				CycleTime:  100 * time.Millisecond,
   210  				Signals: []*descriptor.Signal{
   211  					{
   212  						Name:          "WheelError",
   213  						Start:         0,
   214  						Length:        1,
   215  						Scale:         1,
   216  						ReceiverNodes: []string{"DRIVER", "IO"},
   217  					},
   218  					{
   219  						Name:          "SpeedKph",
   220  						Start:         8,
   221  						Length:        16,
   222  						Scale:         0.001,
   223  						Unit:          "km/h",
   224  						ReceiverNodes: []string{"DRIVER", "IO"},
   225  					},
   226  				},
   227  			},
   228  
   229  			{
   230  				ID:         500,
   231  				Name:       "IODebug",
   232  				Length:     6,
   233  				SenderNode: "IO",
   234  				SendType:   descriptor.SendTypeEvent,
   235  				Signals: []*descriptor.Signal{
   236  					{
   237  						Name:          "TestUnsigned",
   238  						Start:         0,
   239  						Length:        8,
   240  						Scale:         1,
   241  						ReceiverNodes: []string{"DBG"},
   242  					},
   243  					{
   244  						Name:          "TestEnum",
   245  						Start:         8,
   246  						Length:        6,
   247  						Scale:         1,
   248  						ReceiverNodes: []string{"DBG"},
   249  						DefaultValue:  int(examplecan.IODebug_TestEnum_Two),
   250  						ValueDescriptions: []*descriptor.ValueDescription{
   251  							{Value: 1, Description: "One"},
   252  							{Value: 2, Description: "Two"},
   253  						},
   254  					},
   255  					{
   256  						Name:          "TestSigned",
   257  						Start:         16,
   258  						Length:        8,
   259  						IsSigned:      true,
   260  						Scale:         1,
   261  						ReceiverNodes: []string{"DBG"},
   262  					},
   263  					{
   264  						Name:          "TestFloat",
   265  						Start:         24,
   266  						Length:        8,
   267  						Scale:         0.5,
   268  						ReceiverNodes: []string{"DBG"},
   269  					},
   270  					{
   271  						Name:          "TestBoolEnum",
   272  						Start:         32,
   273  						Length:        1,
   274  						Scale:         1,
   275  						ReceiverNodes: []string{"DBG"},
   276  						ValueDescriptions: []*descriptor.ValueDescription{
   277  							{Value: 0, Description: "Zero"},
   278  							{Value: 1, Description: "One"},
   279  						},
   280  					},
   281  					{
   282  						Name:          "TestScaledEnum",
   283  						Start:         40,
   284  						Length:        2,
   285  						Scale:         2,
   286  						Min:           0,
   287  						Max:           6,
   288  						ReceiverNodes: []string{"DBG"},
   289  						ValueDescriptions: []*descriptor.ValueDescription{
   290  							{Value: 0, Description: "Zero"},
   291  							{Value: 1, Description: "Two"},
   292  							{Value: 2, Description: "Four"},
   293  							{Value: 3, Description: "Six"},
   294  						},
   295  					},
   296  				},
   297  			},
   298  		},
   299  	}
   300  	input, err := os.ReadFile(exampleDBCFile)
   301  	assert.NilError(t, err)
   302  	result, err := Compile(exampleDBCFile, examplePackageName, input)
   303  	if err != nil {
   304  		t.Fatal(err)
   305  	}
   306  	if len(result.Warnings) > 0 {
   307  		t.Fatal(result.Warnings)
   308  	}
   309  	assert.DeepEqual(t, exampleDatabase, result.Database)
   310  }