Merge branch 'REnums2018'

* REnums2018: Fix R return by C++11 const ref enum classes Remove unused code in r.cxx extra doc on anonymous enums ENH: FIX: references to enums now functioning DOC: Extended documentation on enumeration support in R FIX: Corrected path to output from R tests Reformat comments in R module ENH: Run test for enum_thorough in R Code style changes post review ENH: R Module: Enumerations with values set by calls to C code, allowing arbitarily complex value expressions. Setting enum values with calls to the C code.
2019-03-18 18:03:20 +00:00 · 2019-03-18 18:03:20 +00:00 · cfa7a4d4d0
commit cfa7a4d4d0
parent 39d67aea8e 39e3c3b9d7
7 changed files with 875 additions and 291 deletions
--- a/Examples/test-suite/r/Makefile.in
+++ b/Examples/test-suite/r/Makefile.in
@ -27,7 +27,6 @@ CPP_TEST_CASES += \
 # arithmetic expressions

 FAILING_CPP_TESTS = \
-	enum_thorough \
 	preproc_constants

 FAILING_C_TESTS = \
@ -64,7 +63,7 @@ include $(srcdir)/../common.mk
 # check for syntactic correctness
 run_testcase = \
 	if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
-	  env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH PATH=.:"$$PATH" $(RUNTOOL) $(RUNR) $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) || (cat $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX)out ; false); \
+	  env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH PATH=.:"$$PATH" $(RUNTOOL) $(RUNR) $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) || (cat ./$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX)out ; false); \
 	else \
 	  $(RUNTOOL) $(RUNR) ./$(SCRIPTPREFIX)$*$(WRAPSUFFIX) || (cat ./$(SCRIPTPREFIX)$*$(WRAPSUFFIX)out ; false); \
 	fi
@ -72,7 +71,7 @@ run_testcase = \
 run_multitestcase = \
 	for f in `cat $(top_srcdir)/$(EXAMPLES)/$(TEST_SUITE)/$*.list` ; do \
 	if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$${f}$(SCRIPTSUFFIX) ]; then \
-	  env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH PATH=.:"$$PATH" $(RUNTOOL) $(RUNR) $(SCRIPTDIR)/$(SCRIPTPREFIX)$${f}$(SCRIPTSUFFIX) || (cat $(SCRIPTDIR)/$(SCRIPTPREFIX)$${f}$(SCRIPTSUFFIX)out ; false); \
+	  env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH PATH=.:"$$PATH" $(RUNTOOL) $(RUNR) $(SCRIPTDIR)/$(SCRIPTPREFIX)$${f}$(SCRIPTSUFFIX) || (cat ./$(SCRIPTPREFIX)$${f}$(SCRIPTSUFFIX)out ; false); \
 	else \
 	  $(RUNTOOL) $(RUNR) ./$(SCRIPTPREFIX)$${f}$(WRAPSUFFIX) || (cat ./$(SCRIPTPREFIX)$${f}$(WRAPSUFFIX)out ; false); \
 	fi; \
--- a/Examples/test-suite/r/enum_thorough_runme.R
+++ b/Examples/test-suite/r/enum_thorough_runme.R
@ -0,0 +1,452 @@
+clargs <- commandArgs(trailing=TRUE)
+source(file.path(clargs[1], "unittest.R"))
+
+dyn.load(paste("enum_thorough", .Platform$dynlib.ext, sep=""))
+source("enum_thorough.R")
+cacheMetaData(1)
+
+## Anonymous enums are not wrapped by the R module
+##
+
+# Colours - string interface, various function signatures
+unittest('red', colourTest1('red'))
+unittest('blue', colourTest1('blue'))
+unittest('green', colourTest1('green'))
+
+
+unittest('red', colourTest2('red'))
+unittest('blue', colourTest2('blue'))
+unittest('green', colourTest2('green'))
+
+unittest('red', colourTest3('red'))
+unittest('blue', colourTest3('blue'))
+unittest('green', colourTest3('green'))
+
+unittest('red', colourTest4('red'))
+unittest('blue', colourTest4('blue'))
+unittest('green', colourTest4('green'))
+
+## Colours - underlying integers
+unittest(-1, enumToInteger('red', '_colour'))
+unittest(0, enumToInteger('blue', '_colour'))
+unittest(10, enumToInteger('green', '_colour'))
+
+########
+## enum variable, wrapped as a function
+## Is initialization to 0 a "standard"
+myColour()
+
+## Test setting and retrieving
+myColour('green')
+unittest('green', myColour())
+
+########
+## SpeedClass
+
+s <- SpeedClass()
+v <- "medium"
+unittest(v, s$speedTest1(v))
+unittest(v, s$speedTest2(v))
+unittest(v, s$speedTest3(v))
+unittest(v, s$speedTest4(v))
+unittest(v, s$speedTest5(v))
+unittest(v, s$speedTest6(v))
+unittest(v, s$speedTest7(v))
+unittest(v, s$speedTest8(v))
+
+## speedTest methods not in the class
+
+unittest(v, speedTest1(v))
+unittest(v, speedTest2(v))
+unittest(v, speedTest3(v))
+unittest(v, speedTest4(v))
+# enum reference
+unittest(v, speedTest5(v))
+
+## member access
+s <- SpeedClass()
+unittest("slow", s$mySpeedtd1)
+# check integer value
+unittest(10, enumToInteger(s$mySpeedtd1, "_SpeedClass__speed"))
+# set and check
+s$mySpeedtd1 <- "lightning"
+unittest("lightning", s$mySpeedtd1)
+unittest(31, enumToInteger(s$mySpeedtd1, "_SpeedClass__speed"))
+
+## Named anon - not wrapped nicely, but can be retrieved:
+
+
+unittest("NamedAnon2", namedanon_NamedAnon2_get())
+unittest(0, enumToInteger(namedanon_NamedAnon1_get(), "_namedanon"))
+unittest(1, enumToInteger(namedanon_NamedAnon2_get(), "_namedanon"))
+
+## Twonames
+v <- "TwoNames1"
+unittest(v, twonamesTest1(v))
+unittest(v, twonamesTest2(v))
+unittest(v, twonamesTest3(v))
+unittest(33, enumToInteger("TwoNames3", "_twonamestag"))
+
+tt <- TwoNamesStruct()
+v <- "TwoNamesStruct1"
+unittest(v, tt$twonamesTest1(v))
+unittest(v, tt$twonamesTest2(v))
+unittest(v, tt$twonamesTest3(v))
+## Try the wrong name
+unittest(TRUE, is.na(tt$twonamesTest3("TwoNames1")))
+
+## Namedanonspace
+## can get the values
+
+v <- namedanonspace_NamedAnonSpace2_get()
+unittest(v, namedanonspaceTest1(v))
+unittest(v, namedanonspaceTest2(v))
+unittest(v, namedanonspaceTest3(v))
+unittest(v, namedanonspaceTest4(v))
+
+## scientists
+
+tt <- TemplateClassInt()
+
+g <- "galileo"
+unittest(g, tt$scientistsTest1(g))
+unittest(g, tt$scientistsTest2(g))
+unittest(g, tt$scientistsTest3(g))
+unittest(g, tt$scientistsTest4(g))
+unittest(g, tt$scientistsTest5(g))
+unittest(g, tt$scientistsTest6(g))
+unittest(g, tt$scientistsTest7(g))
+unittest(g, tt$scientistsTest8(g))
+unittest(g, tt$scientistsTest9(g))
+
+## This one is commented out in csharp too
+## unittest(g, tt$scientistsTestA(g))
+unittest(g, tt$scientistsTestB(g))
+## This one is commented out in csharp too
+## unittest(g, tt$scientistsTestC(g))
+unittest(g, tt$scientistsTestD(g))
+unittest(g, tt$scientistsTestE(g))
+unittest(g, tt$scientistsTestF(g))
+unittest(g, tt$scientistsTestG(g))
+unittest(g, tt$scientistsTestH(g))
+unittest(g, tt$scientistsTestI(g))
+# enum reference
+unittest(g, tt$scientistsTestJ(g))
+
+
+unittest(g, scientistsTest1(g))
+unittest(g, scientistsTest2(g))
+unittest(g, scientistsTest3(g))
+unittest(g, scientistsTest4(g))
+unittest(g, scientistsTest5(g))
+unittest(g, scientistsTest6(g))
+unittest(g, scientistsTest7(g))
+## enum reference
+unittest(g, scientistsTest8(g))
+
+tt <- TClassInt()
+b <- "bell"
+unittest(b, tt$scientistsNameTest1(b))
+unittest(b, tt$scientistsNameTest2(b))
+unittest(b, tt$scientistsNameTest3(b))
+unittest(b, tt$scientistsNameTest4(b))
+unittest(b, tt$scientistsNameTest5(b))
+unittest(b, tt$scientistsNameTest6(b))
+unittest(b, tt$scientistsNameTest7(b))
+unittest(b, tt$scientistsNameTest8(b))
+unittest(b, tt$scientistsNameTest9(b))
+
+## This one is commented out in csharp too
+## unittest(b, tt$scientistsNameTestA(b))
+unittest(b, tt$scientistsNameTestB(b))
+## This one is commented out in csharp too
+## unittest(b, tt$scientistsNameTestC(b))
+unittest(b, tt$scientistsNameTestD(b))
+unittest(b, tt$scientistsNameTestE(b))
+unittest(b, tt$scientistsNameTestF(b))
+unittest(b, tt$scientistsNameTestG(b))
+unittest(b, tt$scientistsNameTestH(b))
+unittest(b, tt$scientistsNameTestI(b))
+
+
+unittest(b, tt$scientistsNameSpaceTest1(b))
+unittest(b, tt$scientistsNameSpaceTest2(b))
+unittest(b, tt$scientistsNameSpaceTest3(b))
+unittest(b, tt$scientistsNameSpaceTest4(b))
+unittest(b, tt$scientistsNameSpaceTest5(b))
+unittest(b, tt$scientistsNameSpaceTest6(b))
+unittest(b, tt$scientistsNameSpaceTest7(b))
+
+unittest(g, tt$scientistsOtherTest1(g))
+unittest(g, tt$scientistsOtherTest2(g))
+unittest(g, tt$scientistsOtherTest3(g))
+unittest(g, tt$scientistsOtherTest4(g))
+unittest(g, tt$scientistsOtherTest5(g))
+unittest(g, tt$scientistsOtherTest6(g))
+unittest(g, tt$scientistsOtherTest7(g))
+
+## Global 
+unittest(b, scientistsNameTest1(b))
+unittest(b, scientistsNameTest2(b))
+unittest(b, scientistsNameTest3(b))
+unittest(b, scientistsNameTest4(b))
+unittest(b, scientistsNameTest5(b))
+unittest(b, scientistsNameTest6(b))
+unittest(b, scientistsNameTest7(b))
+
+unittest(b, scientistsNameSpaceTest1(b))
+unittest(b, scientistsNameSpaceTest2(b))
+unittest(b, scientistsNameSpaceTest3(b))
+unittest(b, scientistsNameSpaceTest4(b))
+unittest(b, scientistsNameSpaceTest5(b))
+unittest(b, scientistsNameSpaceTest6(b))
+unittest(b, scientistsNameSpaceTest7(b))
+
+unittest(b, scientistsNameSpaceTest8(b))
+unittest(b, scientistsNameSpaceTest9(b))
+unittest(b, scientistsNameSpaceTestA(b))
+unittest(b, scientistsNameSpaceTestB(b))
+unittest(b, scientistsNameSpaceTestC(b))
+unittest(b, scientistsNameSpaceTestD(b))
+unittest(b, scientistsNameSpaceTestE(b))
+unittest(b, scientistsNameSpaceTestF(b))
+unittest(b, scientistsNameSpaceTestG(b))
+unittest(b, scientistsNameSpaceTestH(b))
+unittest(b, scientistsNameSpaceTestI(b))
+unittest(b, scientistsNameSpaceTestJ(b))
+unittest(b, scientistsNameSpaceTestK(b))
+unittest(b, scientistsNameSpaceTestL(b))
+
+## rename test
+v <- "eek"
+unittest(v, renameTest1(v))
+unittest(v, renameTest2(v))
+
+## NewName
+N <- NewNameStruct()
+## Only half works:
+unittest("kerboom", NewNameStruct_bang_get())
+## Can't put in "bang" in the call
+## confirm with:
+## get(".__E___OldNameStruct__enumeration")
+
+## TreeClass
+
+T <- TreesClass()
+p <- "pine"
+
+unittest(p, T$treesTest1(p))
+unittest(p, T$treesTest2(p))
+unittest(p, T$treesTest3(p))
+unittest(p, T$treesTest4(p))
+unittest(p, T$treesTest5(p))
+unittest(p, T$treesTest6(p))
+unittest(p, T$treesTest7(p))
+unittest(p, T$treesTest8(p))
+unittest(p, T$treesTest9(p))
+unittest(p, T$treesTestA(p))
+unittest(p, T$treesTestB(p))
+unittest(p, T$treesTestC(p))
+unittest(p, T$treesTestD(p))
+unittest(p, T$treesTestE(p))
+unittest(p, T$treesTestF(p))
+unittest(p, T$treesTestG(p))
+unittest(p, T$treesTestH(p))
+unittest(p, T$treesTestI(p))
+unittest(p, T$treesTestJ(p))
+unittest(p, T$treesTestK(p))
+unittest(p, T$treesTestL(p))
+unittest(p, T$treesTestM(p))
+unittest(p, T$treesTestN(p))
+unittest(p, T$treesTestO(p))
+
+unittest(p, treesTest1(p))
+unittest(p, treesTest2(p))
+unittest(p, treesTest3(p))
+unittest(p, treesTest4(p))
+unittest(p, treesTest5(p))
+unittest(p, treesTest6(p))
+unittest(p, treesTest7(p))
+unittest(p, treesTest8(p))
+unittest(p, treesTest9(p))
+unittest(p, treesTestA(p))
+unittest(p, treesTestB(p))
+unittest(p, treesTestC(p))
+unittest(p, treesTestD(p))
+unittest(p, treesTestE(p))
+unittest(p, treesTestF(p))
+unittest(p, treesTestG(p))
+unittest(p, treesTestH(p))
+unittest(p, treesTestI(p))
+unittest(p, treesTestJ(p))
+unittest(p, treesTestK(p))
+unittest(p, treesTestL(p))
+unittest(p, treesTestM(p))
+unittest(p, treesTestO(p))
+unittest(p, treesTestP(p))
+unittest(p, treesTestQ(p))
+unittest(p, treesTestR(p))
+
+## Hair
+h <- HairStruct()
+g <- "ginger"
+unittest(g, h$hairTest1(g))
+unittest(g, h$hairTest2(g))
+unittest(g, h$hairTest3(g))
+unittest(g, h$hairTest4(g))
+unittest(g, h$hairTest5(g))
+unittest(g, h$hairTest6(g))
+unittest(g, h$hairTest7(g))
+unittest(g, h$hairTest8(g))
+unittest(g, h$hairTest9(g))
+unittest(g, h$hairTestA(g))
+unittest(g, h$hairTestB(g))
+
+r <- "red"
+unittest(r, h$colourTest1(r))
+unittest(r, h$colourTest2(r))
+
+nmA <- "NamedAnon1"
+unittest(nmA, h$namedanonTest1(nmA))
+unittest("NamedAnonSpace2", h$namedanonspaceTest1("NamedAnonSpace2"))
+
+f <- "fir"
+
+unittest(f, h$treesGlobalTest1(f))
+unittest(f, h$treesGlobalTest2(f))
+unittest(f, h$treesGlobalTest3(f))
+unittest(f, h$treesGlobalTest4(f))
+
+b <- "blonde"
+unittest(b, hairTest1(b))
+unittest(b, hairTest2(b))
+unittest(b, hairTest3(b))
+unittest(b, hairTest4(b))
+unittest(b, hairTest5(b))
+unittest(b, hairTest6(b))
+unittest(b, hairTest7(b))
+unittest(b, hairTest8(b))
+unittest(b, hairTest9(b))
+unittest(b, hairTestA(b))
+unittest(b, hairTestB(b))
+## enum reference
+unittest(b, hairTestC(b))
+unittest(b, hairTestA1(b))
+unittest(b, hairTestA2(b))
+unittest(b, hairTestA3(b))
+unittest(b, hairTestA4(b))
+unittest(b, hairTestA5(b))
+unittest(b, hairTestA6(b))
+unittest(b, hairTestA7(b))
+unittest(b, hairTestA8(b))
+unittest(b, hairTestA9(b))
+unittest(b, hairTestAA(b))
+unittest(b, hairTestAB(b))
+## enum reference
+unittest(b, hairTestAC(b))
+
+unittest(b, hairTestB1(b))
+unittest(b, hairTestB2(b))
+unittest(b, hairTestB3(b))
+unittest(b, hairTestB4(b))
+unittest(b, hairTestB5(b))
+unittest(b, hairTestB6(b))
+unittest(b, hairTestB7(b))
+unittest(b, hairTestB8(b))
+unittest(b, hairTestB9(b))
+unittest(b, hairTestBA(b))
+unittest(b, hairTestBB(b))
+## enum reference
+unittest(b, hairTestBC(b))
+
+f <- FirStruct()
+b <- "blonde"
+
+unittest(b, f$hairTestFir1(b))
+unittest(b, f$hairTestFir2(b))
+unittest(b, f$hairTestFir3(b))
+unittest(b, f$hairTestFir4(b))
+unittest(b, f$hairTestFir5(b))
+unittest(b, f$hairTestFir6(b))
+unittest(b, f$hairTestFir7(b))
+unittest(b, f$hairTestFir8(b))
+unittest(b, f$hairTestFir9(b))
+unittest(b, f$hairTestFirA(b))
+
+## Unnamed enum instance doesn't work
+## Wrapper set/get exists, but there's
+## no mapping between strings and integers
+GlobalInstance(1)
+unittest(1, GlobalInstance())
+
+ii <- Instances()
+ii$MemberInstance <- 1
+unittest(1, ii$MemberInstance)
+
+ii <- IgnoreTest()
+
+## Testing integer values
+unittest(0, enumToInteger(IgnoreTest_ignoreA_zero_get(), "_IgnoreTest__IgnoreA"))
+unittest(3, enumToInteger(IgnoreTest_ignoreA_three_get(), "_IgnoreTest__IgnoreA"))
+unittest(10, enumToInteger(IgnoreTest_ignoreA_ten_get(), "_IgnoreTest__IgnoreA"))
+
+unittest(11, enumToInteger(IgnoreTest_ignoreA_eleven_get(), "_IgnoreTest__IgnoreA"))
+unittest(14, enumToInteger(IgnoreTest_ignoreA_fourteen_get(), "_IgnoreTest__IgnoreA"))
+unittest(20, enumToInteger(IgnoreTest_ignoreA_twenty_get(), "_IgnoreTest__IgnoreA"))
+unittest(30, enumToInteger(IgnoreTest_ignoreA_thirty_get(), "_IgnoreTest__IgnoreA"))
+unittest(32, enumToInteger(IgnoreTest_ignoreA_thirty_two_get(), "_IgnoreTest__IgnoreA"))
+unittest(33, enumToInteger(IgnoreTest_ignoreA_thirty_three_get(), "_IgnoreTest__IgnoreA"))
+
+unittest(11, enumToInteger(IgnoreTest_ignoreB_eleven_get(), "_IgnoreTest__IgnoreB"))
+unittest(12, enumToInteger(IgnoreTest_ignoreB_twelve_get(), "_IgnoreTest__IgnoreB"))
+unittest(31, enumToInteger(IgnoreTest_ignoreB_thirty_one_get(), "_IgnoreTest__IgnoreB"))
+unittest(32, enumToInteger(IgnoreTest_ignoreB_thirty_two_get(), "_IgnoreTest__IgnoreB"))
+unittest(41, enumToInteger(IgnoreTest_ignoreB_forty_one_get(), "_IgnoreTest__IgnoreB"))
+unittest(42, enumToInteger(IgnoreTest_ignoreB_forty_two_get(), "_IgnoreTest__IgnoreB"))
+
+unittest(10, enumToInteger(IgnoreTest_ignoreC_ten_get(), "_IgnoreTest__IgnoreC"))
+unittest(12, enumToInteger(IgnoreTest_ignoreC_twelve_get(), "_IgnoreTest__IgnoreC"))
+unittest(30, enumToInteger(IgnoreTest_ignoreC_thirty_get(), "_IgnoreTest__IgnoreC"))
+unittest(32, enumToInteger(IgnoreTest_ignoreC_thirty_two_get(), "_IgnoreTest__IgnoreC"))
+unittest(40, enumToInteger(IgnoreTest_ignoreC_forty_get(), "_IgnoreTest__IgnoreC"))
+unittest(42, enumToInteger(IgnoreTest_ignoreC_forty_two_get(), "_IgnoreTest__IgnoreC"))
+
+unittest(21, enumToInteger(IgnoreTest_ignoreD_twenty_one_get(), "_IgnoreTest__IgnoreD"))
+unittest(22, enumToInteger(IgnoreTest_ignoreD_twenty_two_get(), "_IgnoreTest__IgnoreD"))
+
+unittest(0, enumToInteger(IgnoreTest_ignoreE_zero_get(), "_IgnoreTest__IgnoreE"))
+unittest(21, enumToInteger(IgnoreTest_ignoreE_twenty_one_get(), "_IgnoreTest__IgnoreE"))
+unittest(22, enumToInteger(IgnoreTest_ignoreE_twenty_two_get(), "_IgnoreTest__IgnoreE"))
+
+## confirm that an ignore directive is followed:
+unittest(TRUE, is.na(ignoreCTest("ignoreC_eleven")))
+
+
+## repeat test
+unittest(1, enumToInteger(repeatTest("one"), "_RepeatSpace__repeat"))
+unittest(1, enumToInteger(repeatTest("initial"), "_RepeatSpace__repeat"))
+unittest(2, enumToInteger(repeatTest("two"), "_RepeatSpace__repeat"))
+unittest(3, enumToInteger(repeatTest("three"), "_RepeatSpace__repeat"))
+unittest(3, enumToInteger(repeatTest("llast"), "_RepeatSpace__repeat"))
+unittest(3, enumToInteger(repeatTest("end"), "_RepeatSpace__repeat"))
+
+## Macro test - nothing in csharp
+## Note - this enum is set up with both entries the same
+## This means that mapping back from the integer value to the
+## string value isn't unique, so asking for "ABCD2" will return
+## a string of "ABCD"
+unittest("ABCD", enumWithMacroTest("ABCD"))
+
+## Different types
+unittest(10, enumToInteger(differentTypesTest("typeint"), "_DifferentSpace__DifferentTypes"))
+unittest(0, enumToInteger(differentTypesTest("typeboolfalse"), "_DifferentSpace__DifferentTypes"))
+unittest(1, enumToInteger(differentTypesTest("typebooltrue"), "_DifferentSpace__DifferentTypes"))
+unittest(2, enumToInteger(differentTypesTest("typebooltwo"), "_DifferentSpace__DifferentTypes"))
+unittest(utf8ToInt('C'), enumToInteger(differentTypesTest("typechar"), "_DifferentSpace__DifferentTypes"))
+unittest(utf8ToInt('D'), enumToInteger(differentTypesTest("typedefaultint"), "_DifferentSpace__DifferentTypes"))
+unittest(utf8ToInt('A') + 1, enumToInteger(differentTypesTest("typecharcompound"), "_DifferentSpace__DifferentTypes"))
+
+
+## Global different types
+## Test uses an anonymous type so the string mapping
+## framework doesn't exist.