Format generated numbers according to their type (#39)

* Format generated numbers according to their type

* Add tests

Author: localhots

datamodel/datamodel_test.go

@@ -2,7 +2,6 @@ package datamodel
 
 import (
 	"errors"
-	"fmt"
 	"testing"
 	"time"
 
@@ -86,6 +85,76 @@ func TestGetValue(t *testing.T) {
 	assert.Equal(t, "Residential Gateway", param.Value)
 }
 
+func TestGetValueFormatGen(t *testing.T) {
+	const path1 = "Device.Ethernet.Interface.5.Stats.BytesReceived"
+	const path2 = "Device.Ethernet.Interface.5.Enabled"
+	t.Run("int", func(t *testing.T) {
+		state := newState()
+		dm := New(state.WithDefaults(map[string]Parameter{
+			path1: {
+				Path: path1,
+				Type: "xsd:int",
+				gen:  func() float64 { return 123.456 },
+			},
+		}))
+		param, ok := dm.GetValue(path1)
+		assert.True(t, ok)
+		assert.Equal(t, "123", param.GetValue())
+	})
+	t.Run("uint", func(t *testing.T) {
+		state := newState()
+		dm := New(state.WithDefaults(map[string]Parameter{
+			path1: {
+				Path: path1,
+				Type: "unsignedInt",
+				gen:  func() float64 { return 123.456 },
+			},
+		}))
+		param, ok := dm.GetValue(path1)
+		assert.True(t, ok)
+		assert.Equal(t, "123", param.GetValue())
+	})
+	t.Run("float", func(t *testing.T) {
+		state := newState()
+		dm := New(state.WithDefaults(map[string]Parameter{
+			path1: {
+				Path: path1,
+				Type: "double",
+				gen:  func() float64 { return 123.456 },
+			},
+		}))
+		param, ok := dm.GetValue(path1)
+		assert.True(t, ok)
+		assert.Equal(t, "123.456", param.GetValue())
+	})
+	t.Run("bool", func(t *testing.T) {
+		state := newState()
+		dm := New(state.WithDefaults(map[string]Parameter{
+			path2: {
+				Path: path2,
+				Type: "xsd:boolean",
+				gen:  func() float64 { return 1 },
+			},
+		}))
+		param, ok := dm.GetValue(path2)
+		assert.True(t, ok)
+		assert.Equal(t, "true", param.GetValue())
+	})
+	t.Run("unsupported", func(t *testing.T) {
+		state := newState()
+		dm := New(state.WithDefaults(map[string]Parameter{
+			path2: {
+				Path: path2,
+				Type: "xsd:string",
+				gen:  func() float64 { return 123 },
+			},
+		}))
+		param, ok := dm.GetValue(path2)
+		assert.True(t, ok)
+		assert.Equal(t, "", param.GetValue())
+	})
+}
+
 func TestGetValues(t *testing.T) {
 	state := newState()
 	dm := New(state.WithDefaults(map[string]Parameter{
@@ -106,7 +175,6 @@ func TestGetValues(t *testing.T) {
 		"Device.DeviceInfo.Description",
 		"Device.DeviceInfo.HardwareVersion",
 	)
-	fmt.Println(ok, params)
 	assert.True(t, ok)
 	assert.Len(t, params, 2)
 }

datamodel/noise/parser.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"regexp"
 	"strconv"
+
+	"github.com/localhots/SimulaTR69/rpc"
 )
 
 // Func represents a noise generator function with its name, arguments, and type.
@@ -58,6 +60,16 @@ func ParseDef(str string) (*Func, error) {
 		args[k] = val
 	}
 
+	// Validate return type
+	switch rpc.NoXSD(matches[3]) {
+	case rpc.TypeInt, rpc.TypeLong:
+	case rpc.TypeUnsignedInt, rpc.TypeUnsignedLong:
+	case rpc.TypeFloat, rpc.TypeDouble:
+	case rpc.TypeBoolean:
+	default:
+		return nil, fmt.Errorf("unsupported type: %s", matches[3])
+	}
+
 	return &Func{
 		Name: matches[1],
 		Args: args,

datamodel/noise/parser_test.go

@@ -73,6 +73,11 @@ func TestParseDef(t *testing.T) {
 			exp: nil,
 			err: "invalid generator definition",
 		},
+		{
+			in:  "foo(a=1) as banana",
+			exp: nil,
+			err: `unsupported type: banana`,
+		},
 	}
 
 	for _, tt := range tests {

datamodel/parameter.go

@@ -44,7 +44,18 @@ func (p Parameter) Name() string {
 // will be returned.
 func (p Parameter) GetValue() string {
 	if p.gen != nil {
-		return strconv.FormatFloat(p.gen(), 'f', -1, 64)
+		switch rpc.NoXSD(p.Type) {
+		case rpc.TypeInt, rpc.TypeLong:
+			return strconv.FormatInt(int64(p.gen()), 10)
+		case rpc.TypeUnsignedInt, rpc.TypeUnsignedLong:
+			return strconv.FormatUint(uint64(p.gen()), 10)
+		case rpc.TypeFloat, rpc.TypeDouble:
+			return strconv.FormatFloat(p.gen(), 'f', -1, 64)
+		case rpc.TypeBoolean:
+			return strconv.FormatBool(int(p.gen()) == 1)
+		default:
+			return ""
+		}
 	}
 	return p.Value
 }

rpc/xsd_types.go

@@ -1,5 +1,9 @@
 package rpc
 
+import (
+	"strings"
+)
+
 // List of supported types.
 const (
 	TypeObject       = "object"
@@ -19,6 +23,8 @@ const (
 	TypeIPv6Address  = "IPv6Address"
 	TypeIPv6Prefix   = "IPv6Prefix"
 	TypeMACAddress   = "MACAddress"
+	TypeFloat        = "float"
+	TypeDouble       = "double"
 
 	// TypeGenerator is a special type used to define a generator function.
 	TypeGenerator = "sim:generator"
@@ -28,3 +34,11 @@ const (
 func XSD(typ string) string {
 	return "xsd:" + typ
 }
+
+// NoXSD removes the XSD prefix from the type.
+func NoXSD(typ string) string {
+	if strings.HasPrefix(typ, "xsd:") {
+		return typ[4:]
+	}
+	return typ
+}

simulator/server.go

@@ -145,7 +145,6 @@ func newUDPServer(ctx context.Context, port int, h crHandlerFn) (server, error)
 	if err != nil {
 		return nil, fmt.Errorf("get ip address: %w", err)
 	}
-	fmt.Println(ip, port)
 
 	listener, err := net.ListenUDP("udp4", &net.UDPAddr{
 		IP:   net.ParseIP(ip),