Merge ~dirk.zimoch/epics-base:named-events-backward-compatibility into ~epics-core/epics-base/+git/epics-base:3.15

[Dirk Zimoch]

Make named soft events backward compatible to calculated numeric events (e.g by calc records).
Every event name that represents a number and that rounds down to an integer 1 ... 255 is a numeric events. If it rounds to 0 or is not finite (nan, +/-inf) it is no event.

[Andrew Johnson (anj)]

Hi Dirk,

You can commit to a branch after you have submitted a Merge Request for it and the new commits will automatically appear in the Merge Request (check this one out, it has your b2d6b67 commit in it). Submitting a *new* MR implies there's something major that is different than before, maybe you rebased the branch. Please don't do resubmits for minor additional changes like this, they are unnecessary and send confusing signals to the reviewers.

I will take a look at this when I get a chance.

Thanks,

- Andrew

[mdavidsaver (mdavidsaver)]

I haven't had a chance to do any run tests, but from reading the code it looks reasonable.

The only (minor) issue I see is that the test code for eventRecord needs to be moved under src/std/rec/test/

[Dirk Zimoch (dirk.zimoch)]

Oh, I didn‘t know that.
Dirk

> Am 16.02.2018 um 17:17 schrieb Andrew Johnson <email address hidden>:
>
> Hi Dirk,
>
> You can commit to a branch after you have submitted a Merge Request for it and the new commits will automatically appear in the Merge Request (check this one out, it has your b2d6b67 commit in it). Submitting a *new* MR implies there's something major that is different than before, maybe you rebased the branch. Please don't do resubmits for minor additional changes like this, they are unnecessary and send confusing signals to the reviewers.
>
> I will take a look at this when I get a chance.
>
> Thanks,
>
> - Andrew
> --
> https://code.launchpad.net/~dirk.zimoch/epics-base/+git/epics-base/+merge/337644
> You are the owner of ~dirk.zimoch/epics-base:named-events-backward-compatibility.

[Dirk Zimoch (dirk.zimoch)]

I had put it in db/test because my intent was to test the db event code,
not to test the records. The records are just the tool to test that the
db code works as intended. But if there is a problem having records in
db/test I see no problem moving it.

Dirk

On 16.02.2018 17:38, mdavidsaver wrote:
> I haven't had a chance to do any run tests, but from reading the code it looks reasonable.
>
> The only (minor) issue I see is that the test code for eventRecord needs to be moved under src/std/rec/test/
>
> Diff comments:
>
>> diff --git a/src/ioc/db/test/Makefile b/src/ioc/db/test/Makefile
>> index 215545f..77e485a 100644
>> --- a/src/ioc/db/test/Makefile
>> +++ b/src/ioc/db/test/Makefile
>> @@ -138,6 +138,21 @@ testHarness_SRCS += dbPutGetTest.db
>> TESTFILES += ../dbPutGetTest.db
>> TESTS += testPutGetTest
>>
>> +TARGETS += $(COMMON_DIR)/scanEventTest.dbd
>> +DBDDEPENDS_FILES += scanEventTest.dbd$(DEP)
>> +scanEventTest_DBD += menuGlobal.dbd
>> +scanEventTest_DBD += menuConvert.dbd
>> +scanEventTest_DBD += menuScan.dbd
>> +scanEventTest_DBD += eventRecord.dbd
>> +scanEventTest_DBD += devEventSoft.dbd
>> +scanEventTest_DBD += calcRecord.dbd
>> +scanEventTest_DBD += dfanoutRecord.dbd
>> +TESTPROD_HOST += scanEventTest
>> +scanEventTest_SRCS += scanEventTest.c
>> +scanEventTest_SRCS += scanEventTest_registerRecordDeviceDriver.cpp
>> +scanEventTest_LIBS = dbRecStd
>> +TESTS += scanEventTest
>
> Tests using libdbRecStd and base.dbd need to be under src/std/rec/test/ (cf. compressTest.c). So the test code needs to move.
>
>> +
>> # This runs all the test programs in a known working order:
>> testHarness_SRCS += epicsRunDbTests.c
>>
>
>

[mdavidsaver (mdavidsaver)]

> if there is a problem having records in db/test

cf src/Makefile. ioc/db/test can be build before libdbRecStd (containing record support) is linked, which will fail. Try "make distclean" then "make -C src ioc/db/test". Testing with parallel make will also catch issues like this.

> DIRS += ioc
> ioc_DEPEND_DIRS = libCom ca/client
>
> DIRS += ioc/db/test
> ioc/db/test_DEPEND_DIRS = ioc libCom/RTEMS
>
> DIRS += std
> std_DEPEND_DIRS = ioc libCom/RTEMS
>
> DIRS += std/rec/test
> std/rec/test_DEPEND_DIRS = std

review: Needs Fixing

[Dirk Zimoch (dirk.zimoch)]

I see...

[Dirk Zimoch (dirk.zimoch)]

> Try "make distclean" then "make -C src ioc/db/test".

Do you mean "make -C src/ioc/db/test" ?

$ make -C src std/rec/test/
make: Entering directory `[my top dir]/epics-base-3.15/src'
make: Nothing to be done for `std/rec/test/'.
make: Leaving directory `[my top dir]/epics-base-3.15/src

$ make -C src/ioc/db/test/
make: Entering directory `[my top dir]/epics-base-3.15/src/ioc/db/test'
perl -CSD [my top dir]/epics-base-3.15/bin/[my host arch]/makeMakefile.pl O.[my host arch] ../../../../..
Can't open perl script "[my top dir]/epics-base-3.15/bin/[my host arch]/makeMakefile.pl": No such file or directory

So it seems this does not work anyway.. ???

[Dirk Zimoch (dirk.zimoch)]

I have moved the test.

[Andrew Johnson (anj)]

The new Release Notes entry should go at the top of the file (where it says "Insert new items immediately below here ..."). I don't think it needs to be quite so explicit about the new algorithm, a brief description in words would suffice (I won't insist you change the text if you don't want to, but see the question below). It should mention that the post_event() routine has been undeprecated again since there may be quite a lot of older software that still calls this entry-point so we don't intend to remove it.

Looking at your event number compatibility logic, if I've understood the code properly it seems that I can legally create an event named "-1" or "256", although neither could be triggered by post_event(), but the names "Inf" and "Nan" are seen as illegal and will be rejected. That doesn't seem terribly logical to me, why couldn't they be allowed as purely string names?

I haven't tried pulling the code yet, I'm assuming it builds and works as promised (I will check that on Linux at least when merging).

[Dirk Zimoch (dirk.zimoch)]

> Am 02.03.2018 um 21:31 schrieb Andrew Johnson <email address hidden>:
>
> The new Release Notes entry should go at the top of the file (where it says "Insert new items immediately below here ..."). I don't think it needs to be quite so explicit about the new algorithm, a brief description in words would suffice (I won't insist you change the text if you don't want to, but see the question below). It should mention that the post_event() routine has been undeprecated again since there may be quite a lot of older software that still calls this entry-point so we don't intend to remove it.

I‘ll change it. (On Monday)

>
> Looking at your event number compatibility logic, if I've understood the code properly it seems that I can legally create an event named "-1" or "256", although neither could be triggered by post_event(), but the names "Inf" and "Nan" are seen as illegal and will be rejected. That doesn't seem terribly logical to me, why couldn't they be allowed as purely string names?

Ralph suggested that.

>
> I haven't tried pulling the code yet, I'm assuming it builds and works as promised (I will check that on Linux at least when merging).
> --
> https://code.launchpad.net/~dirk.zimoch/epics-base/+git/epics-base/+merge/337850
> You are the owner of ~dirk.zimoch/epics-base:named-events-backward-compatibility.

[Ralph Lange (ralph-lange)]

Clarification.

> > Am 02.03.2018 um 21:31 schrieb Andrew Johnson <email address hidden>:
> >
> > Looking at your event number compatibility logic, if I've understood the
> code properly it seems that I can legally create an event named "-1" or "256",
> although neither could be triggered by post_event(), but the names "Inf" and
> "Nan" are seen as illegal and will be rejected. That doesn't seem terribly
> logical to me, why couldn't they be allowed as purely string names?
>
> Ralph suggested that.

Sorry - I must have been not very clear...

The issue - as I understood it - was implementing a mapping from double numbers (use case was a calc record) to db event names.

Dirk mentioned which double numbers he would see as illegal and not map to a valid db event name, and I suggested (or wanted to) that double numbers that are not finite (negative and positive infinity and the not-a-number value) should also not map to a db event name.
Given that the original numeric db event codes were [1-255], I don't see where infinite values would map to.

[Dirk Zimoch (dirk.zimoch)]

> Am 03.03.2018 um 17:21 schrieb Ralph Lange <email address hidden>:
>
> Clarification.
>
>>> Am 02.03.2018 um 21:31 schrieb Andrew Johnson <email address hidden>:
>>>
>>> Looking at your event number compatibility logic, if I've understood the
>> code properly it seems that I can legally create an event named "-1" or "256",
>> although neither could be triggered by post_event(), but the names "Inf" and
>> "Nan" are seen as illegal and will be rejected. That doesn't seem terribly
>> logical to me, why couldn't they be allowed as purely string names?
>>
>> Ralph suggested that.
>
> Sorry - I must have been not very clear...
>
> The issue - as I understood it - was implementing a mapping from double numbers (use case was a calc record) to db event names.
>
> Dirk mentioned which double numbers he would see as illegal and not map to a valid db event name, and I suggested (or wanted to) that double numbers that are not finite (negative and positive infinity and the not-a-number value) should also not map to a db event name.
> Given that the original numeric db event codes were [1-255], I don't see where infinite values would map to.
>

Hmmm... As this fix is about backward compatibility with numeric events 0-255, non-finite values do not really need special treatment. If an event „Inf“ is posted but no record waits for it, nothing happens. But if there is a record waiting for „Inf“ events, we have an even cooler feature. The original purpose of the fix was to trigger event 2 with 2.000000, nothing more. Maybe I simply remove the non-finite handling. But then with the same reasoning 0 needs no special treatment as „no event“. Simply have no records on event „0“. — Or have some if you want. Why not? But maybe do not trigger them with post_event()?

What about spaces? It probably causes more confusion than benefit to distinguish event „ “ from „ “. At the moment leading and trailing blanks are removed. So both are equal to the empty string, which is „no event“ for good reason.

What about other numbers as suggested recently? I am not really fond of the idea to extend the post_event() functionality.

BTW: The whole problem started with the double to string conversion using fixed 6 decimals instead of .PREC. But to change that may cause even more incompatibilities.
How backward compatible do we want/need to be?

> --
> https://code.launchpad.net/~dirk.zimoch/epics-base/+git/epics-base/+merge/337850
> You are the owner of ~dirk.zimoch/epics-base:named-events-backward-compatibility.

[Dirk Zimoch (dirk.zimoch)]

On 03.03.2018 17:21, Ralph Lange wrote:
> Given that the original numeric db event codes were [1-255], I don't see where infinite values would map to.

Infinite values would not map to numeric events and thus not be
available to post_event() anyway. But as named events they would be
available as to postEvent().

I re-enable them now.

Before, 0 was no event, because it was the default value for EVNT
fields. Now the default value is the empty string. Thus I will make "0"
a valid event.

But let's agree on some questions first:
* Should "0" be a different event from "0.000000" like now "256" is
different from "256.000000"?
* Or should any (short, long, signed, unsigned ?) number map to an
integer, but only 1...255 would be available to post_event().
* Or should even more numbers be available to post_event()?
* Is is correct to round down any such number (like 2.999999) to integer
(that would be the full backward compatibility), or should only actual
integer numbers like "2.000000" be treated this way (what I actually
expect calculated event numbers to look like)?

Dirk

[Ralph Lange (ralph-lange)]

Uh-oh.

As for my original concern, I misunderstood how this was going to be implemented.
I'm fine with mapping to appropriate strings that would be ignored (no records waiting) by default and could be used in an exception handling fashion if desired.

As for the numeric conversions, I would try to be reasonable and minimally invasive, e.g.
If and only if number is in the interval [1...256[ remove the fractional part.
Convert in the %f-variant of the %g style: don't show insignificant zeroes to the right of the decimal point, and don't include the decimal point on whole numbers.

Removing trailing and leading whitespace is fine.

[Dirk Zimoch (dirk.zimoch)]

My original fix was supposed to be minimally invasive: an integer 0-255 followed by ".000000" was treated as a numeric event, with 0 being no event. Then change requests came in.

> Convert in the %f-variant of the %g style: don't show insignificant zeroes to the right of the decimal point, and don't include the decimal point on whole numbers.

I tested three cases for the conversion from a calc[out] with VAL=2.0:
1. event.INP -> calcout.VAL (or calc)
This is no problem. calcout.PREC is used to convert the value, so I get "2" with the default PREC=0.
2. event.INP -> calcout.VAL CP
This uses precision=6! I get "2.000000"
I find this a bit strange because caget -d0 gives me "2".
3. calcout.OUT -> event.VAL
This uses precision=6 as well. I get "2.000000".

Maybe the problem should really be fixed in the conversion double->string. But this may break other stuff. I will investigate a bit...

[Dirk Zimoch (dirk.zimoch)]

Giving the event record a get_precision() function that sets precision=0 helps with case 3. But does that make sense? When converting a double to a string, the conversion should use PREC of the source record, not of the target record.

[Andrew Johnson (anj)]

This now looks reasonable to me (I haven't built or tested it yet though).

Ralph have Dirk's latest changes resolved your concerns?

review: Approve

[Ralph Lange (ralph-lange)]

jajaja

review: Approve

diff --git a/documentation/RELEASE_NOTES.html b/documentation/RELEASE_NOTES.html
index 33f12c4..d19664e 100644
--- a/documentation/RELEASE_NOTES.html
+++ b/documentation/RELEASE_NOTES.html
@@ -16,6 +16,14 @@
 
 <!-- Insert new items immediately below here ... -->
 
+<h3>Fix problem with numeric soft events</h3>
+<p>Changing from numeric to named soft events introduced an incompatibility
+when a numeric event 1-255 is converted from a DOUBLE, e.g. from a calc record.
+The <tt>post_event()</tt> API is not marked deprecated any more.
+
+<p>Also <code>scanpel</code> has been modified to accept a glob pattern for
+event name filtering and to show events with no connected records as well.</p>
+
 <h3>Add osiSockOptMcastLoop_t and osiSockTest</h3>
 
 <p>Added a new OS-independent typedef for multicast socket options, and a test
diff --git a/src/ioc/db/dbScan.c b/src/ioc/db/dbScan.c
index e0c48d4..e9dc178 100644
--- a/src/ioc/db/dbScan.c
+++ b/src/ioc/db/dbScan.c
@@ -111,8 +111,8 @@ static char *priorityName[NUM_CALLBACK_PRIORITIES] = {
 typedef struct event_list {
     CALLBACK            callback[NUM_CALLBACK_PRIORITIES];
     scan_list           scan_list[NUM_CALLBACK_PRIORITIES];
-    struct event_list *next;
-    char                event_name[MAX_STRING_SIZE];
+    struct event_list   *next;
+    char                eventname[1]; /* actually arbitrary size */
 } event_list;
 static event_list * volatile pevent_list[256];
 static epicsMutexId event_lock;
@@ -249,11 +249,6 @@ void scanAdd(struct dbCommon *precord)
         event_list *pel;
 
         eventname = precord->evnt;
-        if (strlen(eventname) >= MAX_STRING_SIZE) {
-            recGblRecordError(S_db_badField, (void *)precord,
-                "scanAdd: too long EVNT value");
-            return;
-        }
         prio = precord->prio;
         if (prio < 0 || prio >= NUM_CALLBACK_PRIORITIES) {
             recGblRecordError(-1, (void *)precord,
@@ -317,24 +312,17 @@ void scanDelete(struct dbCommon *precord)
         recGblRecordError(-1, (void *)precord,
             "scanDelete detected illegal SCAN value");
     } else if (scan == menuScanEvent) {
-        char* eventname;
         int prio;
         event_list *pel;
         scan_list *psl = 0;
 
-        eventname = precord->evnt;
         prio = precord->prio;
         if (prio < 0 || prio >= NUM_CALLBACK_PRIORITIES) {
             recGblRecordError(-1, (void *)precord,
                 "scanDelete detected illegal PRIO field");
             return;
         }
-        do /* multithreading: make sure pel is consistent */
-            pel = pevent_list[0];
-        while (pel != pevent_list[0]);
-        for (; pel; pel=pel->next) {
-            if (strcmp(pel->event_name, eventname) == 0) break;
-        }
+        pel = eventNameToHandle(precord->evnt);
         if (pel && (psl = &pel->scan_list[prio]))
             deleteFromList(precord, psl);
     } else if (scan == menuScanI_O_Intr) {
@@ -422,14 +410,12 @@ int scanpel(const char* eventname)   /* print event list */
     int prio;
     event_list *pel;
 
-    do /* multithreading: make sure pel is consistent */
-        pel = pevent_list[0];
-    while (pel != pevent_list[0]);
-    for (; pel; pel = pel->next) {
-        if (!eventname || strcmp(pel->event_name, eventname) == 0) {
+    for (pel = pevent_list[0]; pel; pel = pel->next) {
+        if (!eventname || epicsStrGlobMatch(pel->eventname, eventname)) {
+            printf("Event \"%s\"\n", pel->eventname);
             for (prio = 0; prio < NUM_CALLBACK_PRIORITIES; prio++) {
                 if (ellCount(&pel->scan_list[prio].list) == 0) continue;
-                sprintf(message, "Event \"%s\" Priority %s", pel->event_name, priorityName[prio]);
+                sprintf(message, " Priority %s", priorityName[prio]);
                 printList(&pel->scan_list[prio], message);
             }
         }
@@ -480,18 +466,51 @@ event_list *eventNameToHandle(const char *eventname)
     int prio;
     event_list *pel;
     static epicsThreadOnceId onceId = EPICS_THREAD_ONCE_INIT;
-
-    if (!eventname || eventname[0] == 0)
-        return NULL;
+    double eventnumber = 0;
+    size_t namelength;
+
+    if (!eventname) return NULL;
+    while (isspace((unsigned char)eventname[0])) eventname++;
+    if (!eventname[0]) return NULL;
+    namelength = strlen(eventname);
+    while (isspace((unsigned char)eventname[namelength-1])) namelength--;
+
+    /* Backward compatibility with numeric events:
+       Treat any string that represents a double with an
+       integer part between 0 and 255 the same as the integer
+       because it is most probably a conversion from double
+       like from a calc record.
+    */
+    if (epicsParseDouble(eventname, &eventnumber, NULL) == 0)
+    {
+        if (eventnumber >= 0 && eventnumber < 256)
+        {
+            if (eventnumber < 1)
+                return NULL; /* 0 is no event */
+            if ((pel = pevent_list[(int)eventnumber]) != NULL)
+                return pel;
+        }
+        else
+            eventnumber = 0; /* not a numeric event between 1 and 255 */
+    }
 
     epicsThreadOnce(&onceId, eventOnce, NULL);
     epicsMutexMustLock(event_lock);
     for (pel = pevent_list[0]; pel; pel=pel->next) {
-        if (strcmp(pel->event_name, eventname) == 0) break;
+        if (strncmp(pel->eventname, eventname, namelength) == 0
+            && pel->eventname[namelength] == 0)
+            break;
     }
     if (pel == NULL) {
-        pel = dbCalloc(1, sizeof(event_list));
-        strcpy(pel->event_name, eventname);
+        pel = dbCalloc(1, sizeof(event_list) + namelength);
+        if (eventnumber > 0)
+        {
+            /* backward compatibility: make all numeric events look like integers */
+            sprintf(pel->eventname, "%i", (int)eventnumber);
+            pevent_list[(int)eventnumber] = pel;
+        }
+        else
+            strncpy(pel->eventname, eventname, namelength);
         for (prio = 0; prio < NUM_CALLBACK_PRIORITIES; prio++) {
             callbackSetUser(&pel->scan_list[prio], &pel->callback[prio]);
             callbackSetPriority(prio, &pel->callback[prio]);
@@ -501,12 +520,6 @@ event_list *eventNameToHandle(const char *eventname)
         }
         pel->next=pevent_list[0];
         pevent_list[0]=pel;
-        { /* backward compatibility */
-            char* p;
-            long e = strtol(eventname, &p, 0);
-            if (*p == 0 && e > 0 && e <= 255)
-                pevent_list[e] = pel;
-        }
     }
     epicsMutexUnlock(event_lock);
     return pel;
@@ -527,13 +540,8 @@ void postEvent(event_list *pel)
 /* backward compatibility */
 void post_event(int event)
 {
-    event_list* pel;
-
     if (event <= 0 || event > 255) return;
-    do { /* multithreading: make sure pel is consistent */
-        pel = pevent_list[event];
-    } while (pel != pevent_list[event]);
-    postEvent(pel);
+    postEvent(pevent_list[event]);
 }
 
 
 static void ioscanOnce(void *arg)
diff --git a/src/ioc/db/dbScan.h b/src/ioc/db/dbScan.h
index 28d2e13..d310271 100644
--- a/src/ioc/db/dbScan.h
+++ b/src/ioc/db/dbScan.h
@@ -50,7 +50,7 @@ epicsShareFunc void scanCleanup(void);
 
 epicsShareFunc EVENTPVT eventNameToHandle(const char* event);
 epicsShareFunc void postEvent(EVENTPVT epvt);
-epicsShareFunc void post_event(int event) EPICS_DEPRECATED;
+epicsShareFunc void post_event(int event);
 epicsShareFunc void scanAdd(struct dbCommon *);
 epicsShareFunc void scanDelete(struct dbCommon *);
 epicsShareFunc double scanPeriod(int scan);
diff --git a/src/std/rec/test/Makefile b/src/std/rec/test/Makefile
index 5322c8e..70b6e17 100644
--- a/src/std/rec/test/Makefile
+++ b/src/std/rec/test/Makefile
@@ -37,6 +37,15 @@ testHarness_SRCS += analogMonitorTest_registerRecordDeviceDriver.cpp
 TESTFILES += $(COMMON_DIR)/analogMonitorTest.dbd ../analogMonitorTest.db
 TESTS += analogMonitorTest
 
+TARGETS += $(COMMON_DIR)/scanEventTest.dbd
+DBDDEPENDS_FILES += scanEventTest.dbd$(DEP)
+scanEventTest_DBD += base.dbd
+TESTPROD_HOST += scanEventTest
+scanEventTest_SRCS += scanEventTest.c
+scanEventTest_SRCS += scanEventTest_registerRecordDeviceDriver.cpp
+TESTFILES += $(COMMON_DIR)/scanEventTest.dbd ../scanEventTest.db
+TESTS += scanEventTest
+
 TARGETS += $(COMMON_DIR)/regressTest.dbd
 DBDDEPENDS_FILES += regressTest.dbd$(DEP)
 regressTest_DBD += base.dbd
diff --git a/src/std/rec/test/epicsRunRecordTests.c b/src/std/rec/test/epicsRunRecordTests.c
index 092c0a6..1a7133c 100644
--- a/src/std/rec/test/epicsRunRecordTests.c
+++ b/src/std/rec/test/epicsRunRecordTests.c
@@ -14,6 +14,7 @@
 
 int analogMonitorTest(void);
 int arrayOpTest(void);
+int scanEventTest(void);
 
 void epicsRunRecordTests(void)
 {
@@ -22,6 +23,7 @@ void epicsRunRecordTests(void)
     runTest(analogMonitorTest);
 
     runTest(arrayOpTest);
+    runTest(scanEventTest);
 
     epicsExit(0);   /* Trigger test harness */
 }
diff --git a/src/std/rec/test/scanEventTest.c b/src/std/rec/test/scanEventTest.c
 new file mode 100644
index 0000000..595264a
--- /dev/null
+++ b/src/std/rec/test/scanEventTest.c
@@ -0,0 +1,142 @@
+/*************************************************************************\
+* Copyright (c) 2018 Paul Scherrer Institut
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+ \*************************************************************************/
+
+/*
+ *  Author: Dirk Zimoch <[e-mail]>
+ */
+
+#include <string.h>
+#include "dbStaticLib.h"
+#include "dbAccessDefs.h"
+#include "dbUnitTest.h"
+#include "testMain.h"
+#include "osiFileName.h"
+#include "epicsThread.h"
+#include "dbScan.h"
+
+void scanEventTest_registerRecordDeviceDriver(struct dbBase *);
+
+/* test name to event number:
+    num = 0 is no event,
+    num > 0 is numeric event
+    num < 0 is string event (use same unique number for aliases)
+*/
+const struct {char* name; int num;} events[] = {
+/* No events */
+    {NULL,            0},
+    {"",              0},
+    {"       ",       0},
+    {"0",             0},
+    {"0.000000",      0},
+    {"-0.00000",      0},
+    {"0.9",           0},
+/* Numeric events */
+    {"2",             2},
+    {"2.000000",      2},
+    {"2.5",           2},
+    {" 2.5  ",        2},
+    {"+0x02",         2},
+    {"3",             3},
+/* Named events */
+    {"info 1",       -1},
+    {"   info 1  ",  -1},
+    {"-0.9",         -2},
+    {"-2",           -3},
+    {"-2.000000",    -4},
+    {"-2.5",         -5},
+    {" -2.5  ",      -5},
+    {"nan",          -6},
+    {"NaN",          -7},
+    {"-NAN",         -8},
+    {"-inf",         -9},
+    {"inf",         -10},
+};
+
+MAIN(scanEventTest)
+{
+    int i, e;
+    int aliases[512] ;
+    int expected_count[512];
+    #define INDX(i) 256-events[i].num
+    #define MAXEV 5
+    
+    testPlan(NELEMENTS(events)*2+(MAXEV+1)*5);
+    
+    memset(aliases, 0, sizeof(aliases));
+    memset(expected_count, 0, sizeof(expected_count));
+
+    if (dbReadDatabase(&pdbbase, "scanEventTest.dbd",
+            "." OSI_PATH_LIST_SEPARATOR ".." OSI_PATH_LIST_SEPARATOR
+            "../O.Common" OSI_PATH_LIST_SEPARATOR "O.Common", NULL))
+        testAbort("Database description 'scanEventTest.dbd' not found");
+
+    scanEventTest_registerRecordDeviceDriver(pdbbase);
+    for (i = 0; i < NELEMENTS(events); i++) {
+        char substitutions[256];
+        sprintf(substitutions, "N=%d,EVENT=%s", i, events[i].name);
+        if (dbReadDatabase(&pdbbase, "scanEventTest.db",
+                "." OSI_PATH_LIST_SEPARATOR "..", substitutions))
+            testAbort("Error reading test database 'scanEventTest.db'");
+    }
+    testIocInitOk();
+    testDiag("Test if eventNameToHandle() strips spaces and handles numeric events");
+    for (i = 0; i < NELEMENTS(events); i++) {
+        EVENTPVT pev = eventNameToHandle(events[i].name);
+        /* test that some names are not events (num=0) */
+        if (events[i].num == 0)
+            testOk(pev == NULL, "\"%s\" -> no event", events[i].name);
+        else
+        {
+            expected_count[INDX(i)]++; /* +1 for postEvent */
+            if (events[i].num > 0)
+            {
+                testOk(pev != NULL, "\"%s\" -> numeric event %d", events[i].name, events[i].num);
+                expected_count[INDX(i)]++; /* +1 for post_event */
+            }
+            else
+            {
+                 /* test that some strings resolve the same event (num!=0) */
+                 if (!aliases[INDX(i)])
+                 {
+                     aliases[INDX(i)] = i;
+                     testOk(pev != NULL, "\"%s\" -> new named event", events[i].name);
+                 }
+                 else
+                 {
+                     testOk(pev == eventNameToHandle(events[aliases[INDX(i)]].name),
+                         "\"%s\" alias for \"%s\"", events[i].name, events[aliases[INDX(i)]].name);
+                 }
+            }
+        }
+        post_event(events[i].num); /* triggers numeric events only */
+        postEvent(pev);
+    }
+    
+    testDiag("Check calculated numeric events (backward compatibility)");
+    for (e = 0; e <= MAXEV; e++) {
+        testdbPutFieldOk("eventnum", DBR_LONG, e);
+        testdbGetFieldEqual("e1", DBR_LONG, e);
+        testdbGetFieldEqual("e2", DBR_LONG, e);
+        testdbPutFieldOk("e3", DBR_LONG, e);
+        testdbPutFieldOk("e3.PROC", DBR_LONG, 1);
+        for (i = 0; i < NELEMENTS(events); i++)
+            if (e > 0 && e < 256 && events[i].num == e) { /* numeric events */
+                expected_count[INDX(i)]+=3; /* +1 for eventnum->e1, +1 for e2<-eventnum, +1 for e3 */
+                break;
+            }
+    }
+    /* Allow records to finish processing */
+    epicsThreadSleep(0.1);
+    testDiag("Check if events have been processed the expected number of times");
+    for (i = 0; i < NELEMENTS(events); i++) {
+        char pvname[100];
+        sprintf(pvname, "c%d", i);
+        testDiag("Event \"%s\" expected %d times", events[i].name, expected_count[INDX(i)]);
+        testdbGetFieldEqual(pvname, DBR_LONG, expected_count[INDX(i)]);
+    }
+
+    return testDone();
+}
diff --git a/src/std/rec/test/scanEventTest.db b/src/std/rec/test/scanEventTest.db
 new file mode 100644
index 0000000..9118823
--- /dev/null
+++ b/src/std/rec/test/scanEventTest.db
@@ -0,0 +1,16 @@
+record(calc, "c$(N)") {
+  field(SCAN, "Event")
+  field(EVNT, "$(EVENT)")
+  field(CALC, "VAL+1")
+}
+record(dfanout, "eventnum") {
+  field(OUTA, "e1 PP")
+  field(FLNK, "e2")
+}
+record(event, "e1") {
+}
+record(event, "e2") {
+  field(INP,  "eventnum")
+}
+record(event, "e3") {
+}