Merge branch 'master' of ssh://pharmon@git.eclipse.org/gitroot/edt/org.eclipse.edt.git
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/.project b/tests/org.eclipse.edt.eunit.test.ibmi/.project
new file mode 100644
index 0000000..f0e7d00
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/.project
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.edt.eunit.test.ibmi</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+	</buildSpec>
+	<natures>
+	</natures>
+</projectDescription>
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.classpath b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.classpath
new file mode 100644
index 0000000..8612c28
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.classpath
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="src" path="generatedJava"/>
+	<classpathentry kind="con" path="org.eclipse.edt.ide.core.EDT_CONTAINER/javagen"/>
+	<classpathentry kind="con" path="org.eclipse.edt.ide.core.EDT_CONTAINER/org.eclipse.edt.ide.jtopen.ibmiContainer"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.cvsignore b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.cvsignore
new file mode 100644
index 0000000..4331489
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.cvsignore
@@ -0,0 +1,2 @@
+generatedJava
+EGLBin
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.eglPath b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.eglPath
new file mode 100644
index 0000000..5e59e5d
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.eglPath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<eglpath>
+	<eglpathentry kind="src" path="EGLSource"/>
+	<eglpathentry kind="con" path="org.eclipse.edt.compiler.EDT_RUNTIME"/>
+	<eglpathentry path="EGLBin" kind="output"/>
+</eglpath>
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.project b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.project
new file mode 100644
index 0000000..2b23407
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.project
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>thirdparty.programs</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.edt.ide.core.EDTBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.edt.ide.core.EDTGenBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.edt.debug.core.smapBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.edt.ide.core.eglnature</nature>
+	</natures>
+</projectDescription>
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.settings/org.eclipse.core.resources.prefs b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 0000000..da161ef
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,3 @@
+#Mon Feb 13 13:43:03 EST 2012
+eclipse.preferences.version=1
+encoding/.eglPath=UTF-8
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.settings/org.eclipse.edt.ide.compiler.prefs b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.settings/org.eclipse.edt.ide.compiler.prefs
new file mode 100644
index 0000000..4d7109c
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.settings/org.eclipse.edt.ide.compiler.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+javaGenDirectory/<project>=P/generatedJava
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.settings/org.eclipse.edt.ide.core.prefs b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.settings/org.eclipse.edt.ide.core.prefs
new file mode 100644
index 0000000..f1b62df
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/.settings/org.eclipse.edt.ide.core.prefs
@@ -0,0 +1,6 @@
+DefaultDeploymentDescriptorPath/<project>=/thirdparty.programs/EGLSource/thirdparty_programs.egldd
+compilerId/<project>=org.eclipse.edt.ide.compiler.edtCompiler
+eclipse.preferences.version=1
+generatorIds//EGLSource/client=org.eclipse.edt.ide.gen.JavaScriptGenProvider,org.eclipse.edt.ide.gen.JavaScriptDevGenProvider
+generatorIds//EGLSource/server=org.eclipse.edt.ide.gen.JavaGenProvider
+generatorIds/<project>=org.eclipse.edt.ide.gen.JavaGenProvider
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/.ibmi/.properties b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/.ibmi/.properties
new file mode 100644
index 0000000..666eb0b
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/.ibmi/.properties
@@ -0,0 +1,2 @@
+#Tue Jun 12 08:39:24 EDT 2012
+com.ibm.etools.iseries.remotebuild\:ActiveBuildStyle=com.ibm.etools.iseries.remotebuild.style.program
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/.ibmi/QSOURCE/.properties b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/.ibmi/QSOURCE/.properties
new file mode 100644
index 0000000..4a8d198
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/.ibmi/QSOURCE/.properties
@@ -0,0 +1,2 @@
+#Tue Jun 12 08:39:24 EDT 2012
+com.ibm.etools.iseries.projects.core\:ccsid=37
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/.ibmi/QVGNCBLS/.properties b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/.ibmi/QVGNCBLS/.properties
new file mode 100644
index 0000000..121f0d1
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/.ibmi/QVGNCBLS/.properties
@@ -0,0 +1,4 @@
+#Tue Jun 12 08:40:50 EDT 2012
+com.ibm.etools.iseries.projects.core\:ccsid=37
+com.ibm.etools.iseries.projects.core\:recordLength=92
+com.ibm.etools.iseries.projects.core\:textDescription=EGL GENERATION - COBOL SRC
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/.project b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/.project
new file mode 100644
index 0000000..33e045b
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/.project
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>AS4069.rtp.raleigh.ibm.com_TSTSRVPGM</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.ibm.etools.iseries.perspective.projectBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.ibm.etools.iseries.projects.modelValidator</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.ibm.etools.iseries.perspective.nature</nature>
+	</natures>
+</projectDescription>
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QSOURCE/EDTPRIM.RPGLE b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QSOURCE/EDTPRIM.RPGLE
new file mode 100644
index 0000000..be58574
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QSOURCE/EDTPRIM.RPGLE
@@ -0,0 +1,185 @@
+000100120305     H NOMAIN
+000101120305
+000102120305
+000103120305
+000104120222     D USANULL         DS
+000105120611     D  dMonth                        2s 0
+000106120611     D  dDay                          2s 0
+000107120611     D  dYear                         4s 0
+000108120222
+000109120611     D TIMENULLSEP     DS
+000110120611     D  tHour                         2s 0
+000111120611     D  tMin                          2s 0
+000112120611     D  tSec                          2s 0
+000113120606
+000114120606     D PInts           PR
+000115120222     D i1                             3i 0
+000116120222     d i2                             5i 0
+000117120222     d i4                            10i 0
+000118120222     d i8                            20i 0
+000119120222
+000120120305     D PText           PR
+000121120606     D c1                            20a
+000122120606     D c2                            20a
+000123120606     d u1                            20c
+000124120606     d u2                            20c
+000125120606
+000126120305     D PUints          PR
+000127120305     D i1                             3u 0
+000128120222     d i2                             5u 0
+000129120222     d i4                            10u 0
+000130120222     d i8                            20u 0
+000131120222
+000132120222     D pFlts           PR
+000133120222     D f4                             4f
+000134120222     D f8                             8f
+000135120222
+000136120222     D pZone           PR
+000137120222     D z112                          11S 2
+000138120222     D z150                          15S 0
+000139120222
+000140120222     D pPack           PR
+000141120222     D p174                          17p 4
+000142120222     D p80                            8p 0
+000143120222
+000144120222     D pDate           PR
+000145120611     D pd1                             d   datfmt(*ISO)
+000146120611     D pd2                             d   datfmt(*USA)
+000147120611     D pd3                                 likeds(USANULL)
+000148120222
+000149120606     D pTime           PR
+000150120611     D t1                              T   timfmt(*ISO)
+000151120611     D t2                              t   timfmt(*eur)
+000152120611     D t3                                  likeds(TIMENULLSEP)
+000153120606
+000154120606     D pTimeSt         PR
+000155120222     D ts                              z
+000156120222
+000157120222
+000158120222
+000159120222     P PInts           B                   export
+000160120221     D                 PI
+000161120222     D i1                             3i 0
+000162120222     d i2                             5i 0
+000163120222     d i4                            10i 0
+000164120222     d i8                            20i 0
+000165120222      /free
+000166120222       i1 = i1 + 98;
+000167120222       i2 = i2 + 998;
+000168120222       i4 = i4 + 9998;
+000169120222       i8 = i8 + 99998;
+000170120222      /end-free
+000171120222     p PInts           e
+000172120222
+000173120222
+000174120222     P Puints          B                   export
+000175120222     D                 PI
+000176120222     D u1                             3u 0
+000177120222     d u2                             5u 0
+000178120222     d u4                            10u 0
+000179120222     d u8                            20u 0
+000180120222      /free
+000181120222       u1 = u1 + 98;
+000182120222       u2 = u2 + 998;
+000183120222       u4 = u4 + 9998;
+000184120222       u8 = u8 + 99998;
+000185120222      /end-free
+000186120222     p Puints          e
+000187120222
+000188120222
+000189120222     p pFlts           b                   export
+000190120222     D                 PI
+000191120222     D f4                             4f
+000192120222     d f8                             8f
+000193120222
+000194120222      /free
+000195120222       f4 = f4 + 99e-2;
+000196120222       f8 = f8 + 99e-2;
+000197120222      /end-free
+000198120222     p pFlts           e
+000199120222
+000200120222
+000201120222
+000202120222
+000203120222     p pZone           b                   export
+000204120222     D                 PI
+000205120222     D z112                          11S 2
+000206120222     D z150                          15S 0
+000207120222      /free
+000208120222       z112 = z112 + 98;
+000209120222       z150 = z150 + 998;
+000210120222      /end-free
+000211120222     p pZone           e
+000212120222
+000213120222
+000214120222
+000215120222
+000216120222     P pPack           b                   export
+000217120222     D                 PI
+000218120222     D p174                          17p 4
+000219120222     D p80                            8p 0
+000220120222      /free
+000221120222       p174 = p174 + 9998;
+000222120222       p80 = p80 + 99998;
+000223120222      /end-free
+000224120222     p pPack           e
+000225120222
+000226120222
+000227120222
+000228120305     P pText           b                   export
+000229120305     D                 PI
+000230120305     D a1                            20a
+000231120606     D a2                            20a
+000232120606     D u1                            20c
+000233120606     D u2                            20c
+000234120606
+000235120305      /free
+000236120305       a1 = %trimr(a1) + 'YYYYY';
+000237120606       a2 = %trimr(a2) + 'YYYYY';
+000238120606       u1 = %subst(u1:1:4) + %ucs2('ZZZZZZZZZZ');
+000239120606       u2 = %subst(u2:1:4) + %ucs2('ZZZZZZZZZZ');
+000240120606      /end-free
+000241120305     p pText           e
+000242120305
+000243120305
+000244120305     P pDate           b                   export
+000245120222     D                 PI
+000246120611     D pd1                             d   datfmt(*ISO)
+000247120611     D pd2                             d   datfmt(*USA)
+000248120611     D pd3                                 likeds(USANULL)
+000249120222      /free
+000250120611       pd1 = pd1 + %days(5) + %months(5) + %years(5);
+000251120611       pd2 = pd2 + %days(5) + %months(5) + %years(5);
+000252120611       pd3.dMonth = pd3.dMonth + 5;
+000253120611       pd3.dDay =  pd3.dDay + 5;
+000254120611       pd3.dYear = pd3.dYear + 5;
+000255120222      /end-free
+000256120222     p pDate           e
+000257120222
+000258120222
+000259120606     P pTime           b                   export
+000260120606     D                 PI
+000261120611     D t1                              t   timfmt(*ISO)
+000262120611     D t2                              t   timfmt(*EUR)
+000263120611     D t3                                  likeds(TIMENULLSEP)
+000264120606      /free
+000265120611       t1 = t1 + %hours(5) + %minutes(5) + %seconds(5);
+000266120611       t2 = t2 + %hours(5) + %minutes(5) + %seconds(5);
+000267120611       t3.tHour = t3.tHour + 5;
+000268120611       t3.tMin = t3.tMin + 5;
+000269120611       t3.tSec = t3.tSec + 5;
+000270120606      /end-free
+000271120606     p pTime           e
+000272120606
+000273120606
+000274120606     P pTimeST         b                   export
+000275120222     D                 PI
+000276120222     D ts                              z
+000277120222      /free
+000278120222       ts = ts + %days(5) + %months(5) + %years(5);
+000279120222       ts = ts + %hours(5) + %minutes(5) + %seconds(5);
+000280120222      /end-free
+000281120222     p pTimeST         e
+000282120611
+000283120611
+000284120222
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QSOURCE/EDTPRMA.RPGLE b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QSOURCE/EDTPRMA.RPGLE
new file mode 100644
index 0000000..2ad388b
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QSOURCE/EDTPRMA.RPGLE
@@ -0,0 +1,236 @@
+000100120305     H NOMAIN
+000101120305
+000102120305
+000103120305
+000104120222     D USANULL         DS
+000105120611     D  dMonth                        2s 0
+000106120611     D  dDay                          2s 0
+000107120611     D  dYear                         4s 0
+000108120222
+000109120611     D TIMENULLSEP     DS
+000110120611     D  tHour                         2s 0
+000111120611     D  tMin                          2s 0
+000112120611     D  tSec                          2s 0
+000113120606
+000114120606     D PInts           PR
+000115120306     D i1                             3i 0 Dim(4)
+000116120306     d i2                             5i 0 Dim(4)
+000117120306     d i4                            10i 0 Dim(4)
+000118120306     d i8                            20i 0 Dim(4)
+000119120306     d cnt                           10i 0
+000120120306
+000121120305     D PText           PR
+000122120306     D c1                            20a   Dim(4)
+000123120606     D c2                            20a   Dim(4)
+000124120606     d u1                            20c   Dim(4)
+000125120606     d u2                            20c   Dim(4)
+000126120606     d cnt                           10i 0
+000127120306
+000128120305     D PUints          PR
+000129120306     D u1                             3u 0 Dim(4)
+000130120306     d u2                             5u 0 Dim(4)
+000131120306     d u4                            10u 0 Dim(4)
+000132120306     d u8                            20u 0 Dim(4)
+000133120306     d cnt                           10i 0
+000134120306
+000135120222     D pFlts           PR
+000136120306     D f4                             4f   Dim(4)
+000137120306     D f8                             8f   Dim(4)
+000138120306     d cnt                           10i 0
+000139120306
+000140120222     D pZone           PR
+000141120306     D z150                          15S 0 Dim(4)
+000142120306     D z112                          11S 2 Dim(4)
+000143120306     d cnt                           10i 0
+000144120306
+000145120222     D pPack           PR
+000146120306     D p174                          17p 4 Dim(4)
+000147120306     D p80                            8p 0 Dim(4)
+000148120306     d cnt                           10i 0
+000149120306
+000150120222     D pDate           PR
+000151120611     D d1                              d   datfmt(*ISO) Dim(4)
+000152120611     D d2                              d   datfmt(*EUR) Dim(4)
+000153120611     D d3                                  likeds(USANULL) Dim(4)
+000154120306     d cnt                           10i 0
+000155120306
+000156120606     D pTime           PR
+000157120611     D t1                              t   timfmt(*ISO) Dim(4)
+000158120611     D t2                              t   timfmt(*EUR) Dim(4)
+000159120611     D t3                                  likeds(TIMENULLSEP) Dim(4)
+000160120606     d cnt                           10i 0
+000161120606
+000162120222     D pTimeSt         PR
+000163120306     D ts                              z   Dim(4)
+000164120306     d cnt                           10i 0
+000165120306
+000166120222
+000167120222
+000168120222     P PInts           B                   export
+000169120221     D                 PI
+000170120306     D i1                             3i 0 Dim(4)
+000171120306     d i2                             5i 0 Dim(4)
+000172120306     d i4                            10i 0 Dim(4)
+000173120306     d i8                            20i 0 Dim(4)
+000174120306     d cnt                           10i 0
+000175120306     d i               S              5i 0
+000176120306      /free
+000177120306       FOR i = 1 TO 2;
+000178120306         i1(i) = i1(i) + 98;
+000179120306         i2(i) = i2(i) + 998;
+000180120306         i4(i) = i4(i) + 9998;
+000181120306         i8(i) = i8(i) + 99998;
+000182120306       ENDFOR;
+000183120306       cnt = 2;
+000184120306      /end-free
+000185120222     p PInts           e
+000186120222
+000187120222
+000188120222     P Puints          B                   export
+000189120222     D                 PI
+000190120306     D u1                             3u 0 Dim(4)
+000191120306     d u2                             5u 0 Dim(4)
+000192120306     d u4                            10u 0 Dim(4)
+000193120306     d u8                            20u 0 Dim(4)
+000194120306     d cnt                           10i 0
+000195120306     d i               S              5i 0
+000196120306      /free
+000197120306       FOR i = 1 TO 2;
+000198120306         u1(i) = u1(i) + 98;
+000199120306         u2(i) = u2(i) + 998;
+000200120306         u4(i) = u4(i) + 9998;
+000201120306         u8(i) = u8(i) + 99998;
+000202120306       endfor;
+000203120306       cnt = 2;
+000204120306      /end-free
+000205120222     p Puints          e
+000206120222
+000207120222
+000208120222     p pFlts           b                   export
+000209120222     D                 PI
+000210120306     D f4                             4f   Dim(4)
+000211120306     d f8                             8f   Dim(4)
+000212120306     d cnt                           10i 0
+000213120306     d i               S              5i 0
+000214120306
+000215120222      /free
+000216120306       FOR i = 1 TO 2;
+000217120306         f4(i) = f4(i) + 99e-2;
+000218120306         f8(i) = f8(i) + 99e-2;
+000219120306       endfor;
+000220120306       cnt = 2;
+000221120306      /end-free
+000222120222     p pFlts           e
+000223120222
+000224120222
+000225120222
+000226120222
+000227120222     p pZone           b                   export
+000228120222     D                 PI
+000229120306     D z150                          15S 0 Dim(4)
+000230120306     D z112                          11S 2 Dim(4)
+000231120306     d cnt                           10i 0
+000232120306     d i               S              5i 0
+000233120306      /free
+000234120306       FOR i = 1 TO 2;
+000235120306         z112(i) = 98 + z112(i);
+000236120306         z150(i) = 998 + z150(i);
+000237120306       endfor;
+000238120306       cnt = 2;
+000239120306      /end-free
+000240120222     p pZone           e
+000241120222
+000242120222
+000243120222
+000244120222
+000245120222     P pPack           b                   export
+000246120222     D                 PI
+000247120306     D p174                          17p 4 Dim(4)
+000248120306     D p80                            8p 0 Dim(4)
+000249120306     d cnt                           10i 0
+000250120306     d i               S              5i 0
+000251120306      /free
+000252120306       FOR i = 1 TO 2;
+000253120306         p174(i) = p174(i) + 9998;
+000254120306         p80(i) = p80(i) + 99998;
+000255120306       endfor;
+000256120306       cnt = 2;
+000257120306      /end-free
+000258120222     p pPack           e
+000259120222
+000260120222
+000261120222
+000262120305     P pText           b                   export
+000263120305     D                 PI
+000264120306     D c1                            20a   Dim(4)
+000265120606     D c2                            20a   Dim(4)
+000266120606     d u1                            20c   Dim(4)
+000267120606     d u2                            20c   Dim(4)
+000268120606     d cnt                           10i 0
+000269120306     d i               S              5i 0
+000270120306
+000271120305      /free
+000272120306       FOR i = 1 TO 2;
+000273120306         c1(i) = %trimr(c1(i)) + 'YYYYY';
+000274120606         c2(i) = %trimr(c2(i)) + 'YYYYY';
+000275120606
+000276120606         u1(i) = %subst(u1(i):1:4) + %ucs2('ZZZZZZZZZZ');
+000277120606         u2(i) = %subst(u2(i):1:4) + %ucs2('ZZZZZZZZZZ');
+000278120306       endfor;
+000279120306       cnt = 2;
+000280120306      /end-free
+000281120305     p pText           e
+000282120305
+000283120606     P pDate           b                   export
+000285120222     D                 PI
+000286120611     D d1                              d   datfmt(*ISO) Dim(4)
+000287120611     D d2                              d   datfmt(*EUR) Dim(4)
+000288120611     D d3                                  likeds(USANULL) Dim(4)
+000289120306     d cnt                           10i 0
+000290120306     d i               S              5i 0
+000291120306      /free
+000292120306       FOR i = 1 TO 2;
+000293120611         d1(i) = d1(i) + %days(5) + %months(5) + %years(5);
+000294120611         d2(i) = d2(i) + %days(5) + %months(5) + %years(5);
+000295120611         d3(i).dMonth = d3(i).dMonth + 5;
+000296120611         d3(i).dDay =  d3(i).dDay + 5;
+000297120611         d3(i).dYear = d3(i).dYear + 5;
+000298120306       endfor;
+000299120306       cnt = 2;
+000300120306      /end-free
+000301120222     p pDate           e
+000302120222
+000303120606     P pTime           b                   export
+000304120606     D                 PI
+000305120611     D t1                              t   timfmt(*ISO) Dim(4)
+000306120611     D t2                              t   timfmt(*EUR) Dim(4)
+000307120611     D t3                                  likeds(TIMENULLSEP) Dim(4)
+000308120606     d cnt                           10i 0
+000309120606     d i               S              5i 0
+000310120606      /free
+000311120606       FOR i = 1 TO 2;
+000312120611         t1(i) = t1(i) + %hours(5) + %minutes(5) + %seconds(5);
+000313120611         t2(i) = t2(i) + %hours(5) + %minutes(5) + %seconds(5);
+000314120611         t3(i).tHour = t3(i).tHour + 5;
+000315120611         t3(i).tMin = t3(i).tMin + 5;
+000316120611         t3(i).tSec = t3(i).tSec + 5;
+000317120606       endfor;
+000318120606       cnt = 2;
+000319120606      /end-free
+000320120611     p pTime           e
+000321120606
+000322120222
+000323120222     P pTimeST         b                   export
+000324120222     D                 PI
+000325120306     D ts                              z   Dim(4)
+000326120306     d cnt                           10i 0
+000327120306     d i               S              5i 0
+000328120306      /free
+000329120306       FOR i = 1 TO 2;
+000330120306         ts(i) = ts(i) + %days(5) + %months(5) + %years(5);
+000331120306         ts(i) = ts(i) + %hours(5) + %minutes(5) + %seconds(5);
+000332120306       endfor;
+000333120306       cnt = 2;
+000334120306      /end-free
+000335120222     p pTimeST         e
+000336120222
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QSOURCE/EDTRA.RPGLE b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QSOURCE/EDTRA.RPGLE
new file mode 100644
index 0000000..8b99909
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QSOURCE/EDTRA.RPGLE
@@ -0,0 +1,205 @@
+000100120305     H NOMAIN
+000101120305
+000102120305     D USANULL         DS                  qualified
+000103120611     D  dMonth                        2s 0
+000104120611     D  dDay                          2s 0
+000105120611     D  dYear                         4s 0
+000106120305
+000107120611     D TIMENULLSEP     DS
+000108120611     D  tHour                         2s 0
+000109120611     D  tMin                          2s 0
+000110120611     D  tSec                          2s 0
+000111120606
+000112120305
+000113120305     D RECORD1         DS                  qualified
+000114120305     D   c1                          20a
+000115120606     D   c2                          20a
+000116120606     d   uc1                         20c
+000117120606     d   uc2                         20c
+000118120606     D   i1                           3i 0
+000119120305     d   i2                           5i 0
+000120120305     d   i4                          10i 0
+000121120305     d   i8                          20i 0
+000122120305     D   p174                        17p 4
+000123120305     D   p80                          8p 0
+000124120306     D   z150                        15S 0
+000125120306     D   z112                        11S 2
+000126120306     D   u1                           3u 0
+000127120305     d   u2                           5u 0
+000128120305     d   u4                          10u 0
+000129120305     d   u8                          20u 0
+000130120611     D   d1                            d   datfmt(*ISO)
+000131120611     D   d2                            d   datfmt(*EUR)
+000132120611     D   d3                                likeds(USANULL)
+000133120611     D   t1                            t   timfmt(*ISO)
+000134120611     D   t2                            t   timfmt(*EUR)
+000135120611     D   t3                                likeds(TIMENULLSEP)
+000136120606     D   ts                            z
+000137120306     D   f4                           4f
+000138120305     D   f8                           8f
+000139120305
+000140120306     D RECORD11        DS                  qualified
+000141120306     D   rec                                likeds(RECORD1)
+000142120306     D   c1                          20a   Dim(4)
+000143120606     D   c2                          20a   Dim(4)
+000144120606     d   uc1                         20c   Dim(4)
+000145120606     d   uc2                         20c   Dim(4)
+000146120606     D   i1                           3i 0 Dim(4)
+000147120306     d   i2                           5i 0 Dim(4)
+000148120306     d   i4                          10i 0 Dim(4)
+000149120306     d   i8                          20i 0 Dim(4)
+000150120306     D   p174                        17p 4 Dim(4)
+000151120306     D   p80                          8p 0 Dim(4)
+000152120306     D   z150                        15S 0 Dim(4)
+000153120306     D   z112                        11S 2 Dim(4)
+000154120306     D   u1                           3u 0 Dim(4)
+000155120306     d   u2                           5u 0 Dim(4)
+000156120306     d   u4                          10u 0 Dim(4)
+000157120306     d   u8                          20u 0 Dim(4)
+000158120611     D   d1                            d   datfmt(*ISO) Dim(4)
+000168120611     D   d2                            d   datfmt(*EUR) Dim(4)
+000169120611     D   d3                                likeds(USANULL) Dim(4)
+000170120611     D   t1                            t   timfmt(*ISO) Dim(4)
+000171120611     D   t2                            t   timfmt(*EUR) Dim(4)
+000172120611     D   t3                                likeds(TIMENULLSEP) Dim(4)
+000173120606     D   ts                            z   Dim(4)
+000174120306     D   f4                           4f   Dim(4)
+000175120306     D   f8                           8f   Dim(4)
+000176120306     D   recA                               likeds(RECORD1) dim(4)
+000177120306     d   cnt                         10i 0
+000178120306
+000179120305
+000180120306     D PRECS           PR
+000181120306     D recS                                 likeds(Record11) DIM(5)
+000182120306     d cnt                           10i 0
+000183120306
+000184120222
+000185120222
+000186120306     P PRECS           B                   export
+000187120306     D                 PI
+000188120306
+000189120306     D recS                                 likeds(Record11) DIM(5)
+000190120306     d cnt                           10i 0
+000191120306     d x               S              5i 0
+000192120306     d y               S              5i 0
+000193120306      /free
+000194120306       FOR x = 1 TO 2;
+000195120306         recs(x).rec.i1 = recs(x).rec.i1 + 98;
+000196120306         recs(x).rec.i2 = recs(x).rec.i2 + 998;
+000197120306         recs(x).rec.i4 = recs(x).rec.i4 + 9998;
+000198120306         recs(x).rec.i8 = recs(x).rec.i8 + 99998;
+000199120306         recs(x).rec.u1 = recs(x).rec.u1 + 98;
+000200120306         recs(x).rec.u2 = recs(x).rec.u2 + 998;
+000201120306         recs(x).rec.u4 = recs(x).rec.u4 + 9998;
+000202120306         recs(x).rec.u8 = recs(x).rec.u8 + 99998;
+000203120306         recs(x).rec.f4 = recs(x).rec.f4 + 99e-2;
+000204120306         recs(x).rec.f8 = recs(x).rec.f8 + 99e-2;
+000205120306         recs(x).rec.z112 = 98 + recs(x).rec.z112;
+000206120306         recs(x).rec.z150 = 998 + recs(x).rec.z150;
+000207120306         recs(x).rec.p174 = recs(x).rec.p174 + 9998;
+000208120306         recs(x).rec.p80 = recs(x).rec.p80 + 99998;
+000209120306         recs(x).rec.c1 = %trimr(recs(x).rec.c1) + 'YYYYY';
+000210120606         recs(x).rec.c2 = %trimr(recs(x).rec.c2) + 'YYYYY';
+000211120606         recs(x).rec.uc1 = %subst(recs(x).rec.uc1:1:4) + %ucs2('ZZZZZZZZZZ');
+000212120606         recs(x).rec.uc2 = %subst(recs(x).rec.uc2:1:4) + %ucs2('ZZZZZZZZZZ');
+000213120611         recs(x).rec.d1 = recs(x).rec.d1 +
+000214120306                              %days(5) + %months(5) + %years(5);
+000215120611         recs(x).rec.d2 = recs(x).rec.d2 +
+000216120306                              %days(5) + %months(5) + %years(5);
+000217120611         recs(x).rec.d3.dMonth = recs(x).rec.d3.dMonth + 5;
+000219120611         recs(x).rec.d3.dDay = recs(x).rec.d3.dDay + 5;
+000220120611         recs(x).rec.d3.dYear = recs(x).rec.d3.dYear + 5;
+000222120611         recs(x).rec.t1 = recs(x).rec.t1 +
+000223120606                              %hours(5) + %minutes(5) + %seconds(5);
+000224120611         recs(x).rec.t2 = recs(x).rec.t2 +
+000225120606                              %hours(5) + %minutes(5) + %seconds(5);
+000226120611         recs(x).rec.t3.tHour = recs(x).rec.t3.tHour + 5;
+000228120611         recs(x).rec.t3.tMin =  recs(x).rec.t3.tMin + 5;
+000229120611         recs(x).rec.t3.tSec = recs(x).rec.t3.tSec + 5;
+000231120606         recs(x).rec.ts = recs(x).rec.ts + %days(5) + %months(5) + %years(5);
+000232120606         recs(x).rec.ts = recs(x).rec.ts +
+000233120306                              %hours(5) + %minutes(5) + %seconds(5);
+000234120306         FOR y = 1 TO 2;
+000271120306           recs(x).i1(y) = recs(x).i1(y) + 98;
+000272120306           recs(x).i2(y) = recs(x).i2(y) + 998;
+000273120306           recs(x).i4(y) = recs(x).i4(y) + 9998;
+000274120306           recs(x).i8(y) = recs(x).i8(y) + 99998;
+000275120306           recs(x).u1(y) = recs(x).u1(y) + 98;
+000276120306           recs(x).u2(y) = recs(x).u2(y) + 998;
+000277120306           recs(x).u4(y) = recs(x).u4(y) + 9998;
+000278120306           recs(x).u8(y) = recs(x).u8(y) + 99998;
+000279120306           recs(x).f4(y) = recs(x).f4(y) + 99e-2;
+000280120306           recs(x).f8(y) = recs(x).f8(y) + 99e-2;
+000281120306           recs(x).z112(y) = 98 + recs(x).z112(y);
+000282120306           recs(x).z150(y) = 998 + recs(x).z150(y);
+000283120306           recs(x).p174(y) = recs(x).p174(y) + 9998;
+000284120306           recs(x).p80(y) = recs(x).p80(y) + 99998;
+000285120306           recs(x).c1(y) = %trimr(recs(x).c1(y)) + 'YYYYY';
+000286120606           recs(x).c2(y) = %trimr(recs(x).c2(y)) + 'YYYYY';
+000287120606           recs(x).uc1(y) = %subst(recs(x).uc1(y):1:4) +
+000288120306                                  %ucs2('ZZZZZZZZZZ');
+000289120606           recs(x).uc2(y) = %subst(recs(x).uc2(y):1:4) +
+000290120606                                  %ucs2('ZZZZZZZZZZ');
+000291120611           recs(x).d1(y) = recs(x).d1(y) +
+000292120306                              %days(5) + %months(5) + %years(5);
+000293120611           recs(x).d2(y) = recs(x).d2(y) +
+000294120306                              %days(5) + %months(5) + %years(5);
+000295120611           recs(x).d3(y).dMonth = recs(x).d3(y).dMonth + 5;
+000297120611           recs(x).d3(y).dDay = recs(x).d3(y).dDay + 5;
+000299120611           recs(x).d3(y).dYear = recs(x).d3(y).dYear + 5;
+000301120611           recs(x).t1(y) = recs(x).t1(y) +
+000302120606                              %hours(5) + %minutes(5) + %seconds(5);
+000303120611           recs(x).t2(y) = recs(x).t2(y) +
+000304120606                              %hours(5) + %minutes(5) + %seconds(5);
+000305120611           recs(x).t3(y).tHour = recs(x).t3(y).tHour + 5;
+000307120611           recs(x).t3(y).tMin = recs(x).t3(y).tMin + 5;
+000309120611           recs(x).t3(y).tSec = recs(x).t3(y).tSec + 5;
+000311120606           recs(x).ts(y) = recs(x).ts(y) +
+000312120306                      %days(5) + %months(5) + %years(5);
+000313120606           recs(x).ts(y) = recs(x).ts(y) +
+000314120306                              %hours(5) + %minutes(5) + %seconds(5);
+000315120306           recs(x).recA(y).i1 = recs(x).recA(y).i1 + 98;
+000316120306           recs(x).recA(y).i2 = recs(x).recA(y).i2 + 998;
+000317120306           recs(x).recA(y).i4 = recs(x).recA(y).i4 + 9998;
+000318120306           recs(x).recA(y).i8 = recs(x).recA(y).i8 + 99998;
+000319120306           recs(x).recA(y).u1 = recs(x).recA(y).u1 + 98;
+000320120306           recs(x).recA(y).u2 = recs(x).recA(y).u2 + 998;
+000321120306           recs(x).recA(y).u4 = recs(x).recA(y).u4 + 9998;
+000322120306           recs(x).recA(y).u8 = recs(x).recA(y).u8 + 99998;
+000323120306           recs(x).recA(y).f4 = recs(x).recA(y).f4 + 99e-2;
+000324120306           recs(x).recA(y).f8 = recs(x).recA(y).f8 + 99e-2;
+000325120306           recs(x).recA(y).z112 = 98 + recs(x).recA(y).z112;
+000326120306           recs(x).recA(y).z150 = 998 + recs(x).recA(y).z150;
+000327120306           recs(x).recA(y).p174 = recs(x).recA(y).p174 + 9998;
+000328120306           recs(x).recA(y).p80 = recs(x).recA(y).p80 + 99998;
+000329120612           recs(x).recA(y).c1 = %trimr(recs(x).recA(y).c1) + 'YYYYY';
+000330120612           recs(x).recA(y).c2 = %trimr(recs(x).recA(y).c2) + 'YYYYY';
+000331120612           recs(x).recA(y).uc1 = %subst(recs(x).recA(y).uc1:1:4) +
+000332120612                                 %ucs2('ZZZZZZZZZZ');
+000333120612           recs(x).recA(y).uc2 = %subst(recs(x).recA(y).uc2:1:4) +
+000334120612                                 %ucs2('ZZZZZZZZZZ');
+000335120612           recs(x).recA(y).d1 = recs(x).recA(y).d1 +
+000336120306                              %days(5) + %months(5) + %years(5);
+000337120612           recs(x).recA(y).d2 = recs(x).recA(y).d2 +
+000338120306                              %days(5) + %months(5) + %years(5);
+000339120612           recs(x).recA(y).d3.dMonth = recs(x).recA(y).d3.dMonth + 5;
+000340120612           recs(x).recA(y).d3.dDay = recs(x).recA(y).d3.dDay + 5;
+000341120612           recs(x).recA(y).d3.dYear = recs(x).recA(y).d3.dYear + 5;
+000342120612           recs(x).recA(y).t1 = recs(x).recA(y).t1 +
+000350120612                              %hours(5) + %minutes(5) + %seconds(5);
+000351120612           recs(x).recA(y).t2 = recs(x).recA(y).t2 +
+000352120612                              %hours(5) + %minutes(5) + %seconds(5);
+000353120612           recs(x).recA(y).t3.tHour = recs(x).recA(y).t3.tHour + 5;
+000354120612           recs(x).recA(y).t3.tMin = recs(x).recA(y).t3.tMin + 5;
+000355120612           recs(x).recA(y).t3.tSec = recs(x).recA(y).t3.tSec + 5;
+000356120612           recs(x).recA(y).ts = recs(x).recA(y).ts +
+000357120612                      %days(5) + %months(5) + %years(5);
+000358120612           recs(x).recA(y).ts = recs(x).recA(y).ts +
+000359120612                              %hours(5) + %minutes(5) + %seconds(5);
+000360120612         ENDFOR;
+000361120306         recs(x).cnt = 2;
+000362120306       ENDFOR;
+000363120306       cnt = 2;
+000364120222      /end-free
+000365120306     p PRECS           e
+000366120222
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QSOURCE/EDTREC.RPGLE b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QSOURCE/EDTREC.RPGLE
new file mode 100644
index 0000000..a99075c
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QSOURCE/EDTREC.RPGLE
@@ -0,0 +1,83 @@
+000100120305     H NOMAIN
+000101120305
+000102120305     D USANULL         DS                  qualified
+000103120611     D  dMonth                        2s 0
+000104120611     D  dDay                          2s 0
+000105120611     D  dYear                         4s 0
+000106120305
+000107120611     D TIMENULLSEP     DS                  qualified
+000108120611     D  tHour                         2s 0
+000109120611     D  tMin                          2s 0
+000110120611     D  tSec                          2s 0
+000111120606
+000112120606
+000113120305     D RECORD1         DS                  qualified
+000114120606     D   c1                          20a
+000115120606     D   c2                          20a
+000116120606     d   uc1                         20c
+000117120606     d   uc2                         20c
+000118120606     D   i1                           3i 0
+000119120305     d   i2                           5i 0
+000120120305     d   i4                          10i 0
+000121120305     d   i8                          20i 0
+000122120305     D   p174                        17p 4
+000123120305     D   p80                          8p 0
+000124120306     D   z150                        15S 0
+000125120306     D   z112                        11S 2
+000126120306     D   u1                           3u 0
+000127120305     d   u2                           5u 0
+000128120305     d   u4                          10u 0
+000129120305     d   u8                          20u 0
+000130120611     D   d1                            d   datfmt(*ISO)
+000131120611     D   d2                            d   datfmt(*EUR)
+000132120611     D   d3                                likeds(USANULL)
+000133120611     D   t1                            t   timfmt(*ISO)
+000134120611     D   t2                            t   timfmt(*EUR)
+000135120611     D   t3                                likeds(TIMENULLSEP)
+000136120606     D   ts                            z
+000137120305     D   f4                           4f
+000138120305     D   f8                           8f
+000139120305
+000140120305
+000141120305     D PREC            PR
+000142120305     D rec                                 likeds(Record1)
+000143120305
+000165120222
+000166120222
+000167120305     P PREC            B                   export
+000168120221     D                 PI
+000169120305     D rec                                 likeds(Record1)
+000170120305      /free
+000171120306       rec.i1 = rec.i1 + 98;
+000175120305       rec.i2 = rec.i2 + 998;
+000176120305       rec.i4 = rec.i4 + 9998;
+000177120305       rec.i8 = rec.i8 + 99998;
+000178120305       rec.u1 = rec.u1 + 98;
+000190120305       rec.u2 = rec.u2 + 998;
+000191120305       rec.u4 = rec.u4 + 9998;
+000192120305       rec.u8 = rec.u8 + 99998;
+000193120305       rec.f4 = rec.f4 + 99e-2;
+000204120305       rec.f8 = rec.f8 + 99e-2;
+000205120306       rec.z112 = 98 + rec.z112;
+000217120306       rec.z150 = 998 + rec.z150;
+000218120305       rec.p174 = rec.p174 + 9998;
+000230120305       rec.p80 = rec.p80 + 99998;
+000231120305       rec.c1 = %trimr(rec.c1) + 'YYYYY';
+000243120606       rec.c2 = %trimr(rec.c2) + 'YYYYY';
+000244120606       rec.uc1 = %subst(rec.uc1:1:4) + %ucs2('ZZZZZZZZZZ');
+000245120606       rec.uc2 = %subst(rec.uc2:1:4) + %ucs2('ZZZZZZZZZZ');
+000246120611       rec.d1 = rec.d1 + %days(5) + %months(5) + %years(5);
+000255120611       rec.d2 = rec.d2 + %days(5) + %months(5) + %years(5);
+000256120611       rec.d3.dMonth = rec.d3.dMonth + 5;
+000257120611       rec.d3.dDay =  rec.d3.dDay + 5;
+000258120611       rec.d3.dYear = rec.d3.dYear + 5;
+000259120611       rec.t1 = rec.t1 + %hours(5) + %minutes(5) + %seconds(5);
+000260120611       rec.t2 = rec.t2 + %hours(5) + %minutes(5) + %seconds(5);
+000261120611       rec.t3.tHour = rec.t3.tHour + 5;
+000262120611       rec.t3.tMin = rec.t3.tMin + 5;
+000263120611       rec.t3.tSec = rec.t3.tSec + 5;
+000264120606       rec.ts = rec.ts + %days(5) + %months(5) + %years(5);
+000268120305       rec.ts = rec.ts + %hours(5) + %minutes(5) + %seconds(5);
+000269120222      /end-free
+000270120305     p PREC            e
+000271120222
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QVGNCBLS/EDTTSTP.CBLLE b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QVGNCBLS/EDTTSTP.CBLLE
new file mode 100644
index 0000000..7eede9c
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QVGNCBLS/EDTTSTP.CBLLE
@@ -0,0 +1,227 @@
+000100120214      *-----------------------------------------------------------------
+000200120203      * Program to test Data types (primitives) from EGL iSeries access
+000300000000      *-----------------------------------------------------------------
+000400120203
+000800000000       IDENTIFICATION DIVISION.
+000900120203       PROGRAM-ID.    EDTTSTP.
+001000000000       AUTHOR.                 NONE
+001100000000           INSTALLATION.       NONE
+001200120203           DATE WRITTEN.       2/5/2012.
+001300000000           DATE COMPILED.
+001400000000       ENVIRONMENT DIVISION.
+001500000000       CONFIGURATION SECTION.
+001600000000       SPECIAL-NAMES.
+006100120207       INPUT-OUTPUT SECTION.
+006101120207       FILE-CONTROL.
+006300000000       DATA DIVISION.
+006400000000
+006500000000       WORKING-STORAGE SECTION.
+024600000000       01  CL-CMD.
+024700000000           05  CL-CMD-DATA.
+024800000000              10  CL-CMD-OVRDBF PIC X(7) VALUE "OVRDBF ".
+024900000000              10  CL-CMD-OLDFILE PIC X(11).
+025000000000              10  CL-CMD-NEWFILE PIC X(33).
+025100000000              10  CL-CMD-SECURE  PIC X(12) VALUE "SECURE(*YES)".
+025200000000           05  CL-CMD-LENGTH PIC 9(10)V9(5) COMP-3 VALUE 63.
+056800120214
+056802120214       LINKAGE SECTION.
+056803120214
+059300120606       01  CHAR20      PIC X(20).
+059301120606       01  LCHAR20     PIC X(20).
+059302120606       01  UNICODE20   PIC N(20) USAGE NATIONAL.
+059303120606       01  LUNICODE20  PIC N(20) USAGE NATIONAL.
+059304120606       01  BIN2SIGN    PIC S9(4) COMP-4.
+059305120207       01  BIN4SIGN    PIC S9(9) COMP-4.
+059306120207       01  BIN8SIGN    PIC S9(18) COMP-4.
+059307120207       01  DEC112      PIC S9(9)V9(2) COMP-3.
+059308120214       01  DEC15       PIC S9(15) COMP-3.
+059309120214       01  NUM6        PIC S9(6).
+059310120214       01  NUM103      PIC S9(7)V9(3).
+059311120214       01  BIN2        PIC 9(4) COMP-4.
+059312120207       01  BIN4        PIC 9(9) COMP-4.
+059313120213       01  DATE1.
+059314120612           03 DATE1-YYYY PIC 9(4) USAGE DISPLAY.
+059315120213           03 FILLER   PIC X(1).
+059316120612           03 DATE1-MM PIC 9(2) USAGE DISPLAY.
+059317120213           03 FILLER   PIC X(1).
+059318120612           03 DATE1-DD PIC 9(2) USAGE DISPLAY.
+059319120213       01  DATE2.
+059320120612           03 DATE2-MM PIC 9(2) USAGE DISPLAY.
+059321120213           03 FILLER   PIC X(1).
+059322120612           03 DATE2-DD PIC 9(2) USAGE DISPLAY.
+059323120213           03 FILLER   PIC X(1).
+059324120612           03 DATE2-YYYY PIC 9(4) USAGE DISPLAY.
+059325120213       01  DATE3.
+059326120612           03 DATE3-MM PIC 9(2) USAGE DISPLAY.
+059327120612           03 DATE3-DD PIC 9(2) USAGE DISPLAY.
+059328120612           03 DATE3-YYYY PIC 9(4) USAGE DISPLAY.
+059329120606       01  TIME1.
+059330120612           03 TIME1-HH PIC 9(2) USAGE DISPLAY.
+059331120606           03 FILLER   PIC X(1).
+059332120612           03 TIME1-MM  PIC 9(2) USAGE DISPLAY.
+059333120606           03 FILLER   PIC X(1).
+059334120612           03 TIME1-SS PIC 9(2) USAGE DISPLAY.
+059335120606       01  TIME2.
+059336120612           03 TIME2-SS PIC 9(2) USAGE DISPLAY.
+059337120606           03 FILLER   PIC X(1).
+059338120612           03 TIME2-MM PIC 9(2) USAGE DISPLAY.
+059339120606           03 FILLER   PIC X(1).
+059340120612           03 TIME2-HH PIC 9(2) USAGE DISPLAY.
+059341120606       01  TIME3.
+059342120612           03 TIME3-SS PIC 9(2) USAGE DISPLAY.
+059343120612           03 TIME3-MM PIC 9(2) USAGE DISPLAY.
+059345120612           03 TIME3-HH PIC 9(2) USAGE DISPLAY.
+059347120606       01  TIMESTAMP1.
+059348120612           03 TS-YYYY  PIC 9(4) USAGE DISPLAY.
+059349120213           03 FILLER   PIC X(1).
+059350120612           03 TS-MM    PIC 9(2) USAGE DISPLAY.
+059351120213           03 FILLER   PIC X(1).
+059352120612           03 TS-DD    PIC 9(2) USAGE DISPLAY.
+059353120213           03 FILLER   PIC X(1).
+059354120612           03 TS-HH    PIC 9(2) USAGE DISPLAY.
+059355120213           03 FILLER   PIC X(1).
+059356120612           03 TS-MIN   PIC 9(2) USAGE DISPLAY.
+059357120213           03 FILLER   PIC X(1).
+059358120612           03 TS-SS    PIC 9(2) USAGE DISPLAY.
+059359120214           03 FILLER   PIC X(1).
+059360120612           03 TS-MS    PIC 9(6) USAGE DISPLAY.
+059361120214       01  FLOAT4      COMP-1.
+059362120210       01  FLOAT8      COMP-2.
+059363120211
+059364120210
+059700000000       PROCEDURE DIVISION USING
+059800120606                   CHAR20
+059801120606                   LCHAR20
+059802120606                   UNICODE20
+059803120606                   LUNICODE20
+059804120606                   BIN2SIGN
+059805120207                   BIN4SIGN
+059806120207                   BIN8SIGN
+059807120207                   DEC112
+059808120214                   DEC15
+059809120207                   NUM6
+059810120214                   NUM103
+059811120207                   BIN2
+059812120210                   BIN4
+059813120211                   DATE1
+059814120213                   DATE2
+059815120213                   DATE3
+059816120606                   TIME1
+059817120606                   TIME2
+059818120606                   TIME3
+059819120606                   TIMESTAMP1
+059820120210                   FLOAT4
+059821120213                   FLOAT8.
+059822120211
+059900000000      *-----------------------------------------------------------------
+060000000000      * MAIN PROCESS
+060100000000      *-----------------------------------------------------------------
+060200120203       MAIN-PARA SECTION.
+060201120207
+060202120606           DISPLAY "CHAR20 = " CHAR20
+060203120606           DISPLAY "LCHAR20 = " LCHAR20
+060204120606           DISPLAY "UNICODE20 = " UNICODE20
+060205120606           DISPLAY "LUNICODE20 = " LUNICODE20
+060206120606           DISPLAY "BIN2SIGN = " BIN2SIGN
+060207120207           DISPLAY "BIN4SIGN = " BIN4SIGN
+060208120207           DISPLAY "BIN8SIGN = " BIN8SIGN
+060209120207           DISPLAY "DEC112 = " DEC112
+060210120214           DISPLAY "DEC15 = " DEC15
+060211120214           DISPLAY "NUM6 = " NUM6
+060212120214           DISPLAY "NUM103 = " NUM103
+060213120214           DISPLAY "BIN2 = " BIN2
+060214120207           DISPLAY "BIN4 = " BIN4
+060215120210           DISPLAY "DATE1 = " DATE1
+060216120213           DISPLAY "DATE2 = " DATE2
+060217120213           DISPLAY "DATE3 = " DATE3
+060218120606           DISPLAY "TIME1 = " TIME1
+060219120606           DISPLAY "TIME2 = " TIME2
+060220120606           DISPLAY "TIME3 = " TIME3
+060221120606           DISPLAY "TIMESTAMP1 = " TIMESTAMP1
+060222120210           DISPLAY "FLOAT4 = " FLOAT4
+060223120210           DISPLAY "FLOAT8 = " FLOAT8
+060224120211
+060225120213
+060226120214           MOVE "YYYYY" TO CHAR20(5:5)
+060227120606           MOVE "YYYYY" TO LCHAR20(5:5)
+060228120606           MOVE  FUNCTION NATIONAL-OF("ZZZZZZZZZZ")
+060229120214               TO UNICODE20(5:10)
+060230120606           MOVE  FUNCTION NATIONAL-OF("ZZZZZZZZZZ")
+060231120606               TO LUNICODE20(5:10)
+060232120606           COMPUTE BIN2SIGN = BIN2SIGN + 98
+060233120207           COMPUTE BIN4SIGN = BIN4SIGN + 998
+060234120207           COMPUTE BIN8SIGN = BIN8SIGN + 9998
+060235120207           COMPUTE DEC112 = DEC112 + 998
+060236120214           COMPUTE DEC15 = DEC15 + 998
+060237120214           COMPUTE NUM6 = NUM6 + 9998
+060238120214           COMPUTE NUM103 = NUM103 + 9998
+060239120214           COMPUTE BIN2 = BIN2 + 98
+060240120207           COMPUTE BIN4 = BIN4 + 998
+060241120606      *    DATE1 FORMAT YYYY-MM-DD
+060253120213           COMPUTE DATE1-YYYY = DATE1-YYYY + 5
+060254120213           COMPUTE DATE1-MM = DATE1-MM + 5
+060255120213           COMPUTE DATE1-DD = DATE1-DD + 5
+060256120213
+060257120213      *    DATE2 FORMAT MM/DD/YYYY
+060258120213           COMPUTE DATE2-YYYY = DATE2-YYYY + 5
+060259120213           COMPUTE DATE2-MM = DATE2-MM + 5
+060260120213           COMPUTE DATE2-DD = DATE2-DD + 5
+060261120213
+060262120213      *    DATE3 FORMAT MMDDYYYY
+060263120213           COMPUTE DATE3-YYYY = DATE3-YYYY + 5
+060264120213           COMPUTE DATE3-MM = DATE3-MM + 5
+060265120213           COMPUTE DATE3-DD = DATE3-DD + 5
+060266120213
+060267120606      *    TIME1 FORMAT YYYY-MM-DD
+060268120606           COMPUTE TIME1-HH = TIME1-HH + 5
+060269120606           COMPUTE TIME1-MM = TIME1-MM + 5
+060270120606           COMPUTE TIME1-SS = TIME1-SS + 5
+060271120606
+060272120606      *    TIME2 FORMAT MM/DD/YYYY
+060273120606           COMPUTE TIME2-HH = TIME2-HH + 5
+060274120606           COMPUTE TIME2-MM = TIME2-MM + 5
+060275120612           COMPUTE TIME2-SS = TIME2-SS + 5
+060276120606
+060277120606      *    TIME3 FORMAT MMDDYYYY
+060278120606           COMPUTE TIME3-HH = TIME3-HH + 5
+060279120606           COMPUTE TIME3-MM = TIME3-MM + 5
+060280120606           COMPUTE TIME3-SS = TIME3-SS + 5
+060281120606
+060282120606      *    TIMESTAMP1 FORMAT = YYYY-MM-DD-HH.MM.SS
+060283120213           COMPUTE TS-YYYY = TS-YYYY + 5
+060284120213           COMPUTE TS-MM = TS-MM + 5
+060285120213           COMPUTE TS-DD = TS-DD + 5
+060286120213           COMPUTE TS-HH = TS-HH + 5
+060287120213           COMPUTE TS-MIN = TS-MIN + 5
+060288120213           COMPUTE TS-SS = TS-SS + 5
+060289120213
+060290120213      *     MOVE "1999-03-15-03.15.54" TO TIMESTAMP1
+060291120213
+060292120210           COMPUTE FLOAT4 = FLOAT4 + 9.9e-1
+060293120210           COMPUTE FLOAT8 = FLOAT8 + 9.9e-1
+060294120211
+060295120213           DISPLAY "CHAR20 = " CHAR20
+060296120214           DISPLAY "UNICODE20 = " UNICODE20
+060297120606           DISPLAY "LCHAR20 = " LCHAR20
+060298120606           DISPLAY "LUNICODE20 = " LUNICODE20
+060299120606           DISPLAY "DATE1 = " DATE1
+060300120213           DISPLAY "DATE2 = " DATE2
+060301120213           DISPLAY "DATE3 = " DATE3
+060302120213
+060303120606           DISPLAY "TIME1 = " TIME1
+060304120606           DISPLAY "TIME2 = " TIME2
+060305120606           DISPLAY "TIME3 = " TIME3
+060306120606           DISPLAY "TIMESTAMP1 = " TIMESTAMP1
+060307120203           PERFORM PARA-1.
+060308120203
+060400000000           GOBACK.
+060500000000
+062100120203       PARA-1 SECTION.
+063100000000           CONTINUE.
+063200120203       PARA-1-X.
+063300000000           EXIT.
+063400000000
+104700000000
+104800000000      *-----------------------------------------------------------------
+104900120203      * END OF PROGRAM EDTTSTP
+105000000000      *-----------------------------------------------------------------
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QVGNCBLS/EDTTSTPA.CBLLE b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QVGNCBLS/EDTTSTPA.CBLLE
new file mode 100644
index 0000000..934802d
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QVGNCBLS/EDTTSTPA.CBLLE
@@ -0,0 +1,263 @@
+000100000000      *-----------------------------------------------------------------
+000200120203      * Program to test Data types (primitives) from EGL iSeries access
+000300000000      *-----------------------------------------------------------------
+000400120203
+000800000000       IDENTIFICATION DIVISION.
+000900120210       PROGRAM-ID.    EDTTSTPA.
+001000000000       AUTHOR.                 NONE
+001100000000           INSTALLATION.       NONE
+001200120203           DATE WRITTEN.       2/5/2012.
+001300000000           DATE COMPILED.
+001400000000       ENVIRONMENT DIVISION.
+001500000000       CONFIGURATION SECTION.
+001600000000       SPECIAL-NAMES.
+006100120207       INPUT-OUTPUT SECTION.
+006101120207       FILE-CONTROL.
+006300000000       DATA DIVISION.
+006400000000
+006500000000       WORKING-STORAGE SECTION.
+006501120210       01 CNTR PIC S9(4) COMP-4.
+024600000000       01  CL-CMD.
+024700000000           05  CL-CMD-DATA.
+024800000000              10  CL-CMD-OVRDBF PIC X(7) VALUE "OVRDBF ".
+024900000000              10  CL-CMD-OLDFILE PIC X(11).
+025000000000              10  CL-CMD-NEWFILE PIC X(33).
+025100000000              10  CL-CMD-SECURE  PIC X(12) VALUE "SECURE(*YES)".
+025200000000           05  CL-CMD-LENGTH PIC 9(10)V9(5) COMP-3 VALUE 63.
+056800000000       LINKAGE SECTION.
+059200120210        01 CHAR20-DATA.
+059300120215            05  CHAR20      PIC X(20) OCCURS 4 TIMES.
+059301120606        01 LCHAR20-DATA.
+059302120606            05  LCHAR20      PIC X(20) OCCURS 4 TIMES.
+059303120606        01 UNICODE-DATA.
+059304120215            05  UNICODE20   PIC N(20) USAGE NATIONAL OCCURS 4 TIMES.
+059305120606        01 LUNICODE-DATA.
+059306120606            05  LUNICODE20   PIC N(20) USAGE NATIONAL OCCURS 4 TIMES.
+059307120606        01 BIN2SIGN-DATA.
+059308120215            05  BIN2SIGN    PIC S9(4) COMP-4 OCCURS 4 TIMES.
+059309120210        01 BIN4SIGN-DATA.
+059310120215            05  BIN4SIGN    PIC S9(9) COMP-4 OCCURS 4 TIMES.
+059311120210        01 BIN8SIGN-DATA.
+059312120215            05  BIN8SIGN    PIC S9(18) COMP-4 OCCURS 4 TIMES.
+059313120210        01 DEC112-DATA.
+059314120215            05  DEC112      PIC S9(9)V9(2) COMP-3 OCCURS 4 TIMES.
+059315120215        01 DEC15-DATA.
+059316120215            05  DEC15       PIC S9(15) COMP-3 OCCURS 4 TIMES.
+059317120210        01 NUM6-DATA.
+059318120215            05  NUM6        PIC S9(6) OCCURS 4 TIMES.
+059319120215        01 NUM103-DATA.
+059320120215            05  NUM103      PIC S9(7)V9(3) OCCURS 4 TIMES.
+059321120210        01 BIN2-DATA.
+059322120215            05  BIN2        PIC 9(4) COMP-4 OCCURS 4 TIMES.
+059323120210        01 BIN4-DATA.
+059324120215            05  BIN4        PIC 9(9) COMP-4 OCCURS 4 TIMES.
+059325120210        01 DATE1-DATA.
+059326120215           05 DATE1  OCCURS 4 TIMES.
+059327120612              10 DATE1-YYYY PIC 9(4) USAGE DISPLAY.
+059328120215              10 FILLER   PIC X(1).
+059329120612              10 DATE1-MM PIC 9(2) USAGE DISPLAY.
+059330120215              10 FILLER   PIC X(1).
+059331120612              10 DATE1-DD PIC 9(2) USAGE DISPLAY.
+059332120215        01 DATE2-DATA.
+059333120215           05 DATE2  OCCURS 4 TIMES.
+059334120612              10 DATE2-MM PIC 9(2) USAGE DISPLAY.
+059335120215              10 FILLER   PIC X(1).
+059336120612              10 DATE2-DD PIC 9(2) USAGE DISPLAY.
+059337120215              10 FILLER   PIC X(1).
+059338120612              10 DATE2-YYYY PIC 9(4) USAGE DISPLAY.
+059339120215        01 DATE3-DATA.
+059340120215           05 DATE3  OCCURS 4 TIMES.
+059341120612              10 DATE3-MM PIC 9(2) USAGE DISPLAY.
+059342120612              10 DATE3-DD PIC 9(2) USAGE DISPLAY.
+059343120612              10 DATE3-YYYY PIC 9(4) USAGE DISPLAY.
+059347120606        01 TIME1-DATA.
+059348120606           05  TIME1  OCCURS 4 TIMES.
+059349120612              10 TIME1-HH PIC 9(2) USAGE DISPLAY.
+059350120606              10 FILLER   PIC X(1).
+059351120612              10 TIME1-MM  PIC 9(2) USAGE DISPLAY.
+059352120606              10 FILLER   PIC X(1).
+059353120612              10 TIME1-SS PIC 9(2) USAGE DISPLAY.
+059354120606        01 TIME2-DATA.
+059355120606           05  TIME2  OCCURS 4 TIMES.
+059356120612              10 TIME2-SS PIC 9(2) USAGE DISPLAY.
+059357120606              10 FILLER   PIC X(1).
+059358120612              10 TIME2-MM PIC 9(2) USAGE DISPLAY.
+059359120606              10 FILLER   PIC X(1).
+059360120612              10 TIME2-HH PIC 9(2) USAGE DISPLAY.
+059361120606        01 TIME3-DATA.
+059362120606           05  TIME3  OCCURS 4 TIMES.
+059363120612              10 TIME3-SS PIC 9(2) USAGE DISPLAY.
+059364120612              10 TIME3-MM PIC 9(2) USAGE DISPLAY.
+059365120612              10 TIME3-HH PIC 9(2) USAGE DISPLAY.
+059366120606        01 TIMESTAMP1-DATA.
+059367120215           05  TIMESTAMP1 OCCURS 4 TIMES.
+059368120612              10 TS-YYYY  PIC 9(4) USAGE DISPLAY.
+059369120215              10 FILLER   PIC X(1).
+059370120612              10 TS-MM    PIC 9(2) USAGE DISPLAY.
+059371120215              10 FILLER   PIC X(1).
+059372120612              10 TS-DD    PIC 9(2) USAGE DISPLAY.
+059373120215              10 FILLER   PIC X(1).
+059374120612              10 TS-HH    PIC 9(2) USAGE DISPLAY.
+059375120215              10 FILLER   PIC X(1).
+059376120612              10 TS-MIN   PIC 9(2) USAGE DISPLAY.
+059377120215              10 FILLER   PIC X(1).
+059378120612              10 TS-SS   PIC 9(2) USAGE DISPLAY.
+059379120215              10 FILLER   PIC X(1).
+059380120215              10 TS-MS   PIC 9(6) USAGE DISPLAY.
+059381120215        01 FLOAT4-DATA.
+059382120215            05  FLOAT4      COMP-1 OCCURS 4 TIMES.
+059383120210        01 FLOAT8-DATA.
+059384120215            05  FLOAT8      COMP-2 OCCURS 4 TIMES.
+059385120215       01  VALIDCOUNT    PIC S9(9) COMP-4.
+059386120215
+059700000000       PROCEDURE DIVISION USING
+059800120606                   CHAR20-DATA
+059801120606                   LCHAR20-DATA
+059802120606                   UNICODE-DATA
+059803120606                   LUNICODE-DATA
+059804120606                   BIN2SIGN-DATA
+059805120210                   BIN4SIGN-DATA
+059806120210                   BIN8SIGN-DATA
+059807120210                   DEC112-DATA
+059808120215                   DEC15-DATA
+059809120210                   NUM6-DATA
+059810120215                   NUM103-DATA
+059811120210                   BIN2-DATA
+059812120210                   BIN4-DATA
+059813120210                   DATE1-DATA
+059814120215                   DATE2-DATA
+059815120215                   DATE3-DATA
+059816120606                   TIME1-DATA
+059817120606                   TIME2-DATA
+059818120606                   TIME3-DATA
+059819120606                   TIMESTAMP1-DATA
+059820120210                   FLOAT4-DATA
+059821120215                   FLOAT8-DATA
+059822120215                   VALIDCOUNT.
+059823120210
+059900000000      *-----------------------------------------------------------------
+060000000000      * MAIN PROCESS
+060100000000      *-----------------------------------------------------------------
+060200120203       MAIN-PARA SECTION.
+060201120207
+060202120210           PERFORM WITH TEST BEFORE VARYING CNTR FROM 1 BY 1 UNTIL
+060203120210               CNTR > 2
+060204120215                DISPLAY "CNTR = " CNTR
+060205120606                DISPLAY "CHAR20 = " CHAR20(CNTR)
+060206120606                DISPLAY "LCHAR20 = " LCHAR20(CNTR)
+060207120606                DISPLAY "UNICODE20 = " UNICODE20(CNTR)
+060208120606                DISPLAY "LUNICODE20 = " LUNICODE20(CNTR)
+060209120606                DISPLAY "BIN2SIGN = " BIN2SIGN(CNTR)
+060210120210                DISPLAY "BIN4SIGN = " BIN4SIGN(CNTR)
+060211120210                DISPLAY "BIN8SIGN = " BIN8SIGN(CNTR)
+060212120210                DISPLAY "DEC112 = " DEC112(CNTR)
+060213120215                DISPLAY "DEC15 = " DEC15(CNTR)
+060214120210                DISPLAY "NUM6 = " NUM6(CNTR)
+060215120215                DISPLAY "NUM103 = " NUM103(CNTR)
+060216120210                DISPLAY "BIN2 = " BIN2(CNTR)
+060217120210                DISPLAY "BIN4 = " BIN4(CNTR)
+060218120210                DISPLAY "DATE1 = " DATE1(CNTR)
+060219120215                DISPLAY "DATE2 = " DATE2(CNTR)
+060220120215                DISPLAY "DATE3 = " DATE3(CNTR)
+060221120606                DISPLAY "TIME1 = " TIME1(CNTR)
+060222120606                DISPLAY "TIME2 = " TIME2(CNTR)
+060223120606                DISPLAY "TIME3 = " TIME3(CNTR)
+060224120606                DISPLAY "TIMESTAMP1 = " TIMESTAMP1(CNTR)
+060225120210                DISPLAY "FLOAT4 = " FLOAT4(CNTR)
+060226120210                DISPLAY "FLOAT8 = " FLOAT8(CNTR)
+060227120207
+060228120215                DISPLAY "COMPUTE"
+060229120215                MOVE "YYYYY" TO CHAR20(CNTR)(5:5)
+060230120215                DISPLAY "CHAR20 = " CHAR20(CNTR)
+060231120606                MOVE "YYYYY" TO LCHAR20(CNTR)(5:5)
+060232120606                DISPLAY "LCHAR20 = " LCHAR20(CNTR)
+060233120606                MOVE  FUNCTION NATIONAL-OF("ZZZZZZZZZZ")
+060234120215                     TO UNICODE20(CNTR)(5:10)
+060235120606                DISPLAY "UNICODE20 = " UNICODE20(CNTR)
+060236120606                MOVE  FUNCTION NATIONAL-OF("ZZZZZZZZZZ")
+060237120606                     TO LUNICODE20(CNTR)(5:10)
+060238120606                DISPLAY "LUNICODE20 = " LUNICODE20(CNTR)
+060239120215                COMPUTE BIN2SIGN(CNTR) = BIN2SIGN(CNTR) + 98
+060240120215                DISPLAY "BIN2SIGN = " BIN2SIGN(CNTR)
+060241120215                COMPUTE BIN4SIGN(CNTR) = BIN4SIGN(CNTR) + 998
+060242120215                DISPLAY "BIN4SIGN = " BIN4SIGN(CNTR)
+060243120215                COMPUTE BIN8SIGN(CNTR) = BIN8SIGN(CNTR) + 9998
+060244120215                DISPLAY "BIN8SIGN = " BIN8SIGN(CNTR)
+060245120215                COMPUTE DEC112(CNTR) = DEC112(CNTR) + 998
+060246120215                DISPLAY "DEC112 = " DEC112(CNTR)
+060247120215                COMPUTE DEC15(CNTR) = DEC15(CNTR) + 998
+060248120215                DISPLAY "DEC15 = " DEC15(CNTR)
+060249120215                COMPUTE NUM6(CNTR) = NUM6(CNTR) + 9998
+060250120215                DISPLAY "NUM6 = " NUM6(CNTR)
+060251120215                COMPUTE NUM103(CNTR) = NUM103(CNTR) + 9998
+060252120215                DISPLAY "NUM103 = " NUM103(CNTR)
+060253120215                COMPUTE BIN2(CNTR) = BIN2(CNTR) + 98
+060254120215                DISPLAY "BIN2 = " BIN2(CNTR)
+060255120215                COMPUTE BIN4(CNTR) = BIN4(CNTR) + 998
+060256120215                DISPLAY "BIN4 = " BIN4(CNTR)
+060257120215
+060258120215      *    DATE1 FORMAT YYYY-MM-DD
+060259120215                COMPUTE DATE1-YYYY(CNTR) = DATE1-YYYY(CNTR) + 5
+060260120215                COMPUTE DATE1-MM(CNTR) = DATE1-MM(CNTR) + 5
+060261120215                COMPUTE DATE1-DD(CNTR) = DATE1-DD(CNTR) + 5
+060262120215                DISPLAY "DATE1 = " DATE1(CNTR)
+060263120215
+060264120215      *    DATE2 FORMAT MM/DD/YYYY
+060265120215                COMPUTE DATE2-YYYY(CNTR) = DATE2-YYYY(CNTR) + 5
+060266120215                COMPUTE DATE2-MM(CNTR) = DATE2-MM(CNTR) + 5
+060267120215                COMPUTE DATE2-DD(CNTR) = DATE2-DD(CNTR) + 5
+060268120215                DISPLAY "DATE2 = " DATE2(CNTR)
+060269120215
+060270120215      *    DATE3 FORMAT MMDDYYYY
+060271120215                COMPUTE DATE3-YYYY(CNTR) = DATE3-YYYY(CNTR) + 5
+060272120215                COMPUTE DATE3-MM(CNTR) = DATE3-MM(CNTR) + 5
+060273120215                COMPUTE DATE3-DD(CNTR) = DATE3-DD(CNTR) + 5
+060274120215                DISPLAY "DATE3 = " DATE3(CNTR)
+060275120215
+060276120606      *    TIME1 FORMAT
+060277120606                COMPUTE TIME1-HH(CNTR) = TIME1-HH(CNTR) + 5
+060278120606                COMPUTE TIME1-MM(CNTR) = TIME1-MM(CNTR) + 5
+060279120606                COMPUTE TIME1-SS(CNTR) = TIME1-SS(CNTR) + 5
+060280120606                DISPLAY "TIME1 = " TIME1(CNTR)
+060281120606
+060282120606      *    TIME2 FORMAT
+060283120606                COMPUTE TIME2-HH(CNTR) = TIME2-HH(CNTR) + 5
+060284120606                COMPUTE TIME2-MM(CNTR) = TIME2-MM(CNTR) + 5
+060285120612                COMPUTE TIME2-SS(CNTR) = TIME2-SS(CNTR) + 5
+060286120606                DISPLAY "TIME2 = " TIME2(CNTR)
+060287120606
+060288120606      *    TIME3 FORMAT
+060289120606                COMPUTE TIME3-HH(CNTR) = TIME3-HH(CNTR) + 5
+060290120606                COMPUTE TIME3-MM(CNTR) = TIME3-MM(CNTR) + 5
+060291120606                COMPUTE TIME3-SS(CNTR) = TIME3-SS(CNTR) + 5
+060292120606                DISPLAY "TIME3 = " TIME3(CNTR)
+060293120606
+060294120606      *    TIMESTAMP1 FORMAT = YYYY-MM-DD-HH.MM.SS
+060295120215                COMPUTE TS-YYYY(CNTR) = TS-YYYY(CNTR) + 5
+060296120215                COMPUTE TS-MM(CNTR) = TS-MM(CNTR) + 5
+060297120215                COMPUTE TS-DD(CNTR) = TS-DD(CNTR) + 5
+060298120215                COMPUTE TS-HH(CNTR) = TS-HH(CNTR) + 5
+060299120215                COMPUTE TS-MIN(CNTR) = TS-MIN(CNTR) + 5
+060300120215                COMPUTE TS-SS(CNTR) = TS-SS(CNTR) + 5
+060301120215                DISPLAY "TIMESTAMP1 = " TIMESTAMP1(CNTR)
+060302120215                COMPUTE FLOAT4(CNTR) = FLOAT4(CNTR) + 9.9e-1
+060303120215                DISPLAY "FLOAT4 = " FLOAT4(CNTR)
+060304120215                COMPUTE FLOAT8(CNTR) = FLOAT8(CNTR) + 9.9e-1
+060305120215                DISPLAY "FLOAT8 = " FLOAT8(CNTR)
+060306120215
+060307120215      *          DISPLAY "TIME1 = " TIME1(CNTR)
+060308120215           END-PERFORM
+060309120215           MOVE 2 TO VALIDCOUNT;
+060310120215           PERFORM PARA-1.
+060311120203
+060400000000           GOBACK.
+060500000000
+062100120203       PARA-1 SECTION.
+063100000000           CONTINUE.
+063200120203       PARA-1-X.
+063300000000           EXIT.
+063400000000
+104700000000
+104800000000      *-----------------------------------------------------------------
+104900120210      * END OF PROGRAM EDTTSTPA
+105000000000      *-----------------------------------------------------------------
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QVGNCBLS/EDTTSTR.CBLLE b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QVGNCBLS/EDTTSTR.CBLLE
new file mode 100644
index 0000000..fb5b046
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QVGNCBLS/EDTTSTR.CBLLE
@@ -0,0 +1,224 @@
+000100000000      *-----------------------------------------------------------------
+000200120203      * Program to test Data types (primitives) from EGL iSeries access
+000300000000      *-----------------------------------------------------------------
+000400120203
+000800000000       IDENTIFICATION DIVISION.
+000900120210       PROGRAM-ID.    EDTTSTR.
+001000000000       AUTHOR.                 NONE
+001100000000           INSTALLATION.       NONE
+001200120203           DATE WRITTEN.       2/5/2012.
+001300000000           DATE COMPILED.
+001400000000       ENVIRONMENT DIVISION.
+001500000000       CONFIGURATION SECTION.
+001600000000       SPECIAL-NAMES.
+006100120207       INPUT-OUTPUT SECTION.
+006101120207       FILE-CONTROL.
+006300000000       DATA DIVISION.
+006400000000
+006500000000       WORKING-STORAGE SECTION.
+024600000000       01  CL-CMD.
+024700000000           05  CL-CMD-DATA.
+024800000000              10  CL-CMD-OVRDBF PIC X(7) VALUE "OVRDBF ".
+024900000000              10  CL-CMD-OLDFILE PIC X(11).
+025000000000              10  CL-CMD-NEWFILE PIC X(33).
+025100000000              10  CL-CMD-SECURE  PIC X(12) VALUE "SECURE(*YES)".
+025200000000           05  CL-CMD-LENGTH PIC 9(10)V9(5) COMP-3 VALUE 63.
+056800000000       LINKAGE SECTION.
+059200120203
+059201120210       01 TYPEREC.
+059300120606            05  CHAR20      PIC X(20).
+059301120606            05  LCHAR20     PIC X(20).
+059302120606            05  UNICODE20   PIC N(20) USAGE NATIONAL.
+059303120606            05  LUNICODE20  PIC N(20) USAGE NATIONAL.
+059304120606            05  BIN2SIGN    PIC S9(4) COMP-4.
+059305120210            05  BIN4SIGN    PIC S9(9) COMP-4.
+059306120210            05  BIN8SIGN    PIC S9(18) COMP-4.
+059307120214            05  DEC112      PIC S9(9)V9(2) COMP-3.
+059308120214            05  DEC15       PIC S9(15) COMP-3.
+059309120214            05  NUM6        PIC S9(6).
+059310120214            05  NUM103      PIC S9(7)V9(3).
+059311120214            05  BIN2        PIC 9(4) COMP-4.
+059312120214            05  BIN4        PIC 9(9) COMP-4.
+059313120214            05  DATE1.
+059314120612                10 DATE1-YYYY PIC 9(4) USAGE DISPLAY.
+059315120214                10 FILLER   PIC X(1).
+059316120612                10 DATE1-MM PIC 9(2) USAGE DISPLAY.
+059317120214                10 FILLER   PIC X(1).
+059318120612                10 DATE1-DD PIC 9(2) USAGE DISPLAY.
+059319120214            05  DATE2.
+059320120612                10 DATE2-MM PIC 9(2) USAGE DISPLAY.
+059321120214                10 FILLER   PIC X(1).
+059322120612                10 DATE2-DD PIC 9(2) USAGE DISPLAY.
+059323120214                10 FILLER   PIC X(1).
+059324120612                10 DATE2-YYYY PIC 9(4) USAGE DISPLAY.
+059325120214            05  DATE3.
+059326120612                10 DATE3-MM PIC 9(2) USAGE DISPLAY.
+059327120612                10 DATE3-DD PIC 9(2) USAGE DISPLAY.
+059328120612                10 DATE3-YYYY PIC 9(4) USAGE DISPLAY.
+059329120606            05  TIME1.
+059330120612                10 TIME1-HH PIC 9(2) USAGE DISPLAY.
+059331120606                10 FILLER   PIC X(1).
+059332120612                10 TIME1-MM  PIC 9(2) USAGE DISPLAY.
+059333120606                10 FILLER   PIC X(1).
+059334120612                10 TIME1-SS PIC 9(2) USAGE DISPLAY.
+059335120606            05  TIME2.
+059336120612                10 TIME2-SS PIC 9(2) USAGE DISPLAY.
+059337120606                10 FILLER   PIC X(1).
+059338120612                10 TIME2-MM PIC 9(2) USAGE DISPLAY.
+059339120606                10 FILLER   PIC X(1).
+059340120612                10 TIME2-HH PIC 9(2) USAGE DISPLAY.
+059341120606            05  TIME3.
+059342120612                10 TIME3-SS PIC 9(2) USAGE DISPLAY.
+059343120612                10 TIME3-MM PIC 9(2) USAGE DISPLAY.
+059344120612                10 TIME3-HH PIC 9(2) USAGE DISPLAY.
+059345120606            05  TIMESTAMP1.
+059346120612                10 TS-YYYY  PIC 9(4) USAGE DISPLAY.
+059347120214                10 FILLER   PIC X(1).
+059348120612                10 TS-MM    PIC 9(2) USAGE DISPLAY.
+059349120214                10 FILLER   PIC X(1).
+059350120612                10 TS-DD    PIC 9(2) USAGE DISPLAY.
+059351120214                10 FILLER   PIC X(1).
+059352120612                10 TS-HH    PIC 9(2) USAGE DISPLAY.
+059353120214                10 FILLER   PIC X(1).
+059354120612                10 TS-MIN   PIC 9(2) USAGE DISPLAY.
+059355120214                10 FILLER   PIC X(1).
+059356120612                10 TS-SS    PIC 9(2) USAGE DISPLAY.
+059357120215                10 FILLER   PIC X(1).
+059358120612                10 TS-MS    PIC 9(6) USAGE DISPLAY.
+059359120215            05  FLOAT4      COMP-1.
+059360120210            05  FLOAT8      COMP-2.
+059361120210
+059700120210       PROCEDURE DIVISION USING TYPEREC.
+059800120210      *            CHAR20
+059801120210      *            BIN2SIGN
+059802120210      *            BIN4SIGN
+059803120210      *            BIN8SIGN
+059804120210      *            DEC112
+059805120210      *            NUM6
+059806120210      *            BIN2
+059807120210      *            BIN4
+059808120210      *            DATE1
+059809120210      *            TIME1
+059810120210      *            TIMESTAMP1
+059811120210      *            FLOAT4
+059812120210      *            FLOAT8.
+059813120210
+059900000000      *-----------------------------------------------------------------
+060000000000      * MAIN PROCESS
+060100000000      *-----------------------------------------------------------------
+060200120203       MAIN-PARA SECTION.
+060201120210           DISPLAY "TYPEREC = " TYPEREC
+060202120207           DISPLAY "CHAR20 = " CHAR20
+060203120606           DISPLAY "LCHAR20 = " LCHAR20
+060204120606           DISPLAY "UNICODE20 = " UNICODE20
+060205120606           DISPLAY "LUNICODE20 = " LUNICODE20
+060206120606           DISPLAY "BIN2SIGN = " BIN2SIGN
+060207120207           DISPLAY "BIN4SIGN = " BIN4SIGN
+060208120207           DISPLAY "BIN8SIGN = " BIN8SIGN
+060209120214           DISPLAY "DEC112 = " DEC112
+060210120214           DISPLAY "DEC15 = " DEC15
+060211120214           DISPLAY "NUM6 = " NUM6
+060212120214           DISPLAY "NUM103 = " NUM103
+060213120214           DISPLAY "BIN2 = " BIN2
+060214120207           DISPLAY "BIN4 = " BIN4
+060215120214           DISPLAY "DATE1 = " DATE1
+060216120214           DISPLAY "DATE2 = " DATE2
+060217120214           DISPLAY "DATE3 = " DATE3
+060218120606           DISPLAY "TIME1 = " TIME1
+060219120606           DISPLAY "TIME2 = " TIME2
+060220120606           DISPLAY "TIME3 = " TIME3
+060221120606           DISPLAY "TIMESTAMP1 = " TIMESTAMP1
+060222120210           DISPLAY "FLOAT4 = " FLOAT4
+060223120210           DISPLAY "FLOAT8 = " FLOAT8
+060224120207
+060225120215           MOVE "YYYYY" TO CHAR20(5:5)
+060226120606           MOVE "YYYYY" TO LCHAR20(5:5)
+060227120606           MOVE  FUNCTION NATIONAL-OF("ZZZZZZZZZZ")
+060228120215               TO UNICODE20(5:10)
+060229120606           MOVE  FUNCTION NATIONAL-OF("ZZZZZZZZZZ")
+060230120606               TO LUNICODE20(5:10)
+060231120606           COMPUTE BIN2SIGN = BIN2SIGN + 98
+060249120207           COMPUTE BIN4SIGN = BIN4SIGN + 998
+060250120207           COMPUTE BIN8SIGN = BIN8SIGN + 9998
+060251120207           COMPUTE DEC112 = DEC112 + 998
+060252120214           COMPUTE DEC15 = DEC15 + 998
+060253120214           COMPUTE NUM6 = NUM6 + 9998
+060254120214           COMPUTE NUM103 = NUM103 + 9998
+060255120207           COMPUTE BIN2 = BIN2 + 98
+060256120207           COMPUTE BIN4 = BIN4 + 998
+060257120214      *    DATE1 FORMAT YYYY-MM-DD
+060258120214           COMPUTE DATE1-YYYY = DATE1-YYYY + 5
+060259120214           COMPUTE DATE1-MM = DATE1-MM + 5
+060260120214           COMPUTE DATE1-DD = DATE1-DD + 5
+060261120214
+060262120214      *    DATE2 FORMAT MM/DD/YYYY
+060263120214           COMPUTE DATE2-YYYY = DATE2-YYYY + 5
+060264120214           COMPUTE DATE2-MM = DATE2-MM + 5
+060265120214           COMPUTE DATE2-DD = DATE2-DD + 5
+060266120214
+060267120214      *    DATE3 FORMAT MMDDYYYY
+060268120214           COMPUTE DATE3-YYYY = DATE3-YYYY + 5
+060269120214           COMPUTE DATE3-MM = DATE3-MM + 5
+060270120214           COMPUTE DATE3-DD = DATE3-DD + 5
+060271120214
+060272120606      *    TIME1 FORMAT YYYY-MM-DD
+060273120606           COMPUTE TIME1-HH = TIME1-HH + 5
+060274120606           COMPUTE TIME1-MM = TIME1-MM + 5
+060275120606           COMPUTE TIME1-SS = TIME1-SS + 5
+060276120606
+060277120606      *    TIME2 FORMAT MM/DD/YYYY
+060278120606           COMPUTE TIME2-HH = TIME2-HH + 5
+060279120606           COMPUTE TIME2-MM = TIME2-MM + 5
+060280120612           COMPUTE TIME2-SS = TIME2-SS + 5
+060281120606
+060282120606      *    TIME3 FORMAT MMDDYYYY
+060283120606           COMPUTE TIME3-HH = TIME3-HH + 5
+060284120606           COMPUTE TIME3-MM = TIME3-MM + 5
+060285120606           COMPUTE TIME3-SS = TIME3-SS + 5
+060286120606
+060287120606      *    TIMESTAMP1 FORMAT = YYYY-MM-DD-HH.MM.SS
+060288120214           COMPUTE TS-YYYY = TS-YYYY + 5
+060289120214           COMPUTE TS-MM = TS-MM + 5
+060290120214           COMPUTE TS-DD = TS-DD + 5
+060291120214           COMPUTE TS-HH = TS-HH + 5
+060292120214           COMPUTE TS-MIN = TS-MIN + 5
+060293120214           COMPUTE TS-SS = TS-SS + 5
+060294120214           COMPUTE FLOAT4 = FLOAT4 + 9.9e-1
+060295120210           COMPUTE FLOAT8 = FLOAT8 + 9.9e-1
+060296120210
+060297120215           DISPLAY "AFTER COMPUTE"
+060298120606           DISPLAY "CHAR20 = " CHAR20
+060299120606           DISPLAY "LCHAR20 = " LCHAR20
+060300120606           DISPLAY "UNICODE20 = " UNICODE20
+060301120606           DISPLAY "LUNICODE20 = " LUNICODE20
+060302120606           DISPLAY "BIN2SIGN = " BIN2SIGN
+060303120215           DISPLAY "BIN4SIGN = " BIN4SIGN
+060304120215           DISPLAY "BIN8SIGN = " BIN8SIGN
+060305120215           DISPLAY "DEC112 = " DEC112
+060306120215           DISPLAY "DEC15 = " DEC15
+060307120215           DISPLAY "NUM6 = " NUM6
+060308120215           DISPLAY "NUM103 = " NUM103
+060309120215           DISPLAY "BIN2 = " BIN2
+060310120215           DISPLAY "BIN4 = " BIN4
+060311120215           DISPLAY "DATE1 = " DATE1
+060312120215           DISPLAY "DATE2 = " DATE2
+060313120215           DISPLAY "DATE3 = " DATE3
+060314120606           DISPLAY "TIME1 = " TIME1
+060315120606           DISPLAY "TIME2 = " TIME2
+060316120606           DISPLAY "TIME3 = " TIME3
+060317120606           DISPLAY "TIMESTAMP1 = " TIMESTAMP1
+060318120215           DISPLAY "FLOAT4 = " FLOAT4
+060319120215           DISPLAY "FLOAT8 = " FLOAT8
+060320120215           PERFORM PARA-1.
+060321120203
+060400000000           GOBACK.
+060500000000
+062100120203       PARA-1 SECTION.
+063100000000           CONTINUE.
+063200120203       PARA-1-X.
+063300000000           EXIT.
+063400000000
+104700000000
+104800000000      *-----------------------------------------------------------------
+104900120210      * END OF PROGRAM EDTTSTR
+105000000000      *-----------------------------------------------------------------
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QVGNCBLS/EDTTSTRA.CBLLE b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QVGNCBLS/EDTTSTRA.CBLLE
new file mode 100644
index 0000000..a63b1fd
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/AS4069.rtp.raleigh.ibm.com_TSTSRVPGM/QVGNCBLS/EDTTSTRA.CBLLE
@@ -0,0 +1,645 @@
+000100000000      *-----------------------------------------------------------------
+000200120203      * Program to test Data types (primitives) from EGL iSeries access
+000300000000      *-----------------------------------------------------------------
+000400120203
+000800000000       IDENTIFICATION DIVISION.
+000900120213       PROGRAM-ID.    EDTTSTRA.
+001000000000       AUTHOR.                 NONE
+001100000000           INSTALLATION.       NONE
+001200120203           DATE WRITTEN.       2/5/2012.
+001300000000           DATE COMPILED.
+001400000000       ENVIRONMENT DIVISION.
+001500000000       CONFIGURATION SECTION.
+001600000000       SPECIAL-NAMES.
+006100120207       INPUT-OUTPUT SECTION.
+006101120207       FILE-CONTROL.
+006300000000       DATA DIVISION.
+006400000000
+006500000000       WORKING-STORAGE SECTION.
+006501120216       01 CNTR1 PIC 9(1) COMP-4.
+006502120216       01 CNTR2 PIC 9(1) COMP-4.
+006503120216       01  CL-CMD.
+024700000000           05  CL-CMD-DATA.
+024800000000              10  CL-CMD-OVRDBF PIC X(7) VALUE "OVRDBF ".
+024900000000              10  CL-CMD-OLDFILE PIC X(11).
+025000000000              10  CL-CMD-NEWFILE PIC X(33).
+025100000000              10  CL-CMD-SECURE  PIC X(12) VALUE "SECURE(*YES)".
+025200000000           05  CL-CMD-LENGTH PIC 9(10)V9(5) COMP-3 VALUE 63.
+056800000000       LINKAGE SECTION.
+059200120203
+059201120213       01 TYPERECS.
+059202120216          03 RECORD11 OCCURS 5 TIMES.
+059203120216               04 RECORD1.
+059204120606                   05  CHAR20      PIC X(20).
+059205120606                   05  LCHAR20     PIC X(20).
+059206120606                   05  UNICODE20   PIC N(20) USAGE NATIONAL.
+059207120606                   05  LUNICODE20  PIC N(20) USAGE NATIONAL.
+059208120606                   05  BIN2SIGN    PIC S9(4) COMP-4.
+059209120216                   05  BIN4SIGN    PIC S9(9) COMP-4.
+059210120216                   05  BIN8SIGN    PIC S9(18) COMP-4.
+059211120216                   05  DEC112      PIC S9(9)V9(2) COMP-3.
+059212120216                   05  DEC15       PIC S9(15) COMP-3.
+059213120216                   05  NUM6        PIC S9(6).
+059214120216                   05  NUM103      PIC S9(7)V9(3).
+059215120216                   05  BIN2        PIC 9(4) COMP-4.
+059216120216                   05  BIN4        PIC 9(9) COMP-4.
+059217120216                   05  DATE1.
+059218120612                       10 DATE1-YYYY PIC 9(4) USAGE DISPLAY.
+059219120216                       10 FILLER   PIC X(1).
+059220120612                       10 DATE1-MM PIC 9(2) USAGE DISPLAY.
+059221120216                       10 FILLER   PIC X(1).
+059222120612                       10 DATE1-DD PIC 9(2) USAGE DISPLAY.
+059223120216                   05  DATE2.
+059224120612                       10 DATE2-MM PIC 9(2) USAGE DISPLAY.
+059225120216                       10 FILLER   PIC X(1).
+059226120612                       10 DATE2-DD PIC 9(2) USAGE DISPLAY.
+059227120216                       10 FILLER   PIC X(1).
+059228120612                       10 DATE2-YYYY PIC 9(4) USAGE DISPLAY.
+059229120216                   05  DATE3.
+059230120612                       10 DATE3-MM PIC 9(2) USAGE DISPLAY.
+059231120612                       10 DATE3-DD PIC 9(2) USAGE DISPLAY.
+059232120612                       10 DATE3-YYYY PIC 9(4) USAGE DISPLAY.
+059233120612                   05  TIME1.
+059234120612                       10 TIME1-HH PIC 9(2) USAGE DISPLAY.
+059235120612                       10 FILLER   PIC X(1).
+059236120612                       10 TIME1-MM PIC 9(2) USAGE DISPLAY.
+059237120612                       10 FILLER   PIC X(1).
+059238120612                       10 TIME1-SS PIC 9(2) USAGE DISPLAY.
+059239120612                   05  TIME2.
+059240120612                       10 TIME2-HH PIC 9(2) USAGE DISPLAY.
+059241120612                       10 FILLER   PIC X(1).
+059242120612                       10 TIME2-MM PIC 9(2) USAGE DISPLAY.
+059243120612                       10 FILLER   PIC X(1).
+059244120612                       10 TIME2-SS PIC 9(2) USAGE DISPLAY.
+059245120612                   05  TIME3.
+059246120612                       10 TIME3-HH PIC 9(2) USAGE DISPLAY.
+059247120612                       10 TIME3-MM PIC 9(2) USAGE DISPLAY.
+059248120612                       10 TIME3-SS PIC 9(2) USAGE DISPLAY.
+059249120612                   05  TIMESTAMP1.
+059250120612                       10 TS-YYYY  PIC 9(4) USAGE DISPLAY.
+059251120216                       10 FILLER   PIC X(1).
+059252120612                       10 TS-MM    PIC 9(2) USAGE DISPLAY.
+059253120216                       10 FILLER   PIC X(1).
+059254120612                       10 TS-DD    PIC 9(2) USAGE DISPLAY.
+059255120216                       10 FILLER   PIC X(1).
+059256120612                       10 TS-HH    PIC 9(2) USAGE DISPLAY.
+059257120216                       10 FILLER   PIC X(1).
+059258120612                       10 TS-MIN   PIC 9(2) USAGE DISPLAY.
+059259120216                       10 FILLER   PIC X(1).
+059260120612                       10 TS-SS    PIC 9(2) USAGE DISPLAY.
+059261120216                       10 FILLER   PIC X(1).
+059262120216                       10 TS-MS    PIC 9(6) USAGE DISPLAY.
+059263120216                   05  FLOAT4      COMP-1.
+059264120216                   05  FLOAT8      COMP-2.
+059265120606               04 CHAR20-DATA.
+059266120612                   05  CHAR20A      PIC X(20) OCCURS 4 TIMES.
+059267120606               04 LCHAR20-DATA.
+059268120612                   05  LCHAR20A      PIC X(20) OCCURS 4 TIMES.
+059269120606               04 UNICODE-DATA.
+059270120612                   05  UNICODE20A   PIC N(20) USAGE NATIONAL
+059271120606                           OCCURS 4 TIMES.
+059272120606               04 LUNICODE-DATA.
+059273120612                   05  LUNICODE20A   PIC N(20) USAGE NATIONAL
+059274120606                           OCCURS 4 TIMES.
+059275120216               04 BIN2SIGN-DATA.
+059276120216                   05  BIN2SIGNA    PIC S9(4) COMP-4 OCCURS 4 TIMES.
+059277120216               04 BIN4SIGN-DATA.
+059278120216                   05  BIN4SIGNA    PIC S9(9) COMP-4 OCCURS 4 TIMES.
+059279120216               04 BIN8SIGN-DATA.
+059280120216                   05  BIN8SIGNA    PIC S9(18) COMP-4 OCCURS 4 TIMES.
+059281120216               04 DEC112-DATA.
+059282120216                   05  DEC112A      PIC S9(9)V9(2) COMP-3
+059283120216                                       OCCURS 4 TIMES.
+059284120216               04 DEC15-DATA.
+059285120216                   05  DEC15A       PIC S9(15) COMP-3 OCCURS 4 TIMES.
+059286120216               04 NUM6-DATA.
+059287120216                   05  NUM6A        PIC S9(6) OCCURS 4 TIMES.
+059288120216               04 NUM103-DATA.
+059289120216                   05  NUM103A      PIC S9(7)V9(3) OCCURS 4 TIMES.
+059290120216               04 BIN2-DATA.
+059291120216                   05  BIN2A        PIC 9(4) COMP-4 OCCURS 4 TIMES.
+059292120216               04 BIN4-DATA.
+059293120216                   05  BIN4A        PIC 9(9) COMP-4 OCCURS 4 TIMES.
+059294120216               04 DATE1-DATA.
+059295120216                   05 DATE1A  OCCURS 4 TIMES.
+059296120612                       10 DATE1-YA PIC 9(4) USAGE DISPLAY.
+059297120216                       10 FILLER   PIC X(1).
+059298120612                       10 DATE1-MA PIC 9(2) USAGE DISPLAY.
+059299120216                       10 FILLER   PIC X(1).
+059300120612                       10 DATE1-DA PIC 9(2) USAGE DISPLAY.
+059301120216               04 DATE2-DATA.
+059302120216                   05 DATE2A  OCCURS 4 TIMES.
+059303120612                       10 DATE2-MA PIC 9(2) USAGE DISPLAY.
+059304120216                       10 FILLER   PIC X(1).
+059305120612                       10 DATE2-DA PIC 9(2) USAGE DISPLAY.
+059306120216                       10 FILLER   PIC X(1).
+059307120612                       10 DATE2-YA PIC 9(4) USAGE DISPLAY.
+059308120216               04 DATE3-DATA.
+059309120216                   05 DATE3A  OCCURS 4 TIMES.
+059310120612                       10 DATE3-MA PIC 9(2) USAGE DISPLAY.
+059311120612                       10 DATE3-DA PIC 9(2) USAGE DISPLAY.
+059312120612                       10 DATE3-YA PIC 9(4) USAGE DISPLAY.
+059313120606               04 TIME1-DATA.
+059314120612                   05  TIME1A  OCCURS 4 TIMES.
+059315120612                       10 TIME1-HA PIC 9(2) USAGE DISPLAY.
+059316120606                       10 FILLER   PIC X(1).
+059317120612                       10 TIME1-MA  PIC 9(2) USAGE DISPLAY.
+059318120606                       10 FILLER   PIC X(1).
+059319120612                       10 TIME1-SA PIC 9(2) USAGE DISPLAY.
+059320120606               04 TIME2-DATA.
+059321120612                   05  TIME2A  OCCURS 4 TIMES.
+059322120612                       10 TIME2-HA PIC 9(2) USAGE DISPLAY.
+059323120606                       10 FILLER   PIC X(1).
+059324120612                       10 TIME2-MA PIC 9(2) USAGE DISPLAY.
+059325120606                       10 FILLER   PIC X(1).
+059326120612                       10 TIME2-SA PIC 9(2) USAGE DISPLAY.
+059327120606               04 TIME3-DATA.
+059328120612                   05  TIME3A  OCCURS 4 TIMES.
+059329120612                       10 TIME3-HA PIC 9(2) USAGE DISPLAY.
+059330120612                       10 TIME3-MA PIC 9(2) USAGE DISPLAY.
+059331120612                       10 TIME3-SA PIC 9(2) USAGE DISPLAY.
+059332120606               04 TIMESTAMP1-DATA.
+059333120216                   05  TIMESTAMP1A OCCURS 4 TIMES.
+059334120612                       10 TS-YA  PIC 9(4) USAGE DISPLAY.
+059335120216                       10 FILLER   PIC X(1).
+059336120612                       10 TS-MA    PIC 9(2) USAGE DISPLAY.
+059337120216                       10 FILLER   PIC X(1).
+059338120612                       10 TS-DA    PIC 9(2) USAGE DISPLAY.
+059339120216                       10 FILLER   PIC X(1).
+059340120612                       10 TS-HA    PIC 9(2) USAGE DISPLAY.
+059341120216                       10 FILLER   PIC X(1).
+059342120612                       10 TS-MIA   PIC 9(2) USAGE DISPLAY.
+059343120216                       10 FILLER   PIC X(1).
+059344120612                       10 TS-SA   PIC 9(2) USAGE DISPLAY.
+059345120216                       10 FILLER   PIC X(1).
+059346120216                       10 TS-MSA   PIC 9(6) USAGE DISPLAY.
+059347120216               04 FLOAT4-DATA.
+059348120216                   05  FLOAT4A      COMP-1 OCCURS 4 TIMES.
+059349120216               04 FLOAT8-DATA.
+059350120216                   05  FLOAT8A      COMP-2 OCCURS 4 TIMES.
+059351120216               04  RECA.
+059352120216                   05  RECORD1      OCCURS 4 TIMES.
+059353120216                       07  CHAR20R      PIC X(20).
+059354120606                       07  LCHAR20R      PIC X(20).
+059355120606                       07  UNICODE20R   PIC N(20) USAGE NATIONAL.
+059356120606                       07  LUNICODE20R   PIC N(20) USAGE NATIONAL.
+059357120606                       07  BIN2SIGNR    PIC S9(4) COMP-4.
+059358120216                       07  BIN4SIGNR    PIC S9(9) COMP-4.
+059359120216                       07  BIN8SIGNR    PIC S9(18) COMP-4.
+059360120216                       07  DEC112R      PIC S9(9)V9(2) COMP-3.
+059361120216                       07  DEC15R       PIC S9(15) COMP-3.
+059362120216                       07  NUM6R        PIC S9(6).
+059363120216                       07  NUM103R      PIC S9(7)V9(3).
+059364120216                       07  BIN2R        PIC 9(4) COMP-4.
+059365120216                       07  BIN4R        PIC 9(9) COMP-4.
+059366120216                       07  DATE1R.
+059367120612                           10 DATE1-YR PIC 9(4) USAGE DISPLAY.
+059368120216                           10 FILLER   PIC X(1).
+059369120612                           10 DATE1-MR PIC 9(2) USAGE DISPLAY.
+059370120216                           10 FILLER   PIC X(1).
+059371120612                           10 DATE1-DR PIC 9(2) USAGE DISPLAY.
+059372120216                       07  DATE2R.
+059373120612                           10 DATE2-MR PIC 9(2) USAGE DISPLAY.
+059374120216                           10 FILLER   PIC X(1).
+059375120612                           10 DATE2-DR PIC 9(2) USAGE DISPLAY.
+059376120216                           10 FILLER   PIC X(1).
+059377120612                           10 DATE2-YR PIC 9(4) USAGE DISPLAY.
+059378120216                       07  DATE3R.
+059379120612                           10 DATE3-MR PIC 9(2) USAGE DISPLAY.
+059380120612                           10 DATE3-DR PIC 9(2) USAGE DISPLAY.
+059381120612                           10 DATE3-YR PIC 9(4) USAGE DISPLAY.
+059382120606                       07  TIME1R.
+059383120612                           10 TIME1-HR PIC 9(2) USAGE DISPLAY.
+059384120606                           10 FILLER   PIC X(1).
+059385120612                           10 TIME1-MR  PIC 9(2) USAGE DISPLAY.
+059386120606                           10 FILLER   PIC X(1).
+059387120612                           10 TIME1-SR PIC 9(2) USAGE DISPLAY.
+059388120606                       07  TIME2R.
+059389120612                           10 TIME2-HR PIC 9(2) USAGE DISPLAY.
+059390120606                           10 FILLER   PIC X(1).
+059391120612                           10 TIME2-MR PIC 9(2) USAGE DISPLAY.
+059392120606                           10 FILLER   PIC X(1).
+059393120612                           10 TIME2-SR PIC 9(2) USAGE DISPLAY.
+059394120606                       07  TIME3R.
+059395120612                           10 TIME3-HR PIC 9(2) USAGE DISPLAY.
+059396120612                           10 TIME3-MR PIC 9(2) USAGE DISPLAY.
+059397120612                           10 TIME3-SR PIC 9(2) USAGE DISPLAY.
+059398120606                       07  TIMESTAMP1R.
+059399120612                           10 TS-YR  PIC 9(4) USAGE DISPLAY.
+059400120216                           10 FILLER   PIC X(1).
+059401120612                           10 TS-MR    PIC 9(2) USAGE DISPLAY.
+059402120216                           10 FILLER   PIC X(1).
+059403120612                           10 TS-DR    PIC 9(2) USAGE DISPLAY.
+059404120216                           10 FILLER   PIC X(1).
+059405120612                           10 TS-HR    PIC 9(2) USAGE DISPLAY.
+059406120216                           10 FILLER   PIC X(1).
+059407120612                           10 TS-MIR   PIC 9(2) USAGE DISPLAY.
+059408120216                           10 FILLER   PIC X(1).
+059409120612                           10 TS-SR    PIC 9(2) USAGE DISPLAY.
+059410120216                           10 FILLER   PIC X(1).
+059411120216                           10 TS-MSR    PIC 9(6) USAGE DISPLAY.
+059412120216                       07  FLOAT4R      COMP-1.
+059413120216                       07  FLOAT8R      COMP-2.
+059414120216               04  VALIDCOUNT    PIC S9(9) COMP-4.
+059415120216       01 VALIDCOUNTP   PIC S9(9) COMP-4.
+059416120216
+059417120210
+059700120216       PROCEDURE DIVISION USING TYPERECS VALIDCOUNTP.
+059800120210      *            CHAR20
+059801120210      *            BIN2SIGN
+059802120210      *            BIN4SIGN
+059803120210      *            BIN8SIGN
+059804120210      *            DEC112
+059805120210      *            NUM6
+059806120210      *            BIN2
+059807120210      *            BIN4
+059808120210      *            DATE1
+059809120210      *            TIME1
+059810120210      *            TIMESTAMP1
+059811120210      *            FLOAT4
+059812120210      *            FLOAT8.
+059813120210
+059900000000      *-----------------------------------------------------------------
+060000000000      * MAIN PROCESS
+060100000000      *-----------------------------------------------------------------
+060200120203       MAIN-PARA SECTION.
+060201120216           PERFORM WITH TEST BEFORE VARYING CNTR1 FROM 1 BY 1 UNTIL
+060202120216               CNTR1 > 2
+060203120606                DISPLAY "CHAR20." CNTR1 " = " CHAR20(CNTR1)
+060204120606                DISPLAY "LCHAR20." CNTR1 " = " LCHAR20(CNTR1)
+060205120606                DISPLAY "UNICODE20." CNTR1 " = " UNICODE20(CNTR1)
+060206120606                DISPLAY "LUNICODE20." CNTR1 " = " LUNICODE20(CNTR1)
+060207120606                DISPLAY "BIN2SIGN." CNTR1 " = " BIN2SIGN(CNTR1)
+060208120216                DISPLAY "BIN4SIGN." CNTR1 " = " BIN4SIGN(CNTR1)
+060209120216                DISPLAY "BIN8SIGN." CNTR1 " = " BIN8SIGN(CNTR1)
+060210120216                DISPLAY "DEC112." CNTR1 " = " DEC112(CNTR1)
+060211120216                DISPLAY "DEC15." CNTR1 " = " DEC15(CNTR1)
+060212120216                DISPLAY "NUM6." CNTR1 " = " NUM6(CNTR1)
+060213120216                DISPLAY "NUM103." CNTR1 " = " NUM103(CNTR1)
+060214120216                DISPLAY "BIN2." CNTR1 " = " BIN2(CNTR1)
+060215120216                DISPLAY "BIN4." CNTR1 " = " BIN4(CNTR1)
+060216120216                DISPLAY "DATE." CNTR1 " = " DATE1(CNTR1)
+060217120216                DISPLAY "DATE2." CNTR1 " = " DATE2(CNTR1)
+060218120216                DISPLAY "DATE3." CNTR1 " = " DATE3(CNTR1)
+060219120606                DISPLAY "TIME1." CNTR1 " = " TIME1(CNTR1)
+060220120606                DISPLAY "TIME2." CNTR1 " = " TIME2(CNTR1)
+060221120606                DISPLAY "TIME3." CNTR1 " = " TIME3(CNTR1)
+060222120606                DISPLAY "TIMESTAMP." CNTR1 " = " TIMESTAMP1(CNTR1)
+060223120216                DISPLAY "FLOAT4." CNTR1 " = " FLOAT4(CNTR1)
+060224120216                DISPLAY "FLOAT." CNTR1 " = " FLOAT8(CNTR1)
+060225120215
+060226120216                MOVE "YYYYY" TO CHAR20(CNTR1)(5:5)
+060227120606                MOVE "YYYYY" TO LCHAR20(CNTR1)(5:5)
+060228120606                MOVE  FUNCTION NATIONAL-OF("ZZZZZZZZZZ")
+060229120216                     TO UNICODE20(CNTR1)(5:10)
+060230120606                MOVE  FUNCTION NATIONAL-OF("ZZZZZZZZZZ")
+060231120606                     TO LUNICODE20(CNTR1)(5:10)
+060232120606                COMPUTE BIN2SIGN(CNTR1) = BIN2SIGN(CNTR1) + 98
+060233120216                COMPUTE BIN4SIGN(CNTR1) = BIN4SIGN(CNTR1) + 998
+060234120216                COMPUTE BIN8SIGN(CNTR1) = BIN8SIGN(CNTR1) + 9998
+060235120216                COMPUTE DEC112(CNTR1) = DEC112(CNTR1) + 998
+060236120216                COMPUTE DEC15(CNTR1) = DEC15(CNTR1) + 998
+060237120216                COMPUTE NUM6(CNTR1) = NUM6(CNTR1) + 9998
+060238120216                COMPUTE NUM103(CNTR1) = NUM103(CNTR1) + 9998
+060239120216                COMPUTE BIN2(CNTR1) = BIN2(CNTR1) + 98
+060240120216                COMPUTE BIN4(CNTR1) = BIN4(CNTR1) + 998
+060241120215
+060242120215      *    DATE1 FORMAT YYYY-MM-DD
+060243120216                COMPUTE DATE1-YYYY(CNTR1) = DATE1-YYYY(CNTR1) + 5
+060244120216                COMPUTE DATE1-MM(CNTR1) = DATE1-MM(CNTR1) + 5
+060245120216                COMPUTE DATE1-DD(CNTR1) = DATE1-DD(CNTR1) + 5
+060246120215
+060247120215      *    DATE2 FORMAT MM/DD/YYYY
+060248120216                COMPUTE DATE2-YYYY(CNTR1) = DATE2-YYYY(CNTR1) + 5
+060249120216                COMPUTE DATE2-MM(CNTR1) = DATE2-MM(CNTR1) + 5
+060250120216                COMPUTE DATE2-DD(CNTR1) = DATE2-DD(CNTR1) + 5
+060251120215
+060252120215      *    DATE3 FORMAT MMDDYYYY
+060253120216                COMPUTE DATE3-YYYY(CNTR1) = DATE3-YYYY(CNTR1) + 5
+060254120216                COMPUTE DATE3-MM(CNTR1) = DATE3-MM(CNTR1) + 5
+060255120216                COMPUTE DATE3-DD(CNTR1) = DATE3-DD(CNTR1) + 5
+060256120215
+060257120606      *    TIME1 FORMAT
+060258120606                COMPUTE TIME1-HH(CNTR1) = TIME1-HH(CNTR1) + 5
+060259120606                COMPUTE TIME1-MM(CNTR1) = TIME1-MM(CNTR1) + 5
+060260120606                COMPUTE TIME1-SS(CNTR1) = TIME1-SS(CNTR1) + 5
+060261120606
+060263120606      *    TIME2 FORMAT
+060264120606                COMPUTE TIME2-HH(CNTR1) = TIME2-HH(CNTR1) + 5
+060265120606                COMPUTE TIME2-MM(CNTR1) = TIME2-MM(CNTR1) + 5
+060266120612                COMPUTE TIME2-SS(CNTR1) = TIME2-SS(CNTR1) + 5
+060267120606
+060269120606      *    TIME3 FORMAT
+060270120606                COMPUTE TIME3-HH(CNTR1) = TIME3-HH(CNTR1) + 5
+060271120606                COMPUTE TIME3-MM(CNTR1) = TIME3-MM(CNTR1) + 5
+060272120606                COMPUTE TIME3-SS(CNTR1) = TIME3-SS(CNTR1) + 5
+060273120606
+060275120606      *    TIMESTAMP1 FORMAT = YYYY-MM-DD-HH.MM.SS
+060276120216                COMPUTE TS-YYYY(CNTR1) = TS-YYYY(CNTR1) + 5
+060277120216                COMPUTE TS-MM(CNTR1) = TS-MM(CNTR1) + 5
+060278120216                COMPUTE TS-DD(CNTR1) = TS-DD(CNTR1) + 5
+060279120216                COMPUTE TS-HH(CNTR1) = TS-HH(CNTR1) + 5
+060280120216                COMPUTE TS-MIN(CNTR1) = TS-MIN(CNTR1) + 5
+060281120216                COMPUTE TS-SS(CNTR1) = TS-SS(CNTR1) + 5
+060282120216                COMPUTE FLOAT4(CNTR1) = FLOAT4(CNTR1) + 9.9e-1
+060283120216                COMPUTE FLOAT8(CNTR1) = FLOAT8(CNTR1) + 9.9e-1
+060284120215
+060285120216               PERFORM WITH TEST BEFORE VARYING CNTR2 FROM 1 BY 1
+060286120216                   UNTIL CNTR2 > 2
+060287120216                   DISPLAY "CHAR20." CNTR1 "." CNTR2 " = "
+060288120216                        CHAR20A(CNTR1 CNTR2)
+060289120606                   DISPLAY "LCHAR20." CNTR1 "." CNTR2 " = "
+060290120606                        LCHAR20A(CNTR1 CNTR2)
+060291120606                   DISPLAY "UNICODE20." CNTR1 "." CNTR2 " = "
+060292120216                       UNICODE20A(CNTR1 CNTR2)
+060293120606                   DISPLAY "LUNICODE20." CNTR1 "." CNTR2 " = "
+060294120606                       LUNICODE20A(CNTR1 CNTR2)
+060295120606                   DISPLAY "BIN2SIGN." CNTR1 "." CNTR2 " = "
+060296120216                       BIN2SIGNA(CNTR1 CNTR2)
+060297120216                   DISPLAY "BIN4SIGN." CNTR1 "." CNTR2 " = "
+060298120216                       BIN4SIGNA(CNTR1 CNTR2)
+060299120216                   DISPLAY "BIN8SIGN." CNTR1 "." CNTR2 " = "
+060300120216                       BIN8SIGNA(CNTR1 CNTR2)
+060301120216                   DISPLAY "DEC112." CNTR1 "." CNTR2 " = "
+060302120216                       DEC112A(CNTR1 CNTR2)
+060303120216                   DISPLAY "DEC15." CNTR1 "." CNTR2 " = "
+060304120216                       DEC15A(CNTR1 CNTR2)
+060305120216                   DISPLAY "NUM6" CNTR1 "." CNTR2 " = "
+060306120216                       NUM6A(CNTR1 CNTR2)
+060307120216                   DISPLAY "NUM103" CNTR1 "." CNTR2 " = "
+060308120216                       NUM103A(CNTR1 CNTR2)
+060309120216                   DISPLAY "BIN2" CNTR1 "." CNTR2 " = "
+060310120216                       BIN2A(CNTR1 CNTR2)
+060311120216                   DISPLAY "BIN4" CNTR1 "." CNTR2 " = "
+060312120216                       BIN4A(CNTR1 CNTR2)
+060313120216                   DISPLAY "DATE1" CNTR1 "." CNTR2 " = "
+060314120216                       DATE1A(CNTR1 CNTR2)
+060315120606                   DISPLAY "DATE2" CNTR1 "." CNTR2 " = "
+060316120606                       DATE2A(CNTR1 CNTR2)
+060317120606                   DISPLAY "DATE3" CNTR1 "." CNTR2 " = "
+060318120606                       DATE3A(CNTR1 CNTR2)
+060319120606                   DISPLAY "TIME1" CNTR1 "." CNTR2 " = "
+060320120612                       TIME1A(CNTR1 CNTR2)
+060321120606                   DISPLAY "TIME2" CNTR1 "." CNTR2 " = "
+060322120612                       TIME2A(CNTR1 CNTR2)
+060323120612                   DISPLAY "TIME3" CNTR1 "." CNTR2 " = "
+060324120612                       TIME3A(CNTR1 CNTR2)
+060325120606                   DISPLAY "TIMESTAMP1" CNTR1 "." CNTR2 " = "
+060326120216                       TIMESTAMP1A(CNTR1 CNTR2)
+060327120216                   DISPLAY "FLOAT4" CNTR1 "." CNTR2 " = "
+060328120216                       FLOAT4A(CNTR1 CNTR2)
+060329120216                   DISPLAY "FLOAT8" CNTR1 "." CNTR2 " = "
+060330120216                       FLOAT8A(CNTR1 CNTR2)
+060331120216
+060332120216                   MOVE "YYYYY" TO CHAR20A(CNTR1 CNTR2)(5:5)
+060333120606                   MOVE "YYYYY" TO LCHAR20A(CNTR1 CNTR2)(5:5)
+060334120606                   MOVE  FUNCTION NATIONAL-OF("ZZZZZZZZZZ")
+060335120216                       TO UNICODE20A(CNTR1 CNTR2)(5:10)
+060336120606                   MOVE  FUNCTION NATIONAL-OF("ZZZZZZZZZZ")
+060337120606                       TO LUNICODE20A(CNTR1 CNTR2)(5:10)
+060338120606                   COMPUTE BIN2SIGNA(CNTR1 CNTR2) =
+060339120216                       BIN2SIGNA(CNTR1 CNTR2) + 98
+060340120216
+060341120216                   COMPUTE BIN4SIGNA(CNTR1 CNTR2) =
+060342120216                       BIN4SIGNA(CNTR1 CNTR2) + 998
+060343120216                   COMPUTE BIN8SIGNA(CNTR1 CNTR2) =
+060344120216                       BIN8SIGNA(CNTR1 CNTR2) + 9998
+060345120216                   COMPUTE DEC112A(CNTR1 CNTR2) =
+060346120216                       DEC112A(CNTR1 CNTR2) + 998
+060347120216                   COMPUTE DEC15A(CNTR1 CNTR2) =
+060348120216                       DEC15A(CNTR1 CNTR2) + 998
+060349120216                   COMPUTE NUM6A(CNTR1 CNTR2) =
+060350120216                       NUM6A(CNTR1 CNTR2) + 9998
+060351120216                   COMPUTE NUM103A(CNTR1 CNTR2) =
+060352120216                       NUM103A(CNTR1 CNTR2) + 9998
+060353120216                   COMPUTE BIN2A(CNTR1 CNTR2) =
+060354120216                        BIN2A(CNTR1 CNTR2) + 98
+060355120216                   COMPUTE BIN4A(CNTR1 CNTR2) =
+060356120216                       BIN4A(CNTR1 CNTR2) + 998
+060357120216
+060358120216      *    DATE1 FORMAT YYYY-MM-DD
+060359120216                   COMPUTE DATE1-YA(CNTR1 CNTR2) =
+060360120216                       DATE1-YA(CNTR1 CNTR2) + 5
+060361120216                   COMPUTE DATE1-MA(CNTR1 CNTR2) =
+060362120216                       DATE1-MA(CNTR1 CNTR2) + 5
+060363120216                   COMPUTE DATE1-DA(CNTR1 CNTR2) =
+060364120216                       DATE1-DA(CNTR1 CNTR2) + 5
+060365120216
+060366120216      *    DATE2 FORMAT MM/DD/YYYY
+060367120216                   COMPUTE DATE2-YA(CNTR1 CNTR2) =
+060368120216                       DATE2-YA(CNTR1 CNTR2) + 5
+060369120216                   COMPUTE DATE2-MA(CNTR1 CNTR2) =
+060370120216                       DATE2-MA(CNTR1 CNTR2) + 5
+060371120216                   COMPUTE DATE2-DA(CNTR1 CNTR2) =
+060372120216                       DATE2-DA(CNTR1 CNTR2) + 5
+060373120216
+060374120216      *    DATE3 FORMAT MMDDYYYY
+060375120216                   COMPUTE DATE3-YA(CNTR1 CNTR2) =
+060376120216                       DATE3-YA(CNTR1 CNTR2) + 5
+060377120216                   COMPUTE DATE3-MA(CNTR1 CNTR2) =
+060378120216                       DATE3-MA(CNTR1 CNTR2) + 5
+060379120216                   COMPUTE DATE3-DA(CNTR1 CNTR2) =
+060380120216                       DATE3-DA(CNTR1 CNTR2) + 5
+060381120216
+060382120606      *    TIME1 FORMAT
+060383120612                COMPUTE TIME1-HA(CNTR1 CNTR2) =
+060384120612                   TIME1-HA(CNTR1 CNTR2) + 5
+060385120612                COMPUTE TIME1-MA(CNTR1 CNTR2) =
+060386120612                   TIME1-MA(CNTR1 CNTR2) + 5
+060387120612                COMPUTE TIME1-SA(CNTR1 CNTR2) =
+060388120612                   TIME1-SA(CNTR1 CNTR2) + 5
+060389120606
+060390120606      *    TIME2 FORMAT
+060391120612                COMPUTE TIME2-HA(CNTR1 CNTR2) =
+060392120612                   TIME2-HA(CNTR1 CNTR2) + 5
+060393120612                COMPUTE TIME2-MA(CNTR1 CNTR2) =
+060394120612                   TIME2-MA(CNTR1 CNTR2) + 5
+060395120612                COMPUTE TIME2-SA(CNTR1 CNTR2) =
+060396120612                   TIME2-SA(CNTR1 CNTR2) + 5
+060397120612
+060398120606      *    TIME3 FORMAT
+060399120612                COMPUTE TIME3-HA(CNTR1 CNTR2) =
+060400120612                   TIME3-HA(CNTR1 CNTR2) + 5
+060401120612                COMPUTE TIME3-MA(CNTR1 CNTR2) =
+060402120612                   TIME3-MA(CNTR1 CNTR2) + 5
+060403120612                COMPUTE TIME3-SA(CNTR1 CNTR2) =
+060404120612                   TIME3-SA(CNTR1 CNTR2) + 5
+060405120606
+060406120606      *    TIMESTAMP1 FORMAT = YYYY-MM-DD-HH.MM.SS
+060407120216                   COMPUTE TS-YA(CNTR1 CNTR2) =
+060408120216                       TS-YA(CNTR1 CNTR2) + 5
+060409120216                   COMPUTE TS-MA(CNTR1 CNTR2) =
+060410120216                       TS-MA(CNTR1 CNTR2) + 5
+060411120216                   COMPUTE TS-DA(CNTR1 CNTR2) =
+060412120216                       TS-DA(CNTR1 CNTR2) + 5
+060413120216                   COMPUTE TS-HA(CNTR1 CNTR2) =
+060414120216                       TS-HA(CNTR1 CNTR2) + 5
+060415120216                   COMPUTE TS-MIA(CNTR1 CNTR2) =
+060416120216                       TS-MIA(CNTR1 CNTR2) + 5
+060417120216                   COMPUTE TS-SA(CNTR1 CNTR2) =
+060418120216                       TS-SA(CNTR1 CNTR2) + 5
+060419120216                   COMPUTE FLOAT4A(CNTR1 CNTR2) =
+060420120216                       FLOAT4A(CNTR1 CNTR2) + 9.9e-1
+060421120216                   COMPUTE FLOAT8A(CNTR1 CNTR2) =
+060422120216                       FLOAT8A(CNTR1 CNTR2) + 9.9e-1
+060423120216
+060424120216
+060425120216                   DISPLAY "R_CHAR20." CNTR1 "." CNTR2 " = "
+060426120216                        CHAR20R(CNTR1 CNTR2)
+060427120606                   DISPLAY "R_LCHAR20." CNTR1 "." CNTR2 " = "
+060428120606                        LCHAR20R(CNTR1 CNTR2)
+060429120606                   DISPLAY "R_UNICODE20." CNTR1 "." CNTR2 " = "
+060430120216                       UNICODE20R(CNTR1 CNTR2)
+060431120606                   DISPLAY "R_LUNICODE20." CNTR1 "." CNTR2 " = "
+060432120606                       LUNICODE20R(CNTR1 CNTR2)
+060433120606                   DISPLAY "R_BIN2SIGN." CNTR1 "." CNTR2 " = "
+060434120216                       BIN2SIGNR(CNTR1 CNTR2)
+060435120216                   DISPLAY "R_BIN4SIGN." CNTR1 "." CNTR2 " = "
+060436120216                       BIN4SIGNR(CNTR1 CNTR2)
+060437120216                   DISPLAY "R_BIN8SIGN." CNTR1 "." CNTR2 " = "
+060438120216                       BIN8SIGNR(CNTR1 CNTR2)
+060439120216                   DISPLAY "R_DEC112." CNTR1 "." CNTR2 " = "
+060440120216                       DEC112R(CNTR1 CNTR2)
+060441120216                   DISPLAY "R_DEC15." CNTR1 "." CNTR2 " = "
+060442120216                       DEC15R(CNTR1 CNTR2)
+060443120216                   DISPLAY "R_NUM6" CNTR1 "." CNTR2 " = "
+060444120216                       NUM6R(CNTR1 CNTR2)
+060445120216                   DISPLAY "R_NUM103" CNTR1 "." CNTR2 " = "
+060446120216                       NUM103R(CNTR1 CNTR2)
+060447120216                   DISPLAY "R_BIN2" CNTR1 "." CNTR2 " = "
+060448120216                       BIN2R(CNTR1 CNTR2)
+060449120216                   DISPLAY "R_BIN4" CNTR1 "." CNTR2 " = "
+060450120216                       BIN4R(CNTR1 CNTR2)
+060451120216                   DISPLAY "R_DATE1" CNTR1 "." CNTR2 " = "
+060452120216                       DATE1R(CNTR1 CNTR2)
+060453120216                   DISPLAY "R_DATE1" CNTR1 "." CNTR2 " = "
+060454120216                       DATE2R(CNTR1 CNTR2)
+060455120216                   DISPLAY "R_DATE2" CNTR1 "." CNTR2 " = "
+060456120216                       DATE3R(CNTR1 CNTR2)
+060457120606                   DISPLAY "R_TIME1" CNTR1 "." CNTR2 " = "
+060458120606                       TIME1R(CNTR1 CNTR2)
+060459120612                   DISPLAY "R_TIME2" CNTR1 "." CNTR2 " = "
+060460120606                       TIME2R(CNTR1 CNTR2)
+060461120612                   DISPLAY "R_TIME3" CNTR1 "." CNTR2 " = "
+060462120606                       TIME3R(CNTR1 CNTR2)
+060463120606                   DISPLAY "R_TIMESTAMP1" CNTR1 "." CNTR2 " = "
+060464120216                       TIMESTAMP1R(CNTR1 CNTR2)
+060465120216                   DISPLAY "R_FLOAT4" CNTR1 "." CNTR2 " = "
+060466120216                       FLOAT4R(CNTR1 CNTR2)
+060467120216                   DISPLAY "R_FLOAT8" CNTR1 "." CNTR2 " = "
+060468120216                       FLOAT8R(CNTR1 CNTR2)
+060469120216
+060470120217                   DISPLAY "COMPUTE RECA"
+060471120216                   MOVE "YYYYY" TO CHAR20R(CNTR1 CNTR2)(5:5)
+060472120606                   MOVE "YYYYY" TO LCHAR20R(CNTR1 CNTR2)(5:5)
+060473120606                   MOVE  FUNCTION NATIONAL-OF("ZZZZZZZZZZ")
+060474120216                       TO UNICODE20R(CNTR1 CNTR2)(5:10)
+060475120606                   MOVE  FUNCTION NATIONAL-OF("ZZZZZZZZZZ")
+060476120606                       TO LUNICODE20R(CNTR1 CNTR2)(5:10)
+060477120606                   COMPUTE BIN2SIGNR(CNTR1 CNTR2) =
+060478120216                       BIN2SIGNR(CNTR1 CNTR2) + 98
+060479120216
+060480120216                   COMPUTE BIN4SIGNR(CNTR1 CNTR2) =
+060481120216                       BIN4SIGNR(CNTR1 CNTR2) + 998
+060482120216                   COMPUTE BIN8SIGNR(CNTR1 CNTR2) =
+060483120216                       BIN8SIGNR(CNTR1 CNTR2) + 9998
+060484120216                   COMPUTE DEC112R(CNTR1 CNTR2) =
+060485120216                       DEC112R(CNTR1 CNTR2) + 998
+060486120216                   COMPUTE DEC15R(CNTR1 CNTR2) =
+060487120216                       DEC15R(CNTR1 CNTR2) + 998
+060488120216                   COMPUTE NUM6R(CNTR1 CNTR2) =
+060489120216                       NUM6R(CNTR1 CNTR2) + 9998
+060490120216                   COMPUTE NUM103R(CNTR1 CNTR2) =
+060491120216                       NUM103R(CNTR1 CNTR2) + 9998
+060492120216                   COMPUTE BIN2R(CNTR1 CNTR2) =
+060493120216                        BIN2R(CNTR1 CNTR2) + 98
+060494120216                   COMPUTE BIN4R(CNTR1 CNTR2) =
+060495120216                       BIN4R(CNTR1 CNTR2) + 998
+060496120216
+060497120216      *    DATE1 FORMAT YYYY-MM-DD
+060498120216                   COMPUTE DATE1-YR(CNTR1 CNTR2) =
+060499120216                       DATE1-YR(CNTR1 CNTR2) + 5
+060500120216                   COMPUTE DATE1-MR(CNTR1 CNTR2) =
+060501120216                       DATE1-MR(CNTR1 CNTR2) + 5
+060502120216                   COMPUTE DATE1-DR(CNTR1 CNTR2) =
+060503120216                       DATE1-DR(CNTR1 CNTR2) + 5
+060504120216
+060505120216      *    DATE2 FORMAT MM/DD/YYYY
+060506120216                   COMPUTE DATE2-YR(CNTR1 CNTR2) =
+060507120216                       DATE2-YR(CNTR1 CNTR2) + 5
+060508120216                   COMPUTE DATE2-MR(CNTR1 CNTR2) =
+060509120216                       DATE2-MR(CNTR1 CNTR2) + 5
+060510120216                   COMPUTE DATE2-DR(CNTR1 CNTR2) =
+060511120216                       DATE2-DR(CNTR1 CNTR2) + 5
+060512120216
+060513120216      *    DATE3 FORMAT MMDDYYYY
+060514120216                   COMPUTE DATE3-YR(CNTR1 CNTR2) =
+060515120216                       DATE3-YR(CNTR1 CNTR2) + 5
+060516120216                   COMPUTE DATE3-MR(CNTR1 CNTR2) =
+060517120216                       DATE3-MR(CNTR1 CNTR2) + 5
+060518120216                   COMPUTE DATE3-DR(CNTR1 CNTR2) =
+060519120216                       DATE3-DR(CNTR1 CNTR2) + 5
+060520120216
+060521120606      *    TIME1 FORMAT
+060522120612                COMPUTE TIME1-HR(CNTR1 CNTR2) =
+060523120612                   TIME1-HR(CNTR1 CNTR2) + 5
+060524120612                COMPUTE TIME1-MR(CNTR1 CNTR2) =
+060525120612                   TIME1-MR(CNTR1 CNTR2) + 5
+060526120612                COMPUTE TIME1-SR(CNTR1 CNTR2) =
+060527120612                   TIME1-SR(CNTR1 CNTR2) + 5
+060528120606
+060529120606      *    TIME2 FORMAT
+060530120612                COMPUTE TIME2-HR(CNTR1 CNTR2) =
+060531120612                   TIME2-HR(CNTR1 CNTR2) + 5
+060532120612                COMPUTE TIME2-MR(CNTR1 CNTR2) =
+060533120612                   TIME2-MR(CNTR1 CNTR2) + 5
+060534120612                COMPUTE TIME2-SR(CNTR1 CNTR2) =
+060535120612                   TIME2-MR(CNTR1 CNTR2) + 5
+060536120612
+060537120606      *    TIME3 FORMAT
+060538120612                COMPUTE TIME3-HR(CNTR1 CNTR2) =
+060539120612                   TIME3-HR(CNTR1 CNTR2) + 5
+060540120612                COMPUTE TIME3-MR(CNTR1 CNTR2) =
+060541120612                   TIME3-MR(CNTR1 CNTR2) + 5
+060542120612                COMPUTE TIME3-SR(CNTR1 CNTR2) =
+060543120612                   TIME3-SR(CNTR1 CNTR2) + 5
+060544120606
+060545120606      *    TIMESTAMP1 FORMAT = YYYY-MM-DD-HH.MM.SS
+060546120216                   COMPUTE TS-YR(CNTR1 CNTR2) =
+060547120216                       TS-YR(CNTR1 CNTR2) + 5
+060548120216                   COMPUTE TS-MR(CNTR1 CNTR2) =
+060549120216                       TS-MR(CNTR1 CNTR2) + 5
+060550120216                   COMPUTE TS-DR(CNTR1 CNTR2) =
+060551120216                       TS-DR(CNTR1 CNTR2) + 5
+060552120216                   COMPUTE TS-HR(CNTR1 CNTR2) =
+060553120216                       TS-HR(CNTR1 CNTR2) + 5
+060554120216                   COMPUTE TS-MIR(CNTR1 CNTR2) =
+060555120216                       TS-MIR(CNTR1 CNTR2) + 5
+060556120216                   COMPUTE TS-SR(CNTR1 CNTR2) =
+060557120216                       TS-SR(CNTR1 CNTR2) + 5
+060558120216                   COMPUTE FLOAT4R(CNTR1 CNTR2) =
+060559120216                       FLOAT4R(CNTR1 CNTR2) + 9.9e-1
+060560120216                   COMPUTE FLOAT8R(CNTR1 CNTR2) =
+060561120216                       FLOAT8R(CNTR1 CNTR2) + 9.9e-1
+060562120217
+060563120217                   DISPLAY "R_TIMESTAMP1" CNTR1 "." CNTR2 " = "
+060564120217                       TIMESTAMP1R(CNTR1 CNTR2)
+060565120217
+060566120216
+060567120216               END-PERFORM
+060568120216               MOVE 2 TO VALIDCOUNT(CNTR1)
+060569120216           END-PERFORM
+060570120216           MOVE 2 TO VALIDCOUNTP
+060571120203           PERFORM PARA-1.
+060572120203
+060573000000           GOBACK.
+060574000000
+062100120203       PARA-1 SECTION.
+063100000000           CONTINUE.
+063200120203       PARA-1-X.
+063300000000           EXIT.
+063400000000
+104700000000
+104800000000      *-----------------------------------------------------------------
+104900120213      * END OF PROGRAM EDTTSTRA
+105000000000      *-----------------------------------------------------------------
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/ComplexTypeArrays.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/ComplexTypeArrays.egl
new file mode 100644
index 0000000..5374458
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/ComplexTypeArrays.egl
@@ -0,0 +1,83 @@
+package server.host.programs;
+
+import eglx.jtopen.annotations.IBMiProgram;
+import eglx.jtopen.annotations.StructArray;
+import server.host.programs.data.handlers.Handler11;
+import server.host.programs.data.handlers.Handler12;
+import server.host.programs.data.handlers.Handler13;
+import server.host.programs.data.records.Record11;
+import server.host.programs.data.records.Record12;
+import server.host.programs.data.records.Record13;
+
+ 
+// basic library
+library ComplexTypeArrays
+	
+	function primitiveHostProgram(rec1 Record11[] inout, validCount int inout){
+			@IBMiProgram {programName = "EDTTSTRA",
+						parameterAnnotations = [@StructArray{elementCount = 5},
+							null
+						]
+			},
+			@Resource{uri = "binding:file:thirdparty_programs#conn2"}
+			
+	}
+	end
+	
+	function primitiveHostProgram2(rec1 Record12[] inout, validCount int inout){
+			@IBMiProgram {programName = "EDTTSTRA",
+						libraryName = "this would cause an error",
+						parameterAnnotations = [@StructArray{elementCount = 5},
+							null
+						]
+			},
+			@Resource{uri = "binding:file:thirdparty_programs#conn2"}
+	}
+	end
+	
+	function primitiveHostProgram3(rec1 Record13[] inout, validCount int inout){
+		@IBMiProgram {programName = "EDTTSTRA",
+						libraryName = "/QSYS.LIB/EVANSM.LIB",
+						parameterAnnotations = [@StructArray{elementCount = 5, returnCountVariable = validCount},
+							null
+						]
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+	
+	function primitiveHostProgram11(rec1 Handler11[] inout, validCount int inout){
+		@IBMiProgram {programName = "/EDTTSTRA",
+						libraryName = "/QSYS.LIB/EVANSM.LIB/",
+						parameterAnnotations = [@StructArray{elementCount = 5},
+							null
+						]
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+	
+	function primitiveHostProgram12(rec1 Handler12[] inout, validCount int inout){
+		@IBMiProgram {programName = "/EDTTSTRA",
+						libraryName = "/QSYS.LIB/EVANSM.LIB",
+						parameterAnnotations = [@StructArray{elementCount = 5},
+							null
+						]
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+	function primitiveHostProgram13(rec1 Handler13[] inout, validCount int inout){
+		@IBMiProgram {programName = "EDTTSTRA",
+						libraryName = "/QSYS.LIB/EVANSM.LIB/",
+						parameterAnnotations = [@StructArray{elementCount = 5, returnCountVariable = validCount},
+							null
+						]
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+	
+	
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/ComplexTypes.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/ComplexTypes.egl
new file mode 100644
index 0000000..e8698a5
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/ComplexTypes.egl
@@ -0,0 +1,62 @@
+package server.host.programs;
+
+import eglx.jtopen.annotations.ibmiprogram;
+import server.host.programs.data.handlers.Handler1;
+import server.host.programs.data.handlers.Handler2;
+import server.host.programs.data.handlers.Handler3;
+import server.host.programs.data.records.Record1;
+import server.host.programs.data.records.Record2;
+import server.host.programs.data.records.Record3;
+
+
+/// basic library
+library ComplexTypes
+	
+	function primitiveHostProgram(rec1 Record1 inout){
+		@IBMiProgram {programName = "EDTTSTR" },
+		@Resource{uri = "binding:file:thirdparty_programs#conn2"}
+	}
+	end
+	
+	function primitiveHostProgram2(rec1 Record2 inout){
+		@IBMiProgram {programName = "EDTTSTR",
+						libraryName = "this would cause an error"
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn2"}
+	}
+	end
+	
+	function primitiveHostProgram3(rec1 Record3 inout){
+		@IBMiProgram {programName = "EDTTSTR",
+						libraryName = "/QSYS.LIB/EVANSM.LIB"
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+	
+	function primitiveHostProgram11(rec1 Handler1 inout){
+		@IBMiProgram {programName = "/EDTTSTR",
+						libraryName = "/QSYS.LIB/EVANSM.LIB/"
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+	
+	function primitiveHostProgram12(rec1 Handler2 inout){
+		@IBMiProgram {programName = "/EDTTSTR",
+						libraryName = "/QSYS.LIB/EVANSM.LIB"
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+	function primitiveHostProgram13(rec1 Handler3 inout){
+		@IBMiProgram {programName = "EDTTSTR",
+						libraryName = "/QSYS.LIB/EVANSM.LIB/"
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+	
+	
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/EDTOver.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/EDTOver.egl
new file mode 100644
index 0000000..6f136d9
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/EDTOver.egl
@@ -0,0 +1,48 @@
+package server.host.programs;
+
+import eglx.jtopen.annotations.IBMiProgram;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructText;
+import eglx.services.Encoding;
+
+
+// basic library
+library EDTOver
+	
+	function PE037(char20 string inout){
+		@IBMiProgram {programName = "EDTOVERSRV",
+						isServiceProgram = true,			
+						parameterAnnotations = [
+							@StructText{length = 20, encoding = "CP037"}						]
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#Defaults"}
+	}
+	end
+	function PEUTF(unicode20 string inout){
+		@IBMiProgram {programName = "EDTOVERSRV",
+						isServiceProgram = true,			
+						parameterAnnotations = [
+							@StructText{length = 20}
+						]
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#Defaults"}
+	}
+	end
+	function PDTUSA(date1 date inout){
+		@IBMiProgram {programName = "EDTOVERSRV",
+						isServiceProgram = true,			
+						parameterAnnotations = [
+							@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA}
+						]
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#Defaults"}
+	}
+	end
+	function PDTEUR(date1 date inout){
+		@IBMiProgram {programName = "EDTOVERSRV",
+						isServiceProgram = true			
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#Defaults"}
+	}
+	end
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/ExceptionLib.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/ExceptionLib.egl
new file mode 100644
index 0000000..f52deb2
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/ExceptionLib.egl
@@ -0,0 +1,54 @@
+package server.host.programs;
+
+import eglx.jtopen.annotations.IBMiProgram;
+
+
+
+// basic library
+library ExceptionLib
+	
+ 	function TestProc(IPARM int inout){//wrong number of parameters
+		@IBMiProgram {
+			isServiceProgram=true, 
+			programName="TSTSRVMME",
+			libraryName = "/QSYS.LIB/TSTSRVPGM.LIB"
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+ 	function TestProc1(IPARM int inout, RETDATA int inout){//wrong program name
+		@IBMiProgram {
+			isServiceProgram=true, 
+			programName="WRONG NAME",
+			libraryName = "/QSYS.LIB/TSTSRVPGM.LIB"
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	END// /
+ 	function TestProc2(IPARM int inout, RETDATA int inout){@ExternalName {value = "TestProc"},//wrong library name
+		@IBMiProgram {
+			isServiceProgram=true, 
+			programName="TSTSRVMME",
+			libraryName = "/QSYS.LIB/JVINCENS.LIB"
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	END// /
+	function TestProc3(IPARM int inout, RETDATA int inout){@ExternalName {value = "TestProc"},
+		@IBMiProgram {
+			isServiceProgram=true, 
+			programName="TSTSRVMME",
+			libraryName = "/QSYS.LIB/TSTSRVPGM.LIB"
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	END// /
+ 	function func1(IPARM int inout, RETDATA int inout){@ExternalName {value = "TestProc"},//no connections
+		@IBMiProgram {
+			isServiceProgram=true, 
+			programName="TSTSRVMME",
+			libraryName = "/QSYS.LIB/TSTSRVPGM.LIB"
+		}
+	}
+	END// /
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/Primitive.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/Primitive.egl
new file mode 100644
index 0000000..a278527
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/Primitive.egl
@@ -0,0 +1,180 @@
+package server.host.programs;
+
+import eglx.jtopen.annotations.IBMiProgram;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructZonedDecimal;
+
+
+// basic library
+library Primitive
+	
+	function primitiveHostProgram(char20 string inout,
+									lchar20 string(20) inout, 
+									unicode20 string inout,
+									lunicode20 string(20) inout,
+									bin2sign smallint inout,
+									bin4sign int inout,
+									bin8sign bigint inout,
+									dec112 decimal(11,2) inout,
+									dec15 decimal(15) inout,
+									num6 decimal(6) inout,
+									num103 decimal(10,3) inout,
+									bin2 int inout,
+									bin4 bigint inout,
+									date1 date inout,
+									date2 date inout,
+									date3 date inout,
+									time1 time inout,
+									time2 time inout,
+									time3 time inout,
+									timestamp1 timestamp("yyyyMMddHHmmss") inout,
+									float4 smallfloat inout,
+									float8 float inout){
+		@IBMiProgram {programName = "/QSYS.LIB/EVANSM.LIB/EDTTSTP",
+						parameterAnnotations = [@StructText{length = 20},
+							null,
+							@StructText{length = 20, encoding = "UTF-16BE"},
+							@StructText{encoding = "UTF-16BE"},
+							null,
+							null,
+							null,
+							null,
+							null,
+							@StructZonedDecimal {},
+							@StructZonedDecimal {},
+							@StructUnsignedBin2{},
+							@StructUnsignedBin4{},//
+							null,
+							@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA},
+							@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null},
+							null,
+							@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR},
+							@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null},
+							null,
+							null,
+							null
+							
+						]
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+	
+	function primitiveHostProgram2(char20 string inout,
+									lchar20 string(20) inout, 
+									unicode20 string inout,
+									lunicode20 string(20) inout,
+									bin2sign smallint inout,
+									bin4sign int inout,
+									bin8sign bigint inout,
+									dec112 decimal(11,2) inout,
+									dec15 decimal(15) inout,
+									num6 decimal(6) inout,
+									num103 decimal(10,3) inout,
+									bin2 int inout,
+									bin4 bigint inout,
+									date1 date inout,
+									date2 date inout,
+									date3 date inout,
+									time1 time inout,
+									time2 time inout,
+									time3 time inout,
+									timestamp1 timestamp("yyyyMMddHHmmss") inout,
+									float4 smallfloat inout,
+									float8 float inout){
+		@IBMiProgram {programName = "EDTTSTP",
+						libraryName = "/QSYS.LIB/EVANSM.LIB/",
+						parameterAnnotations = [
+							@StructText{length = 20},
+							@StructText{},
+							@StructText{length = 20, encoding = "UTF-16BE"},
+							@StructText{encoding = "UTF-16BE"},
+							@StructBin2{},
+							@StructBin4{},
+							@StructBin8{},
+							@StructPackedDecimal{},
+							@StructPackedDecimal{},
+							@StructZonedDecimal {},
+							@StructZonedDecimal {},
+							@StructUnsignedBin2{},
+							@StructUnsignedBin4{},
+							@StructDate{},
+							@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA},
+							@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null},
+							@StructTime{},
+							@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR},
+							@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null},
+							@StructTimestamp{},
+							@StructFloat4{},
+							@StructFloat8{}
+						]
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+	function primitiveHostProgram3(char20 string inout,
+									lchar20 string(20) inout, 
+									unicode20 string inout,
+									lunicode20 string(20) inout,
+									bin2sign smallint inout,
+									bin4sign int inout,
+									bin8sign bigint inout,
+									dec112 decimal(11,2) inout,
+									dec15 decimal(15) inout,
+									num6 decimal(6) inout,
+									num103 decimal(10,3) inout,
+									bin2 int inout,
+									bin4 bigint inout,
+									date1 date inout,
+									date2 date inout,
+									date3 date inout,
+									time1 time inout,
+									time2 time inout,
+									time3 time inout,
+									timestamp1 timestamp("yyyyMMddHHmmss") inout,
+									float4 smallfloat inout,
+									float8 float inout){
+		@IBMiProgram {programName = "EDTTSTP",
+						libraryName = "/QSYS.LIB/EVANSM.LIB/",
+						parameterAnnotations = [
+							@StructText{length = 20, preserveTrailingSpaces = true},
+							@StructText{preserveTrailingSpaces = true},
+							@StructText{length = 20, encoding = "UTF-16BE", preserveTrailingSpaces = true},
+							@StructText{encoding = "UTF-16BE", preserveTrailingSpaces = true},
+							@StructBin2{},
+							@StructBin4{},
+							@StructBin8{},
+							@StructPackedDecimal{},
+							@StructPackedDecimal{},
+							@StructZonedDecimal {},
+							@StructZonedDecimal {},
+							@StructUnsignedBin2{},
+							@StructUnsignedBin4{},
+							@StructDate{},
+							@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = "^"},
+							@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null},
+							@StructTime{},
+							@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = "^"},
+							@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null},
+							@StructTimestamp{},
+							@StructFloat4{},
+							@StructFloat8{}
+						]
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+	
+	
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/PrimitiveArrays.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/PrimitiveArrays.egl
new file mode 100644
index 0000000..cf2eeb4
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/PrimitiveArrays.egl
@@ -0,0 +1,185 @@
+package server.host.programs;
+
+import eglx.jtopen.annotations.IBMiProgram;
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructZonedDecimal;
+// basic library
+library PrimitiveArrays
+	
+	function primitiveHostProgram(char20 string[] inout, 
+									lchar20 string(20)[] inout, 
+									unicode20 string[] inout,
+									lunicode20 string(20)[] inout,
+									bin2sign smallint[] inout,
+									bin4sign int[] inout,
+									bin8sign bigint[] inout,
+									dec112 decimal(11,2)[] inout,
+									dec15 decimal(15)[] inout,
+									num6 decimal(6)[] inout,
+									num103 decimal(10,3)[] inout,
+									bin2 int[] inout,
+									bin4 bigint[] inout,
+									date1 date[] inout,
+									date2 date[] inout,
+									date3 date[] inout,
+									time1 time[] inout,
+									time2 time[] inout,
+									time3 time[] inout,
+									timestamp1 timestamp("yyyyMMddHHmmss")[] inout,
+									float4 smallfloat[] inout,
+									float8 float[] inout,
+									validCount int inout){
+		@IBMiProgram {programName = "/QSYS.LIB/EVANSM.LIB/EDTTSTPA",
+						parameterAnnotations = [
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20}},
+							@StructArray {elementCount = 4},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE"}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{encoding = "UTF-16BE"}},
+							@StructArray {elementCount = 4},
+							@StructArray {elementCount = 4},
+							@StructArray {elementCount = 4},
+							@StructArray {elementCount = 4},
+							@StructArray {elementCount = 4},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin2{}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin4{}},//
+							@StructArray {elementCount = 4},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = "^"}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}},
+							@StructArray {elementCount = 4},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = "^"}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}},
+							@StructArray {elementCount = 4},
+							@StructArray {elementCount = 4},
+							@StructArray {elementCount = 4},
+							null
+						]
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+ 	
+	function primitiveHostProgram2(char20 string[] inout, 
+									lchar20 string(20)[] inout, 
+									unicode20 string[] inout,
+									lunicode20 string(20)[] inout,
+									bin2sign smallint[] inout,
+									bin4sign int[] inout,
+									bin8sign bigint[] inout,
+									dec112 decimal(11,2)[] inout,
+									dec15 decimal(15)[] inout,
+									num6 decimal(6)[] inout,
+									num103 decimal(10,3)[] inout,
+									bin2 int[] inout,
+									bin4 bigint[] inout,
+									date1 date[] inout,
+									date2 date[] inout,
+									date3 date[] inout,
+									time1 time[] inout,
+									time2 time[] inout,
+									time3 time[] inout,
+									timestamp1 timestamp("yyyyMMddHHmmss")[] inout,
+									float4 smallfloat[] inout,
+									float8 float[] inout,
+									validCount int inout){
+		@IBMiProgram {programName = "EDTTSTPA",
+						libraryName = "/QSYS.LIB/EVANSM.LIB/",
+						parameterAnnotations = [
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructText {}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE"}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{encoding = "UTF-16BE"}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin2{}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin4{}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin8{}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructPackedDecimal{}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructPackedDecimal{}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin2{}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin4{}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate{}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime{}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructTimestamp{}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructFloat4{}},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructFloat8{}},
+							null
+						]
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end  
+	function primitiveHostProgram3(char20 string[] inout, 
+									lchar20 string(20)[] inout, 
+									unicode20 string[] inout,
+									lunicode20 string(20)[] inout,
+									bin2sign smallint[] inout,
+									bin4sign int[] inout,
+									bin8sign bigint[] inout,
+									dec112 decimal(11,2)[] inout,
+									dec15 decimal(15)[] inout,
+									num6 decimal(6)[] inout,
+									num103 decimal(10,3)[] inout,
+									bin2 int[] inout,
+									bin4 bigint[] inout,
+									date1 date[] inout,
+									date2 date[] inout,
+									date3 date[] inout,
+									time1 time[] inout,
+									time2 time[] inout,
+									time3 time[] inout,
+									timestamp1 timestamp("yyyyMMddHHmmss")[] inout,
+									float4 smallfloat[] inout,
+									float8 float[] inout,
+									validCount int inout){
+		@IBMiProgram {programName = "EDTTSTPA",
+						libraryName = "/QSYS.LIB/EVANSM.LIB/",
+						parameterAnnotations = [
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{length = 20, preserveTrailingSpaces = true}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{preserveTrailingSpaces = true}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE", preserveTrailingSpaces = true}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{encoding = "UTF-16BE", preserveTrailingSpaces = true}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin2{}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin4{}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin8{}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructPackedDecimal{}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructPackedDecimal{}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructZonedDecimal {}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructZonedDecimal {}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin2{}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin4{}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate{}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime {}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTimestamp{}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructFloat4{}},
+							@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructFloat8{}},
+							null
+						]
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+	
+	
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/ServiceProgram.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/ServiceProgram.egl
new file mode 100644
index 0000000..1a4321f
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/ServiceProgram.egl
@@ -0,0 +1,44 @@
+package server.host.programs;
+
+import eglx.jtopen.annotations.IBMiProgram;
+
+// basic library
+Handler ServiceProgram
+	
+ 	function TestProc(IPARM int inout, RETDATA int inout){
+		@IBMiProgram {
+			isServiceProgram=true, 
+			programName="TSTSRVMME",
+			libraryName = "/QSYS.LIB/TSTSRVPGM.LIB"
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	END// /
+ 	function TestProc2(IPARM int inout, RETDATA int inout)returns(int){@ExternalName {value = "TestProc"},
+		@IBMiProgram {
+			isServiceProgram=true, 
+			programName="TSTSRVMME",
+			libraryName = "/QSYS.LIB/TSTSRVPGM.LIB"
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	END// /
+ 	function func1(IPARM int inout, RETDATA int inout){@ExternalName {value = "TestProc"},
+		@IBMiProgram {
+			isServiceProgram=true, 
+			programName="TSTSRVMME",
+			libraryName = "/QSYS.LIB/TSTSRVPGM.LIB"
+		},
+		@Resource{uri = "issaifiahf"}
+	}
+	END// /
+ 	function func2(IPARM int inout, RETDATA int inout)returns(int){@ExternalName {value = "TestProc"},
+		@IBMiProgram {
+			isServiceProgram=true, 
+			programName="TSTSRVMME",
+			libraryName = "/QSYS.LIB/TSTSRVPGM.LIB"
+		}
+	}
+	END// / 
+	
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler1.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler1.egl
new file mode 100644
index 0000000..00193d5
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler1.egl
@@ -0,0 +1,37 @@
+package server.host.programs.data.handlers;
+
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+//
+handler Handler1 
+	char20 string{@StructText{length = 20}}; 
+	lchar20 string(20){@StructText{}}; 
+	unicode20 string{@StructText{length = 20, encoding = "UTF-16BE"}}; 
+	lunicode20 string(20){@StructText{encoding = "UTF-16BE"}}; 
+	bin2sign smallint;
+	bin4sign int;
+	bin8sign bigint;
+	dec112 decimal(11,2);
+	dec15 decimal(15);
+	num6 decimal(6){@StructZonedDecimal {}};
+	num103 decimal(10,3){@StructZonedDecimal {}};
+	bin2 int{@StructUnsignedBin2{}};
+	bin4 bigint{@StructUnsignedBin4{}};
+	date1 date;
+	date2 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA}};
+	date3 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}};
+	time1 time;
+	time2 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}};
+	time3 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}};
+	timestamp1 timestamp("yyyyMMddHHmmss");
+	float4 smallfloat;
+	float8 float;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler11.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler11.egl
new file mode 100644
index 0000000..d38d7f1
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler11.egl
@@ -0,0 +1,41 @@
+package server.host.programs.data.handlers;
+
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+
+handler Handler11
+	rec Handler1;
+	char20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20}}}; 
+	lchar20 string(20)[]{@StructArray {elementCount = 4}}; 
+	unicode20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE"}}}; 
+	lunicode20 string(20)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{encoding = "UTF-16BE"}}}; 
+	bin2sign smallint[]{@StructArray {elementCount = 4}};
+	bin4sign int[]{@StructArray {elementCount = 4}};
+	bin8sign bigint[]{@StructArray {elementCount = 4}};
+	dec112 decimal(11,2)[]{@StructArray {elementCount = 4}};
+	dec15 decimal(15)[]{@StructArray {elementCount = 4}};
+	num6 decimal(6)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	num103 decimal(10,3)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	bin2 int[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin2{}}};
+	bin4 bigint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin4{}}};
+	date1 date[]{@StructArray {elementCount = 4}};
+	date2 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA}}};
+	date3 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}}};
+	time1 time[]{@StructArray {elementCount = 4}};
+	time2 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}}};
+	time3 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}}};
+	timestamp1 timestamp("yyyyMMddHHmmss")[]{@StructArray {elementCount = 4}};
+	float4 smallfloat[]{@StructArray {elementCount = 4}};
+	float8 float[]{@StructArray {elementCount = 4}};
+	recA Handler1[]{@StructArray{elementCount = 4}};
+	validCount int;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler12.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler12.egl
new file mode 100644
index 0000000..f8a7f03
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler12.egl
@@ -0,0 +1,48 @@
+package server.host.programs.data.handlers;
+
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+
+handler Handler12
+	rec Handler2;
+	char20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20}}}; 
+	lchar20 string(20)[]{@StructArray {elementCount = 4}}; 
+	unicode20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE"}}}; 
+	lunicode20 string(20)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{encoding = "UTF-16BE"}}}; 
+	bin2sign smallint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin2{}}};
+	bin4sign int[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin4{}}};
+	bin8sign bigint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin8{}}};
+	dec112 decimal(11,2)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructPackedDecimal{}}};
+	dec15 decimal(15)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructPackedDecimal{}}};
+	num6 decimal(6)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	num103 decimal(10,3)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	bin2 int[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin2{}}};
+	bin4 bigint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin4{}}};
+	date1 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate{}}};
+	date2 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = "^"}}};
+	date3 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}}};
+	time1 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime{}}};
+	time2 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = "^"}}};
+	time3 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}}};
+	timestamp1 timestamp("yyyyMMddHHmmss")[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTimestamp{}}};
+	float4 smallfloat[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructFloat4{}}};
+	float8 float[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructFloat8{}}};
+	recA Handler2[]{@StructArray{elementCount = 4}};
+	validCount int;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler13.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler13.egl
new file mode 100644
index 0000000..d5d096c
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler13.egl
@@ -0,0 +1,47 @@
+package server.host.programs.data.handlers;
+
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+handler Handler13
+	rec Handler3;
+	char20 string[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{length = 20, preserveTrailingSpaces = true}}}; 
+	lchar20 string(20)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{preserveTrailingSpaces = true}}}; 
+	unicode20 string[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE", preserveTrailingSpaces = true}}}; 
+	lunicode20 string(20)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{encoding = "UTF-16BE", preserveTrailingSpaces = true}}}; 
+	bin2sign smallint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin2{}}};
+	bin4sign int[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin4{}}};
+	bin8sign bigint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin8{}}};
+	dec112 decimal(11,2)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructPackedDecimal{}}};
+	dec15 decimal(15)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructPackedDecimal{}}};
+	num6 decimal(6)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructZonedDecimal {}}};
+	num103 decimal(10,3)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructZonedDecimal {}}};
+	bin2 int[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin2{}}};
+	bin4 bigint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin4{}}};
+	date1 date[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate{}}};
+	date2 date[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA}}};
+	date3 date[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}}};
+	time1 time[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime{}}};
+	time2 time[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}}};
+	time3 time[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}}};
+	timestamp1 timestamp("yyyyMMddHHmmss")[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTimestamp{}}};
+	float4 smallfloat[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructFloat4{}}};
+	float8 float[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructFloat8{}}};
+	recA Handler3[]{@StructArray{elementCount = 4, returnCountVariable = validCount}};
+	validCount int;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler2.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler2.egl
new file mode 100644
index 0000000..0e308ef
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler2.egl
@@ -0,0 +1,41 @@
+package server.host.programs.data.handlers;
+
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructZonedDecimal;
+
+
+handler Handler2
+	char20 string{@StructText{length = 20}}; 
+	lchar20 string(20){@StructText{}}; 
+	unicode20 string{@StructText{length = 20, encoding = "UTF-16BE"}}; 
+	lunicode20 string(20){@StructText{encoding = "UTF-16BE"}}; 
+	bin2sign smallint{@StructBin2{}};
+	bin4sign int{@StructBin4{}};
+	bin8sign bigint{@StructBin8{}};
+	dec112 decimal(11,2){@StructPackedDecimal{}};
+	dec15 decimal(15){@StructPackedDecimal{}};
+	num6 decimal(6){@StructZonedDecimal {}};
+	num103 decimal(10,3){@StructZonedDecimal {}};
+	bin2 int{@StructUnsignedBin2{}};
+	bin4 bigint{@StructUnsignedBin4{}};
+	date1 date{@StructDate};
+	date2 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = "^"}};
+	date3 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}};
+	time1 time{@StructTime};
+	time2 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = "^"}};
+	time3 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}};
+	timestamp1 timestamp("yyyyMMddHHmmss"){@StructTimestamp{}};
+	float4 smallfloat{@StructFloat4};
+	float8 float{@StructFloat8};
+end
\ No newline at end of file
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler3.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler3.egl
new file mode 100644
index 0000000..87e0040
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/handlers/Handler3.egl
@@ -0,0 +1,42 @@
+package server.host.programs.data.handlers;
+
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+handler Handler3
+	char20 string{@StructText{length = 20,preserveTrailingSpaces = true}}; 
+	lchar20 string(20){@StructText{preserveTrailingSpaces = true}}; 
+	unicode20 string{@StructText{length = 20, encoding = "UTF-16BE",preserveTrailingSpaces = true}}; 
+	lunicode20 string(20){@StructText{encoding = "UTF-16BE",preserveTrailingSpaces = true}}; 
+	bin2sign smallint{@StructBin2{}};
+	bin4sign int{@StructBin4{}};
+	bin8sign bigint{@StructBin8{}};
+	dec112 decimal(11,2){@StructPackedDecimal{}};
+	dec15 decimal(15){@StructPackedDecimal{}};
+	num6 decimal(6){@StructZonedDecimal {}};
+	num103 decimal(10,3){@StructZonedDecimal {}};
+	bin2 int{@StructUnsignedBin2{}};
+	bin4 bigint{@StructUnsignedBin4{}};
+	date1 date{@StructDate};
+	date2 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA}};
+	date3 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}};
+	time1 time{@StructTime};
+	time2 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}};
+	time3 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}};
+	timestamp1 timestamp("yyyyMMddHHmmss"){@StructTimestamp{}};
+	float4 smallfloat{@StructFloat4};
+	float8 float{@StructFloat8};
+end
\ No newline at end of file
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record1.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record1.egl
new file mode 100644
index 0000000..85bfa4d
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record1.egl
@@ -0,0 +1,37 @@
+package server.host.programs.data.records;
+
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+
+record Record1
+	char20 string{@StructText{length = 20}}; 
+	lchar20 string(20); 
+	unicode20 string{@StructText{length = 20, encoding = "UTF-16BE"}}; 
+	lunicode20 string(20){@StructText{encoding = "UTF-16BE"}}; 
+	bin2sign smallint;
+	bin4sign int;
+	bin8sign bigint;
+	dec112 decimal(11,2);
+	dec15 decimal(15);
+	num6 decimal(6){@StructZonedDecimal {}};
+	num103 decimal(10,3){@StructZonedDecimal {}};
+	bin2 int{@StructUnsignedBin2{}};
+	bin4 bigint{@StructUnsignedBin4{}};
+	date1 date;
+	date2 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA}};
+	date3 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}};
+	time1 time;
+	time2 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}};
+	time3 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}};
+	timestamp1 timestamp("yyyyMMddHHmmss");
+	float4 smallfloat;
+	float8 float;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record11.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record11.egl
new file mode 100644
index 0000000..fc300c5
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record11.egl
@@ -0,0 +1,41 @@
+package server.host.programs.data.records;
+
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+
+record Record11
+	rec Record1;
+	char20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20}}}; 
+	lchar20 string(20)[]{@StructArray {elementCount = 4}}; 
+	unicode20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE"}}}; 
+	lunicode20 string(20)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{encoding = "UTF-16BE"}}}; 
+	bin2sign smallint[]{@StructArray {elementCount = 4}};
+	bin4sign int[]{@StructArray {elementCount = 4}};
+	bin8sign bigint[]{@StructArray {elementCount = 4}};
+	dec112 decimal(11,2)[]{@StructArray {elementCount = 4}};
+	dec15 decimal(15)[]{@StructArray {elementCount = 4}};
+	num6 decimal(6)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	num103 decimal(10,3)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	bin2 int[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin2{}}};
+	bin4 bigint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin4{}}};
+	date1 date[]{@StructArray {elementCount = 4}};
+	date2 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA}}};
+	date3 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}}};
+	time1 time[]{@StructArray {elementCount = 4}};
+	time2 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}}};
+	time3 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}}};
+	timestamp1 timestamp("yyyyMMddHHmmss")[]{@StructArray {elementCount = 4}};
+	float4 smallfloat[]{@StructArray {elementCount = 4}};
+	float8 float[]{@StructArray {elementCount = 4}};
+	recA Record1[]{@StructArray{elementCount = 4}};
+	validCount int;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record12.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record12.egl
new file mode 100644
index 0000000..e090649
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record12.egl
@@ -0,0 +1,48 @@
+package server.host.programs.data.records;
+
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+
+record Record12
+	rec Record2;
+	char20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20}}}; 
+	lchar20 string(20)[]{@StructArray {elementCount = 4}}; 
+	unicode20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE"}}}; 
+	lunicode20 string(20)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{encoding = "UTF-16BE"}}}; 
+	bin2sign smallint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin2{}}};
+	bin4sign int[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin4{}}};
+	bin8sign bigint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin8{}}};
+	dec112 decimal(11,2)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructPackedDecimal{}}};
+	dec15 decimal(15)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructPackedDecimal{}}};
+	num6 decimal(6)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	num103 decimal(10,3)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	bin2 int[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin2{}}};
+	bin4 bigint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin4{}}};
+	date1 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate{}}};
+	date2 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = "^"}}};
+	date3 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}}};
+	time1 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime{}}};
+	time2 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = "^"}}};
+	time3 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}}};
+	timestamp1 timestamp("yyyyMMddHHmmss")[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTimestamp{}}};
+	float4 smallfloat[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructFloat4{}}};
+	float8 float[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructFloat8{}}};
+	recA Record2[]{@StructArray{elementCount = 4}};
+	validCount int;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record13.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record13.egl
new file mode 100644
index 0000000..3210f99
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record13.egl
@@ -0,0 +1,48 @@
+package server.host.programs.data.records;
+
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+
+record Record13
+	rec Record3;
+	char20 string[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{length = 20, preserveTrailingSpaces = true}}}; 
+	lchar20 string(20)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{preserveTrailingSpaces = true}}}; 
+	unicode20 string[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE", preserveTrailingSpaces = true}}}; 
+	lunicode20 string(20)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{encoding = "UTF-16BE", preserveTrailingSpaces = true}}}; 
+	bin2sign smallint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin2{}}};
+	bin4sign int[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin4{}}};
+	bin8sign bigint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin8{}}};
+	dec112 decimal(11,2)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructPackedDecimal{}}};
+	dec15 decimal(15)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructPackedDecimal{}}};
+	num6 decimal(6)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructZonedDecimal {}}};
+	num103 decimal(10,3)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructZonedDecimal {}}};
+	bin2 int[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin2{}}};
+	bin4 bigint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin4{}}};
+	date1 date[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate{}}};
+	date2 date[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA}}};
+	date3 date[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}}};
+	time1 time[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime{}}};
+	time2 time[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}}};
+	time3 time[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}}};
+	timestamp1 timestamp("yyyyMMddHHmmss")[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTimestamp{}}};
+	float4 smallfloat[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructFloat4{}}};
+	float8 float[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructFloat8{}}};
+	recA Record3[]{@StructArray{elementCount = 4, returnCountVariable = validCount}};
+	validCount int;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record2.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record2.egl
new file mode 100644
index 0000000..c0a751c
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record2.egl
@@ -0,0 +1,42 @@
+package server.host.programs.data.records;
+
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+record Record2
+	char20 string{@StructText{length = 20}}; 
+	lchar20 string(20){@StructText{}}; 
+	unicode20 string{@StructText{length = 20, encoding = "UTF-16BE"}}; 
+	lunicode20 string(20){@StructText{encoding = "UTF-16BE"}}; 
+	bin2sign smallint{@StructBin2{}};
+	bin4sign int{@StructBin4{}};
+	bin8sign bigint{@StructBin8{}};
+	dec112 decimal(11,2){@StructPackedDecimal{}};
+	dec15 decimal(15){@StructPackedDecimal{}};
+	num6 decimal(6){@StructZonedDecimal {}};
+	num103 decimal(10,3){@StructZonedDecimal {}};
+	bin2 int{@StructUnsignedBin2{}};
+	bin4 bigint{@StructUnsignedBin4{}};
+	date1 date{@StructDate};
+	date2 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = "^"}};
+	date3 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}};
+	time1 time{@StructTime};
+	time2 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = "^"}};
+	time3 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}};
+	timestamp1 timestamp("yyyyMMddHHmmss"){@StructTimestamp{}};
+	float4 smallfloat{@StructFloat4};
+	float8 float{@StructFloat8};
+end
\ No newline at end of file
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record3.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record3.egl
new file mode 100644
index 0000000..75ed519
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/data/records/Record3.egl
@@ -0,0 +1,42 @@
+package server.host.programs.data.records;
+
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+record Record3
+	char20 string{@StructText{length = 20,preserveTrailingSpaces = true}}; 
+	lchar20 string(20){@StructText{preserveTrailingSpaces = true}}; 
+	unicode20 string{@StructText{length = 20, encoding = "UTF-16BE",preserveTrailingSpaces = true}}; 
+	lunicode20 string(20){@StructText{encoding = "UTF-16BE",preserveTrailingSpaces = true}}; 
+	bin2sign smallint{@StructBin2{}};
+	bin4sign int{@StructBin4{}};
+	bin8sign bigint{@StructBin8{}};
+	dec112 decimal(11,2){@StructPackedDecimal{}};
+	dec15 decimal(15){@StructPackedDecimal{}};
+	num6 decimal(6){@StructZonedDecimal {}};
+	num103 decimal(10,3){@StructZonedDecimal {}};
+	bin2 int{@StructUnsignedBin2{}};
+	bin4 bigint{@StructUnsignedBin4{}};
+	date1 date{@StructDate};
+	date2 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA}};
+	date3 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}};
+	time1 time{@StructTime};
+	time2 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}};
+	time3 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}};
+	timestamp1 timestamp("yyyyMMddHHmmss"){@StructTimestamp{}};
+	float4 smallfloat{@StructFloat4};
+	float8 float{@StructFloat8};
+end
\ No newline at end of file
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/qq.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/qq.egl
new file mode 100644
index 0000000..5ddba0d
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/programs/qq.egl
@@ -0,0 +1,29 @@
+package server.host.programs;
+
+import eglx.jtopen.annotations.IBMiProgram;
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructText;
+import eglx.services.Encoding;
+
+// basic library
+library qq
+	 
+	function primitiveHostProgram(char20 string[] inout, 
+									lchar20 string(20)[] inout, 
+									unicode20 string[] inout,
+									lunicode20 string(20)[] inout,
+									validCount int inout){
+		@IBMiProgram {programName = "/QSYS.LIB/EVANSM.LIB/EDTTSTPA",
+						parameterAnnotations = [
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20}},
+							@StructArray {elementCount = 4},
+							@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE"}},
+							@StructArray {elementCount = 4},
+							null
+						]
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	end
+	
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/ComplexTypeArrays.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/ComplexTypeArrays.egl
new file mode 100644
index 0000000..a042a09
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/ComplexTypeArrays.egl
@@ -0,0 +1,99 @@
+package server.host.rpg.programs;
+
+import eglx.jtopen.annotations.IBMiProgram;
+import eglx.jtopen.annotations.StructArray;
+import server.host.rpg.programs.data.handlers.Handler11;
+import server.host.rpg.programs.data.handlers.Handler12;
+import server.host.rpg.programs.data.handlers.Handler13;
+import server.host.rpg.programs.data.records.Record11;
+import server.host.rpg.programs.data.records.Record12;
+import server.host.rpg.programs.data.records.Record13;
+
+
+
+
+
+// basic library
+library ComplexTypeArrays
+	
+	function primitiveHostProgram(rec1 Record11[] inout, validCount int inout){
+		@ExternalName {value = "PRECS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn3"},
+		@IBMiProgram {programName = "EDTRASRV",
+						isServiceProgram = true,
+						parameterAnnotations = [
+							@StructArray{elementCount = 5},
+							null
+						]
+		}
+	}
+	end
+	
+	function primitiveHostProgram2(rec1 Record12[] inout, validCount int inout){
+		@ExternalName {value = "PRECS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn3"},
+		@IBMiProgram {programName = "EDTRASRV",
+						isServiceProgram = true,
+						libraryName = "this would cause an error",
+						parameterAnnotations = [
+							@StructArray{elementCount = 5},
+							null
+						]
+		}
+	}
+	end
+	
+	function primitiveHostProgram3(rec1 Record13[] inout, validCount int inout){
+		@ExternalName {value = "PRECS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn3"},
+		@IBMiProgram {programName = "EDTRASRV",
+						isServiceProgram = true,
+						libraryName = "/QSYS.LIB/EVANSM.LIB",
+						parameterAnnotations = [
+							@StructArray{elementCount = 5, returnCountVariable = validCount},
+							null
+						]
+		}
+	}
+	end
+	function primitiveHostProgram4(rec1 Handler11[] inout, validCount int inout){
+		@ExternalName {value = "PRECS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn3"},
+		@IBMiProgram {programName = "EDTRASRV",
+						isServiceProgram = true,
+						parameterAnnotations = [
+							@StructArray{elementCount = 5},
+							null
+						]
+		}
+	}
+	end
+	
+	function primitiveHostProgram5(rec1 Handler12[] inout, validCount int inout){
+		@ExternalName {value = "PRECS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn3"},
+		@IBMiProgram {programName = "EDTRASRV",
+						isServiceProgram = true,
+						libraryName = "this would cause an error",
+						parameterAnnotations = [
+							@StructArray{elementCount = 5},
+							null
+						]
+		}
+	}
+	end
+	
+	function primitiveHostProgram6(rec1 Handler13[] inout, validCount int inout){
+		@ExternalName {value = "PRECS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn3"},
+		@IBMiProgram {programName = "EDTRASRV",
+						isServiceProgram = true,
+						libraryName = "/QSYS.LIB/EVANSM.LIB",
+						parameterAnnotations = [@StructArray{elementCount = 5, returnCountVariable = validCount},
+							null
+						]
+		}
+	}
+	end
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/ComplexTypes.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/ComplexTypes.egl
new file mode 100644
index 0000000..8eae922
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/ComplexTypes.egl
@@ -0,0 +1,75 @@
+package server.host.rpg.programs;
+
+import eglx.jtopen.annotations.IBMiProgram;
+import server.host.rpg.programs.data.handlers.Handler1;
+import server.host.rpg.programs.data.handlers.Handler2;
+import server.host.rpg.programs.data.handlers.Handler3;
+import server.host.rpg.programs.data.records.Record1;
+import server.host.rpg.programs.data.records.Record2;
+import server.host.rpg.programs.data.records.Record3;
+
+
+/// basic library
+library ComplexTypes
+	
+	function primitiveHostProgram(rec1 Record1 inout){
+		@ExternalName {value="PREC"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn4"},
+		@IBMiProgram {programName = "EDTRECSRV",
+						isServiceProgram = true
+		}
+	}
+	end
+	
+	function primitiveHostProgram2(rec1 Record2 inout){
+		@ExternalName {value="PREC"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn4"},
+		@IBMiProgram {programName = "EDTRECSRV",
+						libraryName = "this would cause an error",
+						isServiceProgram = true
+		}
+	}
+	end
+	
+	function primitiveHostProgram3(rec1 Record3 inout){
+		@ExternalName {value="PREC"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn4"},
+		@IBMiProgram {programName = "EDTRECSRV",
+						libraryName = "/QSYS.LIB/EVANSM.LIB",
+						isServiceProgram = true
+		}
+	}
+	end
+	
+	function primitiveHostProgram11(rec1 Handler1 inout){
+		@ExternalName {value="PREC"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn4"},
+		@IBMiProgram {programName = "EDTRECSRV",
+						libraryName = "/QSYS.LIB/EVANSM.LIB/",
+						isServiceProgram = true
+		}
+	}
+	end
+	
+	function primitiveHostProgram12(rec1 Handler2 inout){
+		@ExternalName {value="PREC"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn4"},
+		@IBMiProgram {programName = "EDTRECSRV",
+						libraryName = "/QSYS.LIB/EVANSM.LIB",
+						isServiceProgram = true
+		}
+	}
+	end
+	function primitiveHostProgram13(rec1 Handler3 inout){
+		@ExternalName {value="PREC"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn4"},
+		@IBMiProgram {programName = "EDTRECSRV",
+						libraryName = "/QSYS.LIB/EVANSM.LIB/",
+						isServiceProgram = true
+		}
+	}
+	end
+	
+	
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/Primitive.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/Primitive.egl
new file mode 100644
index 0000000..c862a5b
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/Primitive.egl
@@ -0,0 +1,454 @@
+package server.host.rpg.programs;
+
+import eglx.jtopen.annotations.IBMiProgram;
+import eglx.jtopen.annotations.StructBin1;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin1;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructUnsignedBin8;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+// basic library  
+library Primitive
+	
+	function primitiveHostProgramText(char20 string inout, 
+									lchar20 string(20) inout, 
+									unicode20 string inout,
+									lunicode20 string(20) inout){
+		@ExternalName {value = "PTEXT"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructText{length = 20},
+				null,
+				@StructText{length = 20, encoding = "UTF-16BE"},
+				@StructText{encoding = "UTF-16BE"}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramInt(bin1sign smallint inout,
+									bin2sign smallint inout,
+									bin4sign int inout,
+									bin8sign bigint inout){
+		@ExternalName {value = "PINTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [@StructBin1{}, NULL, NULL, NULL]
+		}
+	}
+	end
+	
+	function primitiveHostProgramUInt(bin1 smallint inout,
+									bin2 int inout,
+									bin4 bigint inout,
+									bin8 decimal(20) inout){
+		@ExternalName {value = "PUINTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructUnsignedBin1{}, 
+				@StructUnsignedBin2{}, 
+				@StructUnsignedBin4{}, 
+				@StructUnsignedBin8{}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramFloat(float4 smallfloat inout,
+									float8 float inout){
+		@ExternalName {value = "PFLTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true
+		}
+	}
+	end
+	
+	function primitiveHostProgramZoned(num112 decimal(11,2) inout,
+									num15 decimal(15) inout){
+		@ExternalName {value = "PZONE"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructZonedDecimal {},
+				@StructZonedDecimal {}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramPacked(dec174 decimal(17,4) inout,
+									dec8 decimal(8) inout){
+		@ExternalName {value = "PPACK"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true
+		}
+	}
+	end
+	
+	function primitiveHostProgramDate(date1 date inout,
+									date2 date inout,
+									date3 date inout){
+		@ExternalName {value = "PDATE"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				null,
+				@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA},
+				@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}
+			]
+		}
+	}
+	end
+	 
+	function primitiveHostProgramTime(time1 time inout,
+									time2 time inout,
+									time3 time inout){
+		@ExternalName {value = "PTIME"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				null,
+				@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR},
+				@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramTimeStamp(timestamp1 timestamp("yyyyMMddHHmmss") inout){
+		@ExternalName {value = "PTIMEST"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true
+		}
+	}
+	end
+	
+	function primitiveHostProgramText2(char20 string inout, 
+									lchar20 string(20) inout, 
+									unicode20 string inout,
+									lunicode20 string(20) inout){
+		@ExternalName {value = "PTEXT"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructText{length = 20},
+				@StructText{},
+				@StructText{length = 20, encoding = "UTF-16BE"},
+				@StructText{encoding = "UTF-16BE"}
+			]
+		}
+	}
+	end
+	
+
+	function primitiveHostProgramInt2(bin1sign smallint inout,
+									bin2sign smallint inout,
+									bin4sign int inout,
+									bin8sign bigint inout){
+		@ExternalName {value = "PINTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructBin1{}, 
+				@StructBin2{},
+				@StructBin4{},
+				@StructBin8{}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramUInt2(bin1 smallint inout,
+									bin2 int inout,
+									bin4 bigint inout,
+									bin8 decimal(20) inout){
+		@ExternalName {value = "PUINTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructUnsignedBin1{}, 
+				@StructUnsignedBin2{}, 
+				@StructUnsignedBin4{}, 
+				@StructUnsignedBin8{}
+			]
+		}
+	}
+	end
+	
+
+	function primitiveHostProgramFloat2(float4 smallfloat inout,
+									float8 float inout){
+		@ExternalName {value = "PFLTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructFloat4{},
+				@StructFloat8{}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramZoned2(num112 decimal(11,2) inout,
+									num15 decimal(15) inout){
+		@ExternalName {value = "PZONE"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructZonedDecimal {},
+				@StructZonedDecimal {}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramPacked2(dec174 decimal(17,4) inout,
+									dec8 decimal(8) inout){
+		@ExternalName {value = "PPACK"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructPackedDecimal{},
+				@StructPackedDecimal{}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramDate2(date1 date inout,
+									date2 date inout,
+									date3 date inout){
+		@ExternalName {value = "PDATE"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructDate{},
+				@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA},
+				@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramTime2(time1 time inout,
+									time2 time inout,
+									time3 time inout){
+		@ExternalName {value = "PTIME"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructTime{},
+				@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR},
+				@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramTimeStamp2(timestamp1 timestamp("yyyyMMddHHmmss") inout){
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@ExternalName {value = "PTIMEST"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [@StructTimestamp{}]
+		}
+	}
+	end
+	
+	function primitiveHostProgramText3(char20 string inout, 
+									lchar20 string(20) inout, 
+									unicode20 string inout,
+									lunicode20 string(20) inout){
+		@ExternalName {value = "PTEXT"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructText{length = 20, preserveTrailingSpaces = true},
+				@StructText{preserveTrailingSpaces = true},
+				@StructText{length = 20, encoding = "UTF-16BE", preserveTrailingSpaces = true},
+				@StructText{encoding = "UTF-16BE", preserveTrailingSpaces = true}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramInt3(bin1sign smallint inout,
+									bin2sign smallint inout,
+									bin4sign int inout,
+									bin8sign bigint inout){
+		@ExternalName {value = "PINTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [@StructBin1{}, 
+				@StructBin2{},
+				@StructBin4{},
+				@StructBin8{}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramUInt3(bin1 smallint inout,
+									bin2 int inout,
+									bin4 bigint inout,
+									bin8 decimal(20) inout){
+		@ExternalName {value = "PUINTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructUnsignedBin1{}, 
+				@StructUnsignedBin2{}, 
+				@StructUnsignedBin4{}, 
+				@StructUnsignedBin8{}
+ 			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramFloat3(float4 smallfloat inout,
+									float8 float inout){
+		@ExternalName {value = "PFLTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructFloat4{},
+				@StructFloat8{}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramZoned3(num112 decimal(11,2) inout,
+									num15 decimal(15) inout){
+		@ExternalName {value = "PZONE"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructZonedDecimal {},
+				@StructZonedDecimal {}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramPacked3(dec174 decimal(17,4) inout,
+									dec8 decimal(8) inout){
+		@ExternalName {value = "PPACK"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructPackedDecimal{},
+				@StructPackedDecimal{}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramDate3(date1 date inout,
+									date2 date inout,
+									date3 date inout){
+		@ExternalName {value = "PDATE"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructDate{},
+				@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA},
+				@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramTime3(time1 time inout,
+									time2 time inout,
+									time3 time inout){
+		@ExternalName {value = "PTIME"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructTime{},
+				@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR},
+				@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}
+			]
+		}
+	}
+	end
+	
+	function primitiveHostProgramTimeStamp3(timestamp1 timestamp("yyyyMMddHHmmss") inout){
+		@ExternalName {value = "PTIMEST"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {
+			programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRIMSRV",
+			isServiceProgram = true,
+			parameterAnnotations = [@StructTimestamp{}]
+		}
+	}
+	end
+	
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/PrimitiveArrays.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/PrimitiveArrays.egl
new file mode 100644
index 0000000..88beea9
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/PrimitiveArrays.egl
@@ -0,0 +1,549 @@
+package server.host.rpg.programs;
+
+import eglx.jtopen.annotations.IBMiProgram;
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructBin1;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin1;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructUnsignedBin8;
+import eglx.jtopen.annotations.StructZonedDecimal;
+
+
+// basic library
+library PrimitiveArrays
+	
+	function primitiveHostProgramText(char20 string[] inout, 
+									lchar20 string(20)[] inout,
+									unicode20 string[] inout,
+									lunicode20 string(20)[] inout,
+									validCount int inout){
+		@ExternalName {value = "PTEXT"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,			
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20}},
+				@StructArray {elementCount = 4},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE"}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{encoding = "UTF-16BE"}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramInt(bin1sign smallint[] inout,
+									bin2sign smallint[] inout,
+									bin4sign int[] inout,
+									bin8sign bigint[] inout,
+									validCount int inout){
+		@ExternalName {value = "PINTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4,elementTypeAnnotation = @StructBin1{}},
+				@StructArray {elementCount = 4},
+				@StructArray {elementCount = 4},
+				@StructArray {elementCount = 4},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramPack(dec174 decimal(17,4)[] inout,
+									dec8 decimal(8)[] inout,
+									validCount int inout){
+		@ExternalName {value = "PPACK"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4},
+				@StructArray {elementCount = 4},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramZone(num150 decimal(15)[] inout,
+									num112 decimal(11,2)[] inout,
+									validCount int inout){
+		@ExternalName {value = "PZONE"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramUInt(bin1 smallint[] inout,
+									bin2 int[] inout,
+									bin4 bigint[] inout,
+									bin8 decimal(20)[] inout,
+									validCount int inout){
+		@ExternalName {value = "PUINTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin1{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin2{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin4{}},//
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin8{}},//
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramDate(date1 date[] inout,
+									date2 date[] inout,
+									date3 date[] inout,
+									validCount int inout){
+		@ExternalName {value = "PDATE"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramTime(time1 time[] inout,
+									time2 time[] inout,
+									time3 time[] inout,
+									validCount int inout){
+		@ExternalName {value = "PTIME"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramTimestamp(timestamp1 timestamp("yyyyMMddHHmmss")[] inout,
+									validCount int inout){
+		@ExternalName {value = "PTIMEST"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramFloat(float4 smallfloat[] inout,
+									float8 float[] inout,
+									validCount int inout){
+		@ExternalName {value = "PFLTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4},
+				@StructArray {elementCount = 4},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramText2(char20 string[] inout, 
+									lchar20 string(20)[] inout,
+									unicode20 string[] inout,
+									lunicode20 string(20)[] inout,
+									validCount int inout){
+		@ExternalName {value = "PTEXT"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,			
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE"}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{encoding = "UTF-16BE"}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramInt2(bin1sign smallint[] inout,
+									bin2sign smallint[] inout,
+									bin4sign int[] inout,
+									bin8sign bigint[] inout,
+									validCount int inout){
+		@ExternalName {value = "PINTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin1{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin2{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin4{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin8{}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramPack2(dec174 decimal(17,4)[] inout,
+									dec8 decimal(8)[] inout,
+									validCount int inout){
+		@ExternalName {value = "PPACK"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructPackedDecimal{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructPackedDecimal{}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramZone2(num150 decimal(15)[] inout,
+									num112 decimal(11,2)[] inout,
+									validCount int inout){
+		@ExternalName {value = "PZONE"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramUInt2(bin1 smallint[] inout,
+									bin2 int[] inout,
+									bin4 bigint[] inout,
+									bin8 decimal(20)[] inout,
+									validCount int inout){
+		@ExternalName {value = "PUINTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin1{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin2{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin4{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin8{}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramDate2(date1 date[] inout,
+									date2 date[] inout,
+									date3 date[] inout,
+									validCount int inout){
+		@ExternalName {value = "PDATE"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramTime2(time1 time[] inout,
+									time2 time[] inout,
+									time3 time[] inout,
+									validCount int inout){
+		@ExternalName {value = "PTIME"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramTimestamp2(timestamp1 timestamp("yyyyMMddHHmmss")[] inout,
+									validCount int inout){
+		@ExternalName {value = "PTIMEST"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructTimestamp{}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramFloat2(float4 smallfloat[] inout,
+									float8 float[] inout,
+									validCount int inout){
+		@ExternalName {value = "PFLTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructFloat4{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructFloat8{}},
+				null
+			]
+		}
+	}
+	end
+	function primitiveHostProgramText3(char20 string[] inout, 
+									lchar20 string(20)[] inout,
+									unicode20 string[] inout,
+									lunicode20 string(20)[] inout,
+									validCount int inout){
+		@ExternalName {value = "PTEXT"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,			
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{length = 20, preserveTrailingSpaces = true}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{preserveTrailingSpaces = true}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE", preserveTrailingSpaces = true}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{encoding = "UTF-16BE", preserveTrailingSpaces = true}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramInt3(bin1sign smallint[] inout,
+									bin2sign smallint[] inout,
+									bin4sign int[] inout,
+									bin8sign bigint[] inout,
+									validCount int inout){
+		@ExternalName {value = "PINTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin1{}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin2{}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin4{}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin8{}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramPack3(dec174 decimal(17,4)[] inout,
+									dec8 decimal(8)[] inout,
+									validCount int inout){
+		@ExternalName {value = "PPACK"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructPackedDecimal{}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructPackedDecimal{}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramZone3(num150 decimal(15)[] inout,
+									num112 decimal(11,2)[] inout,
+									validCount int inout){
+		@ExternalName {value = "PZONE"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructZonedDecimal {}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructZonedDecimal {}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramUInt3(bin1 smallint[] inout,
+									bin2 int[] inout,
+									bin4 bigint[] inout,
+									bin8 decimal(20)[] inout,
+									validCount int inout){
+		@ExternalName {value = "PUINTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin1{}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin2{}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin4{}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin8{}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramDate3(date1 date[] inout,
+									date2 date[] inout,
+									date3 date[] inout,
+									validCount int inout){
+		@ExternalName {value = "PDATE"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate{}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramTime3(time1 time[] inout,
+									time2 time[] inout,
+									time3 time[] inout,
+									validCount int inout){
+		@ExternalName {value = "PTIME"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime{}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramTimestamp3(timestamp1 timestamp("yyyyMMddHHmmss")[] inout,
+									validCount int inout){
+		@ExternalName {value = "PTIMEST"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTimestamp{}},
+				null
+			]
+		}
+	}
+	end
+ 	
+	function primitiveHostProgramFloat3(float4 smallfloat[] inout,
+									float8 float[] inout,
+									validCount int inout){
+		@ExternalName {value = "PFLTS"},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "/QSYS.LIB/TSTSRVPGM.LIB/EDTPRMASRV",
+			isServiceProgram = true,
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructFloat4{}},
+				@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructFloat8{}},
+				null
+			]
+		}
+	}
+	end
+
+	function primitiveHostProgram2(char20 string[] inout, 
+									unicode20 string[] inout,
+									bin1sign smallint[] inout,
+									bin2sign smallint[] inout,
+									bin4sign int[] inout,
+									bin8sign bigint[] inout,
+									dec174 decimal(17,4)[] inout,
+									dec8 decimal(8)[] inout,
+									num150 decimal(15)[] inout,
+									num112 decimal(11,2)[] inout,
+									bin1 smallint[] inout,
+									bin2 int[] inout,
+									bin4 bigint[] inout,
+									bin8 decimal(20)[] inout,
+									date1 date[] inout,
+									date2 date[] inout,
+									date3 date[] inout,
+									timestamp1 timestamp("yyyyMMddHHmmss")[] inout,
+									float4 smallfloat[] inout,
+									float8 float[] inout,
+									validCount int inout){
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"},
+		@IBMiProgram {programName = "EDTTSTPA",
+			libraryName = "/QSYS.LIB/EVANSM.LIB/",
+			parameterAnnotations = [
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE"}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin1{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin2{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin4{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin8{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructPackedDecimal{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructPackedDecimal{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin1{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin2{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin4{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin8{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructTimestamp{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructFloat4{}},
+				@StructArray {elementCount = 4, elementTypeAnnotation = @StructFloat8{}},
+				null
+			]
+		}
+	}
+	end  
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler1.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler1.egl
new file mode 100644
index 0000000..50c0f07
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler1.egl
@@ -0,0 +1,43 @@
+package server.host.rpg.programs.data.handlers;
+
+import eglx.jtopen.annotations.StructBin1;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructUnsignedBin1;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructUnsignedBin8;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+
+handler Handler1
+	char20 string{@StructText{length = 20}}; 
+	lchar20 string(20); 
+	unicode20 string{@StructText{length = 20, encoding = "UTF-16BE"}}; 
+	lunicode20 string(20){@StructText{encoding = "UTF-16BE"}}; 
+	bin1sign smallint{@StructBin1{}};
+	bin2sign smallint;
+	bin4sign int;
+	bin8sign bigint;
+	dec174 decimal(17,4);
+	dec8 decimal(8);
+	num150 decimal(15){@StructZonedDecimal {}};
+	num112 decimal(11,2){@StructZonedDecimal {}};
+	bin1 smallint{@StructUnsignedBin1{}};
+	bin2 int{@StructUnsignedBin2{}};
+	bin4 bigint{@StructUnsignedBin4{}};
+	bin8 decimal(20){@StructUnsignedBin8{}};
+	date1 date;
+	date2 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}};
+	date3 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}};
+	time1 time;
+	time2 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}};
+	time3 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}};
+	timestamp1 timestamp("yyyyMMddHHmmss");
+	float4 smallfloat;
+	float8 float;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler11.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler11.egl
new file mode 100644
index 0000000..4962f67
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler11.egl
@@ -0,0 +1,47 @@
+package server.host.rpg.programs.data.handlers;
+
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructBin1;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructUnsignedBin1;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructUnsignedBin8;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+
+handler Handler11
+	rec Handler1;
+	char20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20}}}; 
+	lchar20 string(20)[]{@StructArray {elementCount = 4}}; 
+	unicode20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE"}}}; 
+	lunicode20 string(20)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{encoding = "UTF-16BE"}}}; 
+	bin1sign smallint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin1{}}};
+	bin2sign smallint[]{@StructArray {elementCount = 4}};
+	bin4sign int[]{@StructArray {elementCount = 4}};
+	bin8sign bigint[]{@StructArray {elementCount = 4}};
+	dec174 decimal(17,4)[]{@StructArray {elementCount = 4}};
+	dec8 decimal(8)[]{@StructArray {elementCount = 4}};
+	num150 decimal(15)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	num112 decimal(11,2)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	bin1 smallint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin1{}}};
+	bin2 int[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin2{}}};
+	bin4 bigint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin4{}}};
+	bin8 Decimal(20)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin8{}}};
+	date1 date[]{@StructArray {elementCount = 4}};
+	date2 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}}};
+	date3 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}}};
+	time1 time[]{@StructArray {elementCount = 4}};
+	time2 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}}};
+	time3 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}}};
+	timestamp1 timestamp("yyyyMMddHHmmss")[]{@StructArray {elementCount = 4}};
+	float4 smallfloat[]{@StructArray {elementCount = 4}};
+	float8 float[]{@StructArray {elementCount = 4}};
+	recA Handler1[]{@StructArray{elementCount = 4}};
+	validCount int;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler12.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler12.egl
new file mode 100644
index 0000000..b7bf89e
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler12.egl
@@ -0,0 +1,54 @@
+package server.host.rpg.programs.data.handlers;
+
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructBin1;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin1;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructUnsignedBin8;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+
+handler Handler12
+	rec Handler2;
+	char20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20}}}; 
+	lchar20 string(20)[]{@StructArray {elementCount = 4}}; 
+	unicode20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE"}}}; 
+	lunicode20 string(20)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{encoding = "UTF-16BE"}}}; 
+	bin1sign smallint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin1{}}};
+	bin2sign smallint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin2{}}};
+	bin4sign int[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin4{}}};
+	bin8sign bigint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin8{}}};
+	dec174 decimal(17,4)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructPackedDecimal{}}};
+	dec8 decimal(8)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructPackedDecimal{}}};
+	num150 decimal(15)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	num112 decimal(11,2)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	bin1 smallint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin1{}}};
+	bin2 int[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin2{}}};
+	bin4 bigint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin4{}}};
+	bin8 Decimal(20)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin8{}}};
+	date1 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate{}}};
+	date2 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}}};
+	date3 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}}};
+	time1 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime{}}};
+	time2 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}}};
+	time3 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}}};
+	timestamp1 timestamp("yyyyMMddHHmmss")[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTimestamp{}}};
+	float4 smallfloat[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructFloat4{}}};
+	float8 float[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructFloat8{}}};
+	recA Handler2[]{@StructArray{elementCount = 4}};
+	validCount int;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler13.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler13.egl
new file mode 100644
index 0000000..9922a0a
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler13.egl
@@ -0,0 +1,54 @@
+package server.host.rpg.programs.data.handlers;
+
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructBin1;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin1;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructUnsignedBin8;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+
+handler Handler13
+	rec Handler3;
+	char20 string[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{length = 20, preserveTrailingSpaces = true}}}; 
+	lchar20 string(20)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{preserveTrailingSpaces = true}}}; 
+	unicode20 string[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE", preserveTrailingSpaces = true}}}; 
+	lunicode20 string(20)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{encoding = "UTF-16BE", preserveTrailingSpaces = true}}}; 
+	bin1sign smallint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin1{}}};
+	bin2sign smallint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin2{}}};
+	bin4sign int[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin4{}}};
+	bin8sign bigint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin8{}}};
+	dec174 decimal(17,4)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructPackedDecimal{}}};
+	dec8 decimal(8)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructPackedDecimal{}}};
+	num150 decimal(15)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructZonedDecimal {}}};
+	num112 decimal(11,2)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructZonedDecimal {}}};
+	bin1 smallint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin1{}}};
+	bin2 int[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin2{}}};
+	bin4 bigint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin4{}}};
+	bin8 Decimal(20)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin8{}}};
+	date1 date[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate{}}};
+	date2 date[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}}};
+	date3 date[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}}};
+	time1 time[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime{}}};
+	time2 time[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}}};
+	time3 time[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}}};
+	timestamp1 timestamp("yyyyMMddHHmmss")[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTimestamp{}}};
+	float4 smallfloat[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructFloat4{}}};
+	float8 float[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructFloat8{}}};
+	recA Handler3[]{@StructArray{elementCount = 4, returnCountVariable = validCount}};
+	validCount int;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler2.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler2.egl
new file mode 100644
index 0000000..9102d77
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler2.egl
@@ -0,0 +1,48 @@
+package server.host.rpg.programs.data.handlers;
+
+import eglx.jtopen.annotations.StructBin1;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin1;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructUnsignedBin8;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+handler Handler2
+	char20 string{@StructText{length = 20}}; 
+	lchar20 string(20){@StructText}; 
+	unicode20 string{@StructText{length = 20, encoding = "UTF-16BE"}}; 
+	lunicode20 string(20){@StructText{encoding = "UTF-16BE"}}; 
+	bin1sign smallint{@StructBin1{}};
+	bin2sign smallint{@StructBin2{}};
+	bin4sign int{@StructBin4{}};
+	bin8sign bigint{@StructBin8{}};
+	dec174 decimal(17,4){@StructPackedDecimal{}};
+	dec8 decimal(8){@StructPackedDecimal{}};
+	num150 decimal(15){@StructZonedDecimal {}};
+	num112 decimal(11,2){@StructZonedDecimal {}};
+	bin1 smallint{@StructUnsignedBin1{}};
+	bin2 int{@StructUnsignedBin2{}};
+	bin4 bigint{@StructUnsignedBin4{}};
+	bin8 decimal(20){@StructUnsignedBin8{}};
+	date1 date{@StructDate};
+	date2 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}};
+	date3 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}};
+	time1 time{@StructTime};
+	time2 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}};
+	time3 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}};
+	timestamp1 timestamp("yyyyMMddHHmmss"){@StructTimestamp{}};
+	float4 smallfloat{@StructFloat4};
+	float8 float{@StructFloat8};
+end
\ No newline at end of file
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler3.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler3.egl
new file mode 100644
index 0000000..1c5eb25
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/handlers/Handler3.egl
@@ -0,0 +1,48 @@
+package server.host.rpg.programs.data.handlers;
+
+import eglx.jtopen.annotations.StructBin1;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin1;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructUnsignedBin8;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+handler Handler3
+	char20 string{@StructText{length = 20,preserveTrailingSpaces = true}}; 
+	lchar20 string(20){@StructText{preserveTrailingSpaces = true}}; 
+	unicode20 string{@StructText{length = 20, encoding = "UTF-16BE",preserveTrailingSpaces = true}}; 
+	lunicode20 string(20){@StructText{encoding = "UTF-16BE",preserveTrailingSpaces = true}}; 
+	bin1sign smallint{@StructBin1{}};
+	bin2sign smallint{@StructBin2{}};
+	bin4sign int{@StructBin4{}};
+	bin8sign bigint{@StructBin8{}};
+	dec174 decimal(17,4){@StructPackedDecimal{}};
+	dec8 decimal(8){@StructPackedDecimal{}};
+	num150 decimal(15){@StructZonedDecimal {}};
+	num112 decimal(11,2){@StructZonedDecimal {}};
+	bin1 smallint{@StructUnsignedBin1{}};
+	bin2 int{@StructUnsignedBin2{}};
+	bin4 bigint{@StructUnsignedBin4{}};
+	bin8 decimal(20){@StructUnsignedBin8{}};
+	date1 date{@StructDate};
+	date2 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}};
+	date3 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}};
+	time1 time{@StructTime};
+	time2 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}};
+	time3 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}};
+	timestamp1 timestamp("yyyyMMddHHmmss"){@StructTimestamp{}};
+	float4 smallfloat{@StructFloat4};
+	float8 float{@StructFloat8};
+end
\ No newline at end of file
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record1.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record1.egl
new file mode 100644
index 0000000..10bdb1a
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record1.egl
@@ -0,0 +1,43 @@
+package server.host.rpg.programs.data.records;
+
+import eglx.jtopen.annotations.StructBin1;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructUnsignedBin1;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructUnsignedBin8;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+
+record Record1
+	char20 string{@StructText{length = 20}}; 
+	lchar20 string(20); 
+	unicode20 string{@StructText{length = 20, encoding = "UTF-16BE"}}; 
+	lunicode20 string(20){@StructText{encoding = "UTF-16BE"}}; 
+	bin1sign smallint{@StructBin1{}};
+	bin2sign smallint;
+	bin4sign int;
+	bin8sign bigint;
+	dec174 decimal(17,4);
+	dec8 decimal(8);
+	num150 decimal(15){@StructZonedDecimal {}};
+	num112 decimal(11,2){@StructZonedDecimal {}};
+	bin1 smallint{@StructUnsignedBin1{}};
+	bin2 int{@StructUnsignedBin2{}};
+	bin4 bigint{@StructUnsignedBin4{}};
+	bin8 decimal(20){@StructUnsignedBin8{}};
+	date1 date;
+	date2 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}};
+	date3 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}};
+	time1 time;
+	time2 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}};
+	time3 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}};
+	timestamp1 timestamp("yyyyMMddHHmmss");
+	float4 smallfloat;
+	float8 float;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record11.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record11.egl
new file mode 100644
index 0000000..7a62041
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record11.egl
@@ -0,0 +1,47 @@
+package server.host.rpg.programs.data.records;
+
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructBin1;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructUnsignedBin1;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructUnsignedBin8;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+
+record Record11
+	rec Record1;
+	char20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20}}}; 
+	lchar20 string(20)[]{@StructArray {elementCount = 4}}; 
+	unicode20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE"}}}; 
+	lunicode20 string(20)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{encoding = "UTF-16BE"}}}; 
+	bin1sign smallint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin1{}}};
+	bin2sign smallint[]{@StructArray {elementCount = 4}};
+	bin4sign int[]{@StructArray {elementCount = 4}};
+	bin8sign bigint[]{@StructArray {elementCount = 4}};
+	dec174 decimal(17,4)[]{@StructArray {elementCount = 4}};
+	dec8 decimal(8)[]{@StructArray {elementCount = 4}};
+	num150 decimal(15)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	num112 decimal(11,2)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	bin1 smallint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin1{}}};
+	bin2 int[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin2{}}};
+	bin4 bigint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin4{}}};
+	bin8 Decimal(20)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin8{}}};
+	date1 date[]{@StructArray {elementCount = 4}};
+	date2 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}}};
+	date3 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}}};
+	time1 time[]{@StructArray {elementCount = 4}};
+	time2 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}}};
+	time3 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}}};
+	timestamp1 timestamp("yyyyMMddHHmmss")[]{@StructArray {elementCount = 4}};
+	float4 smallfloat[]{@StructArray {elementCount = 4}};
+	float8 float[]{@StructArray {elementCount = 4}};
+	recA Record1[]{@StructArray{elementCount = 4}};
+	validCount int;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record12.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record12.egl
new file mode 100644
index 0000000..576990b
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record12.egl
@@ -0,0 +1,53 @@
+package server.host.rpg.programs.data.records;
+
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructBin1;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin1;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructUnsignedBin8;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+record Record12
+	rec Record2;
+	char20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20}}}; 
+	lchar20 string(20)[]{@StructArray {elementCount = 4}}; 
+	unicode20 string[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE"}}}; 
+	lunicode20 string(20)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructText{encoding = "UTF-16BE"}}}; 
+	bin1sign smallint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin1{}}};
+	bin2sign smallint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin2{}}};
+	bin4sign int[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin4{}}};
+	bin8sign bigint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructBin8{}}};
+	dec174 decimal(17,4)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructPackedDecimal{}}};
+	dec8 decimal(8)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructPackedDecimal{}}};
+	num150 decimal(15)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	num112 decimal(11,2)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructZonedDecimal {}}};
+	bin1 smallint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin1{}}};
+	bin2 int[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin2{}}};
+	bin4 bigint[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin4{}}};
+	bin8 Decimal(20)[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructUnsignedBin8{}}};
+	date1 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate{}}};
+	date2 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}}};
+	date3 date[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}}};
+	time1 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime{}}};
+	time2 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}}};
+	time3 time[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}}};
+	timestamp1 timestamp("yyyyMMddHHmmss")[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructTimestamp{}}};
+	float4 smallfloat[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructFloat4{}}};
+	float8 float[]{@StructArray {elementCount = 4, elementTypeAnnotation = @StructFloat8{}}};
+	recA Record2[]{@StructArray{elementCount = 4}};
+	validCount int;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record13.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record13.egl
new file mode 100644
index 0000000..f64f00e
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record13.egl
@@ -0,0 +1,54 @@
+package server.host.rpg.programs.data.records;
+
+import eglx.jtopen.annotations.StructArray;
+import eglx.jtopen.annotations.StructBin1;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin1;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructUnsignedBin8;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+
+record Record13
+	rec Record3;
+	char20 string[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{length = 20, preserveTrailingSpaces = true}}}; 
+	lchar20 string(20)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{preserveTrailingSpaces = true}}}; 
+	unicode20 string[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{length = 20, encoding = "UTF-16BE", preserveTrailingSpaces = true}}}; 
+	lunicode20 string(20)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructText{encoding = "UTF-16BE", preserveTrailingSpaces = true}}}; 
+	bin1sign smallint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin1{}}};
+	bin2sign smallint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin2{}}};
+	bin4sign int[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin4{}}};
+	bin8sign bigint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructBin8{}}};
+	dec174 decimal(17,4)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructPackedDecimal{}}};
+	dec8 decimal(8)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructPackedDecimal{}}};
+	num150 decimal(15)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructZonedDecimal {}}};
+	num112 decimal(11,2)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructZonedDecimal {}}};
+	bin1 smallint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin1{}}};
+	bin2 int[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin2{}}};
+	bin4 bigint[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin4{}}};
+	bin8 Decimal(20)[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructUnsignedBin8{}}};
+	date1 date[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate{}}};
+	date2 date[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}}};
+	date3 date[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}}};
+	time1 time[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime{}}};
+	time2 time[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}}};
+	time3 time[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}}};
+	timestamp1 timestamp("yyyyMMddHHmmss")[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructTimestamp{}}};
+	float4 smallfloat[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructFloat4{}}};
+	float8 float[]{@StructArray {elementCount = 4, returnCountVariable = validCount, elementTypeAnnotation = @StructFloat8{}}};
+	recA Record3[]{@StructArray{elementCount = 4, returnCountVariable = validCount}};
+	validCount int;
+end
+
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record2.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record2.egl
new file mode 100644
index 0000000..323cec6
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record2.egl
@@ -0,0 +1,48 @@
+package server.host.rpg.programs.data.records;
+
+import eglx.jtopen.annotations.StructBin1;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin1;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructUnsignedBin8;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+record Record2
+	char20 string{@StructText{length = 20}}; 
+	lchar20 string(20){@StructText}; 
+	unicode20 string{@StructText{length = 20, encoding = "UTF-16BE"}}; 
+	lunicode20 string(20){@StructText{encoding = "UTF-16BE"}}; 
+	bin1sign smallint{@StructBin1{}};
+	bin2sign smallint{@StructBin2{}};
+	bin4sign int{@StructBin4{}};
+	bin8sign bigint{@StructBin8{}};
+	dec174 decimal(17,4){@StructPackedDecimal{}};
+	dec8 decimal(8){@StructPackedDecimal{}};
+	num150 decimal(15){@StructZonedDecimal {}};
+	num112 decimal(11,2){@StructZonedDecimal {}};
+	bin1 smallint{@StructUnsignedBin1{}};
+	bin2 int{@StructUnsignedBin2{}};
+	bin4 bigint{@StructUnsignedBin4{}};
+	bin8 decimal(20){@StructUnsignedBin8{}};
+	date1 date{@StructDate};
+	date2 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}};
+	date3 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}};
+	time1 time{@StructTime};
+	time2 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}};
+	time3 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}};
+	timestamp1 timestamp("yyyyMMddHHmmss"){@StructTimestamp{}};
+	float4 smallfloat{@StructFloat4};
+	float8 float{@StructFloat8};
+end
\ No newline at end of file
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record3.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record3.egl
new file mode 100644
index 0000000..8f19f86
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/host/rpg/programs/data/records/Record3.egl
@@ -0,0 +1,48 @@
+package server.host.rpg.programs.data.records;
+
+import eglx.jtopen.annotations.StructBin1;
+import eglx.jtopen.annotations.StructBin2;
+import eglx.jtopen.annotations.StructBin4;
+import eglx.jtopen.annotations.StructBin8;
+import eglx.jtopen.annotations.StructDate;
+import eglx.jtopen.annotations.StructFloat4;
+import eglx.jtopen.annotations.StructFloat8;
+import eglx.jtopen.annotations.StructPackedDecimal;
+import eglx.jtopen.annotations.StructText;
+import eglx.jtopen.annotations.StructTime;
+import eglx.jtopen.annotations.StructTimestamp;
+import eglx.jtopen.annotations.StructUnsignedBin1;
+import eglx.jtopen.annotations.StructUnsignedBin2;
+import eglx.jtopen.annotations.StructUnsignedBin4;
+import eglx.jtopen.annotations.StructUnsignedBin8;
+import eglx.jtopen.annotations.StructZonedDecimal;
+import eglx.services.Encoding;
+
+
+record Record3
+	char20 string{@StructText{length = 20,preserveTrailingSpaces = true}}; 
+	lchar20 string(20){@StructText{preserveTrailingSpaces = true}}; 
+	unicode20 string{@StructText{length = 20, encoding = "UTF-16BE",preserveTrailingSpaces = true}}; 
+	lunicode20 string(20){@StructText{encoding = "UTF-16BE",preserveTrailingSpaces = true}}; 
+	bin1sign smallint{@StructBin1{}};
+	bin2sign smallint{@StructBin2{}};
+	bin4sign int{@StructBin4{}};
+	bin8sign bigint{@StructBin8{}};
+	dec174 decimal(17,4){@StructPackedDecimal{}};
+	dec8 decimal(8){@StructPackedDecimal{}};
+	num150 decimal(15){@StructZonedDecimal {}};
+	num112 decimal(11,2){@StructZonedDecimal {}};
+	bin1 smallint{@StructUnsignedBin1{}};
+	bin2 int{@StructUnsignedBin2{}};
+	bin4 bigint{@StructUnsignedBin4{}};
+	bin8 decimal(20){@StructUnsignedBin8{}};
+	date1 date{@StructDate};
+	date2 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_EUR}};
+	date3 date{@StructDate {ibmiFormat=com.ibm.as400.access.AS400Date.FORMAT_USA, ibmiSeparatorChar = null}};
+	time1 time{@StructTime};
+	time2 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR}};
+	time3 time{@StructTime {ibmiFormat=com.ibm.as400.access.AS400Time.FORMAT_EUR, ibmiSeparatorChar = null}};
+	timestamp1 timestamp("yyyyMMddHHmmss"){@StructTimestamp{}};
+	float4 smallfloat{@StructFloat4};
+	float8 float{@StructFloat8};
+end
\ No newline at end of file
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/calls/CallTests.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/calls/CallTests.egl
new file mode 100644
index 0000000..07d3f3e
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/calls/CallTests.egl
@@ -0,0 +1,148 @@
+package server.test.calls;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.jtopen.IBMiConnection;
+import eglx.jtopen.annotations.IBMiProgram;
+import eglx.lang.AnyException;
+import server.host.programs.ServiceProgram;
+
+// basic library
+library CallTests
+	
+	function test1(){@Test {}}//call with using function no return
+    	IPARM int = 7;
+    	i2 int = 0;
+    	h1 ServiceProgram;
+		try
+        	LogResult.logStdOut("call with using function no return");
+  		  	call h1.TestProc(IPARM, i2) using Resources.getResource("binding:file:thirdparty_programs#conn3") as IBMiConnection; 
+ 			LogResult.logStdOut("Test IPARM value");
+  		  	LogResult.assertBigIntEqual("FAIL IPARM", 7, IPARM);
+ 			LogResult.logStdOut("Test RETDATA value");
+   		  	LogResult.assertBigIntEqual("FAIL RETDATA", 7, i2);
+ 		onException(exception AnyException)
+ 			LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(false);
+		end
+	end
+	function test2(){@Test {}}//call with using variable no return
+    	IPARM int = 7;
+    	i2 int = 0;
+    	h1 ServiceProgram;
+    	conn IBMiConnection = Resources.getResource("binding:file:thirdparty_programs#conn1");
+		try
+        	LogResult.logStdOut("call with using variable no return");
+  		  	call h1.func1(IPARM, i2) using conn; 
+ 			LogResult.logStdOut("Test IPARM value");
+  		  	LogResult.assertBigIntEqual("FAIL IPARM", 7, IPARM);
+ 			LogResult.logStdOut("Test RETDATA value");
+  		  	LogResult.assertBigIntEqual("FAIL RETDATA", 7, i2);
+ 		onException(exception AnyException)
+ 			LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(false);
+		end
+	end
+	function test3(){@Test {}}//call with using function and return
+    	IPARM int = 7;
+    	i2 int = 0;
+    	h1 ServiceProgram;
+    	result int = -1;
+		try
+        	LogResult.logStdOut("call with using function and return");
+  		  	call h1.TestProc2(IPARM, i2) using Resources.getResource("binding:file:thirdparty_programs#conn3") as IBMiConnection returns(result); 
+ 			LogResult.logStdOut("Test IPARM value");
+  		  	LogResult.assertBigIntEqual("FAIL IPARM", 7, IPARM);
+ 			LogResult.logStdOut("Test RETDATA value");
+  		  	LogResult.assertBigIntEqual("FAIL RETDATA", 7, i2);
+ 			LogResult.logStdOut("Test return value");
+  		  	LogResult.assertBigIntEqual("FAIL return", 7, result);
+ 		onException(exception AnyException)
+ 			LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(false);
+		end
+	end
+	function test4(){@Test {}}//call with using variable and return
+    	IPARM int = 7;
+    	i2 int = 0;
+    	h1 ServiceProgram;
+    	conn IBMiConnection = Resources.getResource("binding:file:thirdparty_programs#conn1");
+    	result int = -1;
+		try
+        	LogResult.logStdOut("call with using variable and return");
+  		  	call h1.func2(IPARM, i2) using conn returns(result); 
+ 			LogResult.logStdOut("Test IPARM value");
+  		  	LogResult.assertBigIntEqual("FAIL IPARM", 7, IPARM);
+ 			LogResult.logStdOut("Test RETDATA value");
+  		  	LogResult.assertBigIntEqual("FAIL RETDATA", 7, i2);
+ 			LogResult.logStdOut("Test return value");
+  		  	LogResult.assertBigIntEqual("FAIL return", 7, result);
+ 		onException(exception AnyException)
+ 			LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(false);
+		end
+	end
+	function test5(){@Test {}}//call with no using no return
+    	IPARM int = 7;
+    	i2 int = 0;
+    	h1 ServiceProgram;
+		try
+        	LogResult.logStdOut("call with no using no return");
+  		  	call h1.TestProc(IPARM, i2); 
+ 			LogResult.logStdOut("Test IPARM value");
+  		  	LogResult.assertBigIntEqual("FAIL IPARM", 7, IPARM);
+ 			LogResult.logStdOut("Test RETDATA value");
+  		  	LogResult.assertBigIntEqual("FAIL RETDATA", 7, i2);
+ 		onException(exception AnyException)
+ 			LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(false);
+		end
+	end
+	function test6(){@Test {}}//call with no using and return
+    	IPARM int = 7;
+    	i2 int = 0;
+    	h1 ServiceProgram;
+    	result int = -1;
+		try
+        	LogResult.logStdOut("call with no using and return");
+  		  	call h1.TestProc2(IPARM, i2) returns(result); 
+ 			LogResult.logStdOut("Test IPARM value");
+  		  	LogResult.assertBigIntEqual("FAIL IPARM", 7, IPARM);
+ 			LogResult.logStdOut("Test RETDATA value");
+  		  	LogResult.assertBigIntEqual("FAIL RETDATA", 7, i2);
+ 			LogResult.logStdOut("Test return value");
+  		  	LogResult.assertBigIntEqual("FAIL return", 7, result);
+ 		onException(exception AnyException)
+ 			LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(false);
+		end
+	end
+	function test7(){@Test {}}//call with no using and return
+    	IPARM int = 7;
+    	i2 int = 0;
+    	h1 ServiceProgram;
+    	result int = -1;
+		try
+        	LogResult.logStdOut("call with no using and return");
+  		  	call TestProc2(IPARM, i2) returns(result); 
+ 			LogResult.logStdOut("Test IPARM value");
+  		  	LogResult.assertBigIntEqual("FAIL IPARM", 7, IPARM);
+ 			LogResult.logStdOut("Test RETDATA value");
+  		  	LogResult.assertBigIntEqual("FAIL RETDATA", 7, i2);
+ 			LogResult.logStdOut("Test return value");
+  		  	LogResult.assertBigIntEqual("FAIL return", 7, result);
+ 		onException(exception AnyException)
+ 			LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(false);
+		end
+	end
+ 	function TestProc2(IPARM int inout, RETDATA int inout)returns(int){@ExternalName {value = "TestProc"},
+		@IBMiProgram {
+			isServiceProgram=true, 
+			programName="TSTSRVMME",
+			libraryName = "/QSYS.LIB/TSTSRVPGM.LIB"
+		},
+		@Resource{uri = "binding:file:thirdparty_programs#conn1"}
+	}
+	END// /
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/exceptions/ExceptionTest.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/exceptions/ExceptionTest.egl
new file mode 100644
index 0000000..e2dedd8
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/exceptions/ExceptionTest.egl
@@ -0,0 +1,117 @@
+package server.test.exceptions;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.jtopen.IBMiConnection;
+import server.host.programs.ExceptionLib;
+
+// basic library
+library ExceptionTest
+	
+	function test1(){@Test {}}
+    	IPARM int = 7;
+    	i2 int = 0;
+		try
+        	LogResult.logStdOut("Test number of parameters");
+  		  	call ExceptionLib.TestProc(IPARM) using Resources.getResource("binding:file:thirdparty_programs#conn1") as IBMiConnection; 
+            LogResult.assertTrue("No exception throw.", true);
+ 		onException(exception AnyException)
+        	LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(exception.message.indexOf("MCH3601:Pointer not set for location referenced.") > 0);
+		end
+	end
+	
+	function test2(){@Test {}}
+    	IPARM int = 7;
+    	i2 int = 0;
+		try
+        	LogResult.logStdOut("Test exception wrong library");
+  		  	call ExceptionLib.TestProc2(IPARM, i2) using Resources.getResource("binding:file:thirdparty_programs#conn1") as IBMiConnection; 
+            LogResult.assertTrue("No exception throw.", true);
+ 		onException(exception AnyException)
+        	LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(exception.message.indexOf("com.ibm.as400.access.ObjectDoesNotExistException") > 0);
+		end
+	end
+	
+	function test3(){@Test {}}
+    	IPARM int = 7;
+    	i2 int = 0;
+		try
+        	LogResult.logStdOut("Test exception wrong function");
+  		  	call ExceptionLib.TestProc2(IPARM, i2) using Resources.getResource("binding:file:thirdparty_programs#conn1") as IBMiConnection; 
+            LogResult.assertTrue("No exception throw.", true);
+ 		onException(exception AnyException)
+        	LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(exception.message.indexOf("com.ibm.as400.access.ObjectDoesNotExistException") > 0);
+		end
+	end
+	function test4(){@Test {}}
+    	IPARM int = 7;
+    	i2 int = 0;
+		try
+        	LogResult.logStdOut("Test exception wrong program name");
+  		  	call ExceptionLib.TestProc1(IPARM, i2) using Resources.getResource("binding:file:thirdparty_programs#conn3") as IBMiConnection; 
+            LogResult.assertTrue("No exception throw.", true);
+ 		onException(exception AnyException)
+        	LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(exception.message.indexOf("com.ibm.as400.access.ObjectDoesNotExistException") > 0);
+		end
+	end
+	
+	function test5(){@Test {}}
+    	IPARM int = 7;
+    	i2 int = 0;
+		try
+        	LogResult.logStdOut("Test null connection");
+        	conn IBMiConnection?;
+  		  	call ExceptionLib.TestProc3(IPARM, i2) using conn; 
+            LogResult.assertTrue("No exception throw.", true);
+ 		onException(exception AnyException)
+        	LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(exception.message.indexOf("Host connection is null") > 0);
+		end
+	end
+	
+	function test6(){@Test {}}
+    	IPARM int = 7;
+    	i2 int = 0;
+		try
+        	LogResult.logStdOut("Test bad resource name");
+  		  	call ExceptionLib.TestProc(IPARM) using Resources.getResource("binding:file:thirdparty_programs#conn6") as IBMiConnection; 
+            LogResult.assertTrue("No exception throw.", true);
+ 		onException(exception AnyException)
+        	LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(exception.message.indexOf("No resource binding found for for binding name: conn6") > 0);
+		end
+	end
+	
+	function test7(){@Test {}}
+    	IPARM int = 7;
+    	i2 int = 0;
+		try
+        	LogResult.logStdOut("Test bad resource file name");
+  		  	call ExceptionLib.TestProc(IPARM) using Resources.getResource("binding:file:thirdparty_programs#file#BadFile#conn6") as IBMiConnection; 
+            LogResult.assertTrue("No exception throw.", true);
+ 		onException(exception AnyException)
+        	LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(exception.message == "Unable to processor the uri binding:file:thirdparty_programs#file#BadFile#conn6 into a resource.");
+		end
+	end
+	
+	function test9(){@Test {}}
+    	IPARM int = 7;
+    	i2 int = 0;
+		try
+        	LogResult.logStdOut("Test using resource is the wrong type");
+        	conn IBMiConnection?;
+  		  	call ExceptionLib.TestProc3(IPARM, i2) using Resources.getResource("binding:file:thirdparty_programs#DerbyConnection") as IBMiConnection; 
+            LogResult.assertTrue("No exception throw.", true);
+ 		onException(exception AnyException)
+        	LogResult.logStdOut(exception.message);
+            LogResult.assertTrue1(!(exception.message.indexOf("type eglx.persistence.sql.SQLJNDIDataSource cannot be converted to the type eglx.jtopen.IBMiConnection") > 0));
+		end
+	end
+	
+	
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/HandlerFields.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/HandlerFields.egl
new file mode 100644
index 0000000..69083d4
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/HandlerFields.egl
@@ -0,0 +1,182 @@
+package server.test.handlers;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.programs.ComplexTypes;
+import server.host.programs.data.handlers.Handler1;
+
+// basic library
+library HandlerFields
+	
+	rec Handler1;
+	testParameters boolean = true;
+	function test1(){@Test}
+		rec.char20 = "abcd"; 
+		rec.lchar20 = "defg"; 
+		rec.unicode20 = "xyz"; 
+		rec.lunicode20 = "abc"; 
+		rec.bin2sign = 1;
+		rec.bin4sign = 2;
+		rec.bin8sign = 3;
+		rec.dec112 = 45.67;
+		rec.dec15 = 14;
+		rec.num6 = 5;
+		rec.num103 = 11.61;
+		rec.bin2 = 6;
+		rec.bin4  = 7;
+		rec.date1 = "06/24/2011";
+		rec.date2 = "05/19/1997";
+		rec.date3 = "04/03/1922";
+		rec.time1 = "17:54:34";
+		rec.time2 = "07:14:03";
+		rec.time3 = "01:45:43";
+		rec.timestamp1 = "2012/02/11 17:54:34";
+		rec.float4 = 8;
+		rec.float8 = 9;
+		try
+        	LogResult.logStdOut("call ComplexTypes.primitiveHostProgram11");
+			ComplexTypes.primitiveHostProgram11(rec);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.char20 value");
+            LogResult.assertStringEqual("Fail rec.char20", "abcdYYYYY", rec.char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lchar20 value");
+            LogResult.assertStringEqual("Fail rec.lchar20", "defgYYYYY", rec.lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.unicode20 value");
+            LogResult.assertStringEqual("Fail rec.unicode20", "xyz ZZZZZZZZZZ", rec.unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lunicode20 value");
+            LogResult.assertStringEqual("Fail rec.lunicode20", "abc ZZZZZZZZZZ", rec.lunicode20);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin2sign", 99, rec.bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin4sign", 1000, rec.bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin8sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin8sign", 10001, rec.bin8sign);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec112 value");
+            LogResult.assertDecimalEqual("Fail rec.dec112", 1043.67, rec.dec112);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec15 value");
+            LogResult.assertDecimalEqual("Fail rec.dec15", 1012, rec.dec15);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num6 value");
+            LogResult.assertDecimalEqual("Fail rec.num6", 10003, rec.num6);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num103 value");
+            LogResult.assertDecimalEqual("Fail rec.num103", 10009.61, rec.num103);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2 value");
+            LogResult.assertBigIntEqual("Fail rec.bin2", 104, rec.bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4 value");
+            LogResult.assertBigIntEqual("Fail rec.bin4", 1005, rec.bin4);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date1 value");
+            LogResult.assertDateEqual("Fail rec.date1", "11/29/2016", rec.date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date2 value");
+            LogResult.assertDateEqual("Fail rec.date2", "10/24/2002", rec.date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date3 value");
+            LogResult.assertDateEqual("Fail rec.date3", "09/08/1927", rec.date3);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time1 value");
+            LogResult.assertTimeEqual("Fail rec.time1", "22:59:39", rec.time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time2 value");
+            LogResult.assertTimeEqual("Fail rec.time2", "12:19:08", rec.time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time3 value");
+            LogResult.assertTimeEqual("Fail rec.time3", "06:50:48", rec.time3);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.timestamp1 value");
+            LogResult.assertTimestampEqual("Fail rec.timestamp1", "2017/07/16 22:59:39", rec.timestamp1);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float4 value");
+            LogResult.assertFloatEqual("Fail rec.float4", 8.99 as smallfloat, rec.float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float8 value");
+            LogResult.assertFloatEqual("Fail rec.float8", 9.99, rec.float8);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/HandlerFields2.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/HandlerFields2.egl
new file mode 100644
index 0000000..d6041c1
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/HandlerFields2.egl
@@ -0,0 +1,182 @@
+package server.test.handlers;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.programs.ComplexTypes;
+import server.host.programs.data.handlers.Handler2;
+
+// basic library
+library HandlerFields2
+	
+	rec Handler2;
+	testParameters boolean = true;
+	function test1(){@Test}
+		rec.char20 = "abcd"; 
+		rec.lchar20 = "defg"; 
+		rec.unicode20 = "xyz"; 
+		rec.lunicode20 = "abc"; 
+		rec.bin2sign = 1;
+		rec.bin4sign = 2;
+		rec.bin8sign = 3;
+		rec.dec112 = 45.67;
+		rec.dec15 = 14;
+		rec.num6 = 5;
+		rec.num103 = 11.61;
+		rec.bin2 = 6;
+		rec.bin4  = 7;
+		rec.date1 = "06/24/2011";
+		rec.date2 = "05/19/1997";
+		rec.date3 = "04/03/1922";
+		rec.time1 = "17:54:34";
+		rec.time2 = "07:14:03";
+		rec.time3 = "01:45:43";
+		rec.timestamp1 = "2012/02/11 17:54:34";
+		rec.float4 = 8;
+		rec.float8 = 9;
+		try
+        	LogResult.logStdOut("call ComplexTypes.primitiveHostProgram12");
+			ComplexTypes.primitiveHostProgram12(rec);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.char20 value");
+            LogResult.assertStringEqual("Fail rec.char20", "abcdYYYYY", rec.char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lchar20 value");
+            LogResult.assertStringEqual("Fail rec.lchar20", "defgYYYYY", rec.lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.unicode20 value");
+            LogResult.assertStringEqual("Fail rec.unicode20", "xyz ZZZZZZZZZZ", rec.unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lunicode20 value");
+            LogResult.assertStringEqual("Fail rec.lunicode20", "abc ZZZZZZZZZZ", rec.lunicode20);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin2sign", 99, rec.bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin4sign", 1000, rec.bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin8sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin8sign", 10001, rec.bin8sign);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec112 value");
+            LogResult.assertDecimalEqual("Fail rec.dec112", 1043.67, rec.dec112);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec15 value");
+            LogResult.assertDecimalEqual("Fail rec.dec15", 1012, rec.dec15);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num6 value");
+            LogResult.assertDecimalEqual("Fail rec.num6", 10003, rec.num6);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num103 value");
+            LogResult.assertDecimalEqual("Fail rec.num103", 10009.61, rec.num103);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2 value");
+            LogResult.assertBigIntEqual("Fail rec.bin2", 104, rec.bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4 value");
+            LogResult.assertBigIntEqual("Fail rec.bin4", 1005, rec.bin4);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date1 value");
+            LogResult.assertDateEqual("Fail rec.date1", "11/29/2016", rec.date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date2 value");
+            LogResult.assertDateEqual("Fail rec.date2", "10/24/2002", rec.date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date3 value");
+            LogResult.assertDateEqual("Fail rec.date3", "09/08/1927", rec.date3);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time1 value");
+            LogResult.assertTimeEqual("Fail rec.time1", "22:59:39", rec.time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time2 value");
+            LogResult.assertTimeEqual("Fail rec.time2", "12:19:08", rec.time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time3 value");
+            LogResult.assertTimeEqual("Fail rec.time3", "06:50:48", rec.time3);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.timestamp1 value");
+            LogResult.assertTimestampEqual("Fail rec.timestamp1", "2017/07/16 22:59:39", rec.timestamp1);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float4 value");
+            LogResult.assertFloatEqual("Fail rec.float4", 8.99 as smallfloat, rec.float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float8 value");
+            LogResult.assertFloatEqual("Fail rec.float8", 9.99, rec.float8);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/HandlerFields3.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/HandlerFields3.egl
new file mode 100644
index 0000000..09b71bb
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/HandlerFields3.egl
@@ -0,0 +1,182 @@
+package server.test.handlers;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.programs.ComplexTypes;
+import server.host.programs.data.handlers.Handler3;
+
+// basic library
+library HandlerFields3
+	
+	rec Handler3;
+	testParameters boolean = true;
+	function test1(){@Test}
+		rec.char20 = "abcd"; 
+		rec.lchar20 = "defg"; 
+		rec.unicode20 = "xyz"; 
+		rec.lunicode20 = "abc"; 
+		rec.bin2sign = 1;
+		rec.bin4sign = 2;
+		rec.bin8sign = 3;
+		rec.dec112 = 45.67;
+		rec.dec15 = 14;
+		rec.num6 = 5;
+		rec.num103 = 11.61;
+		rec.bin2 = 6;
+		rec.bin4  = 7;
+		rec.date1 = "06/24/2011";
+		rec.date2 = "05/19/1997";
+		rec.date3 = "04/03/1922";
+		rec.time1 = "17:54:34";
+		rec.time2 = "07:14:03";
+		rec.time3 = "01:45:43";
+		rec.timestamp1 = "2012/02/11 17:54:34";
+		rec.float4 = 8;
+		rec.float8 = 9;
+		try
+        	LogResult.logStdOut("call ComplexTypes.primitiveHostProgram13");
+			ComplexTypes.primitiveHostProgram13(rec);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.char20 value");
+            LogResult.assertStringEqual("Fail rec.char20", "abcdYYYYY           ", rec.char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lchar20 value");
+            LogResult.assertStringEqual("Fail rec.lchar20", "defgYYYYY           ", rec.lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.unicode20 value");
+            LogResult.assertStringEqual("Fail rec.unicode20", "xyz ZZZZZZZZZZ      ", rec.unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lunicode20 value");
+            LogResult.assertStringEqual("Fail rec.lunicode20", "abc ZZZZZZZZZZ      ", rec.lunicode20);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin2sign", 99, rec.bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin4sign", 1000, rec.bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin8sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin8sign", 10001, rec.bin8sign);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec112 value");
+            LogResult.assertDecimalEqual("Fail rec.dec112", 1043.67, rec.dec112);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec15 value");
+            LogResult.assertDecimalEqual("Fail rec.dec15", 1012, rec.dec15);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num6 value");
+            LogResult.assertDecimalEqual("Fail rec.num6", 10003, rec.num6);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num103 value");
+            LogResult.assertDecimalEqual("Fail rec.num103", 10009.61, rec.num103);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2 value");
+            LogResult.assertBigIntEqual("Fail rec.bin2", 104, rec.bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4 value");
+            LogResult.assertBigIntEqual("Fail rec.bin4", 1005, rec.bin4);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date1 value");
+            LogResult.assertDateEqual("Fail rec.date1", "11/29/2016", rec.date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date2 value");
+            LogResult.assertDateEqual("Fail rec.date2", "10/24/2002", rec.date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date3 value");
+            LogResult.assertDateEqual("Fail rec.date3", "09/08/1927", rec.date3);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time1 value");
+            LogResult.assertTimeEqual("Fail rec.time1", "22:59:39", rec.time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time2 value");
+            LogResult.assertTimeEqual("Fail rec.time2", "12:19:08", rec.time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time3 value");
+            LogResult.assertTimeEqual("Fail rec.time3", "06:50:48", rec.time3);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.timestamp1 value");
+            LogResult.assertTimestampEqual("Fail rec.timestamp1", "2017/07/16 22:59:39", rec.timestamp1);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float4 value");
+            LogResult.assertFloatEqual("Fail rec.float4", 8.99 as smallfloat, rec.float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float8 value");
+            LogResult.assertFloatEqual("Fail rec.float8", 9.99, rec.float8);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/arrays/Handler2Fields.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/arrays/Handler2Fields.egl
new file mode 100644
index 0000000..aa633ca
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/arrays/Handler2Fields.egl
@@ -0,0 +1,253 @@
+package server.test.handlers.arrays;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.programs.ComplexTypeArrays;
+import server.host.programs.data.handlers.Handler12;
+import server.host.programs.data.handlers.Handler2;
+
+// basic library
+library Handler2Fields
+	
+	rec Handler12[];
+	function test1(){@Test}
+		rec = new Handler12[0];
+		rec.appendElement(createHandler12());
+		rec.appendElement(createHandler12());
+		try
+        	LogResult.logStdOut("call ComplexTypeArrays.primitiveHostProgram2");
+			validCount int;
+			ComplexTypeArrays.primitiveHostProgram12(rec, validCount);
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	private function createHandler12()returns(Handler12)
+		r Handler12{
+					rec = createHandler2(),
+					char20 = ["abcd", "EFG"], 
+					unicode20 = ["xyz", "1234"], 
+					lchar20 = ["ABCD", "efg"], 
+					lunicode20 = ["XYZ", "4321"], 
+					bin2sign = [1,2],
+					bin4sign = [3,4],
+					bin8sign = [4,5],
+					dec112 = [45.67, 64.97],
+					dec15 = [6,7],
+					num6 = [8,9],
+					num103 = [11.61, 56.72],
+					bin2 = [10,11],
+					bin4  = [12,13],
+					date1 = ["06/24/2011" ,"03/12/1011"],
+					date2 = ["05/19/1997", "01/02/1947"],
+					date3 = ["04/03/1922", "07/24/1822"],
+					timestamp1 = ["2012/02/11 17:54:34", "1812/06/01 08:45:26"],
+					float4 = [14,15],
+					float8 = [16,17],
+					recA = new Handler2[0]
+		};
+		r.recA.appendElement(createHandler2());  
+		r.recA.appendElement(createHandler2());  
+		return(r);
+	end
+	private function createHandler2()returns(Handler2)
+		return(new Handler2{
+							char20 = "abcd", 
+							unicode20 = "xyz", 
+							lchar20 = "defg",
+							lunicode20 = "abc", 
+							bin2sign = 1,
+							bin4sign = 2,
+							bin8sign = 3,
+							dec112 = 45.67,
+							dec15 = 14,
+							num6 = 5,
+							num103 = 11.61,
+							bin2 = 6,
+							bin4  = 7,
+							date1 = "06/24/2011",
+							date2 = "05/19/1997",
+							date3 = "04/03/1922",
+							time1 = "17:54:34",
+							time2 = "07:14:03",
+							time3 = "01:45:43",
+							timestamp1 = "2012/02/11 17:54:34",
+							float4 = 8,
+							float8 = 9
+					});
+	end
+	function recsTest(){@Test {}}
+        LogResult.assertBigIntEqual("Fail rec.getSize()", 5, rec.getSize());
+	end
+	function rec_char20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "].char20.getSize()", 4, rec[idx].char20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[1]", "abcdYYYYY", rec[idx].char20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[2]", "EFG YYYYY", rec[idx].char20[2]);
+	    end
+	end
+	function rec_unicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "]unicode20.getSize()", 4, rec[idx].unicode20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[1]", "xyz ZZZZZZZZZZ", rec[idx].unicode20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[2]", "1234ZZZZZZZZZZ", rec[idx].unicode20[2]); 
+		end
+	end
+	function lchar20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lchar20.getSize()", 4, rec[idx].lchar20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[1]", "ABCDYYYYY", rec[idx].lchar20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[2]", "efg YYYYY", rec[idx].lchar20[2]);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lunicode20.getSize()", 4, rec[idx].lunicode20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[1]", "XYZ ZZZZZZZZZZ", rec[idx].lunicode20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[2]", "4321ZZZZZZZZZZ", rec[idx].lunicode20[2]);
+		end
+	end
+	function rec_bin2signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign.getSize()", 4, rec[idx].bin2sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[1]", 99, rec[idx].bin2sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[2]", 100, rec[idx].bin2sign[2]);
+		end
+	end
+	function rec_bin4signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign.getSize()", 4, rec[idx].bin4sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[1]", 1001, rec[idx].bin4sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[2]", 1002, rec[idx].bin4sign[2]);
+		end
+	end
+	function rec_bin8signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign.getSize()", 4, rec[idx].bin8sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[1]", 10002, rec[idx].bin8sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[2]", 10003, rec[idx].bin8sign[2]);
+		end
+	end
+	function rec_dec112Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec112.getSize()", 4, rec[idx].dec112.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec112[1]", 1043.67, rec[idx].dec112[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec112[2]", 1062.97, rec[idx].dec112[2]);
+		end
+	end
+	function rec_dec15Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec15.getSize()", 4, rec[idx].dec15.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec15[1]", 1004, rec[idx].dec15[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec15[2]", 1005, rec[idx].dec15[2]);
+		end
+	end
+	function num6Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num6.getSize()", 4, rec[idx].num6.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num6[1]", 10006, rec[idx].num6[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num6[2]", 10007, rec[idx].num6[2]);
+		end
+	end
+	function rec_num103Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num103.getSize()", 4, rec[idx].num103.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num103[1]", 10009.61, rec[idx].num103[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num103[2]", 10054.72, rec[idx].num103[2]);
+		end
+	end
+	function rec_bin2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2.getSize()", 4, rec[idx].bin2.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[1]", 108, rec[idx].bin2[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[2]", 109, rec[idx].bin2[2]);
+		end
+	end
+
+	function rec_bin4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4.getSize()", 4, rec[idx].bin4.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[1]", 1010, rec[idx].bin4[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[2]", 1011, rec[idx].bin4[2]);
+		end
+	end
+	function rec_date1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date1.getSize()", 4, rec[idx].date1.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[1]", "11/29/2016", rec[idx].date1[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[2]", "08/17/1016", rec[idx].date1[2]);
+		end
+	end
+	function rec_date2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date2.getSize()", 4, rec[idx].date2.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[1]", "10/24/2002", rec[idx].date2[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[2]", "06/07/1952", rec[idx].date2[2]);
+		end
+	end
+
+	function rec_date3Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date3.getSize()", 4, rec[idx].date3.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[1]", "09/08/1927", rec[idx].date3[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[2]", "12/29/1827", rec[idx].date3[2]);
+		end
+	end
+	function rec_timestamp1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]timestamp1.getSize()", 4, rec[idx].timestamp1.getSize());
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[1]", "2017/07/16 22:59:39", rec[idx].timestamp1[1]);
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[2]", "1817/11/06 13:50:31", rec[idx].timestamp1[2]);
+		end
+	end
+	function rec_float4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float4.getSize()", 4, rec[idx].float4.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[1]", 14.99 as smallfloat, rec[idx].float4[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[2]", 15.99 as smallfloat, rec[idx].float4[2]);
+		end
+	end
+	function rec_float8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float8.getSize()", 4, rec[idx].float8.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[1]", 16.99, rec[idx].float8[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[2]", 17.99, rec[idx].float8[2]);
+		end
+	end
+	function rec_recTest(){@Test {}}
+		for(idx int from 1 to 2)
+			recTest(rec[idx].rec, "rec[" + idx + "].rec");
+		end
+	end
+	function rec_recATest(){@Test {}}
+		for(idx1 int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx1 + "]recA.getSize()", 4, rec[idx1].recA.getSize());
+			for(idx2 int from 1 to 2)
+				recTest(rec[idx1].recA[idx2], "rec[" + idx1 + "].recA[" + idx2 + "]");
+			end
+		end
+	end
+	private function recTest(rec_rec Handler2 in, name String in)
+        LogResult.assertStringEqual("Fail " + name + ".char20", "abcdYYYYY", rec_rec.char20);
+        LogResult.assertStringEqual("Fail " + name + ".unicode20", "xyz ZZZZZZZZZZ", rec_rec.unicode20);
+        LogResult.assertStringEqual("Fail " + name + ".lchar20", "defgYYYYY", rec_rec.lchar20);
+        LogResult.assertStringEqual("Fail " + name + ".lunicode20", "abc ZZZZZZZZZZ", rec_rec.lunicode20);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2sign", 99, rec_rec.bin2sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4sign", 1000, rec_rec.bin4sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin8sign", 10001, rec_rec.bin8sign);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec112", 1043.67, rec_rec.dec112);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec15", 1012, rec_rec.dec15);
+        LogResult.assertDecimalEqual("Fail " + name + ".num6", 10003, rec_rec.num6);
+        LogResult.assertDecimalEqual("Fail " + name + ".num103", 10009.61, rec_rec.num103);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2", 104, rec_rec.bin2);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4", 1005, rec_rec.bin4);
+        LogResult.assertDateEqual("Fail " + name + ".date1", "11/29/2016", rec_rec.date1);
+        LogResult.assertDateEqual("Fail " + name + ".date2", "10/24/2002", rec_rec.date2);
+        LogResult.assertDateEqual("Fail " + name + ".date3", "09/08/1927", rec_rec.date3);
+        LogResult.assertTimestampEqual("Fail " + name + ".timestamp1", "2017/07/16 22:59:39", rec_rec.timestamp1);
+        LogResult.assertFloatEqual("Fail " + name + ".float8", 9.99, rec_rec.float8);
+        LogResult.assertFloatEqual("Fail " + name + ".float4", 8.99 as smallfloat, rec_rec.float4);
+	end
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/arrays/Handler3Fields.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/arrays/Handler3Fields.egl
new file mode 100644
index 0000000..2f245e5
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/arrays/Handler3Fields.egl
@@ -0,0 +1,253 @@
+package server.test.handlers.arrays;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.programs.ComplexTypeArrays;
+import server.host.programs.data.handlers.Handler13;
+import server.host.programs.data.handlers.Handler3;
+
+// basic library
+library Handler3Fields
+	
+	rec Handler13[];
+	function test1(){@Test}
+		rec = new Handler13[0];
+		rec.appendElement(createHandler13());
+		rec.appendElement(createHandler13());
+		try
+        	LogResult.logStdOut("call ComplexTypeArrays.primitiveHostProgram3");
+			validCount int;
+			ComplexTypeArrays.primitiveHostProgram13(rec, validCount);
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	private function createHandler13()returns(Handler13)
+		r Handler13{
+					rec = createHandler3(),
+					char20 = ["abcd", "EFG"], 
+					unicode20 = ["xyz", "1234"], 
+					lchar20 = ["ABCD", "efg"], 
+					lunicode20 = ["XYZ", "4321"], 
+					bin2sign = [1,2],
+					bin4sign = [3,4],
+					bin8sign = [4,5],
+					dec112 = [45.67, 64.97],
+					dec15 = [6,7],
+					num6 = [8,9],
+					num103 = [11.61, 56.72],
+					bin2 = [10,11],
+					bin4  = [12,13],
+					date1 = ["06/24/2011" ,"03/12/1011"],
+					date2 = ["05/19/1997", "01/02/1947"],
+					date3 = ["04/03/1922", "07/24/1822"],
+					timestamp1 = ["2012/02/11 17:54:34", "1812/06/01 08:45:26"],
+					float4 = [14,15],
+					float8 = [16,17],
+					recA = new Handler3[0]
+		};
+		r.recA.appendElement(createHandler3());  
+		r.recA.appendElement(createHandler3());  
+		return(r);
+	end
+	private function createHandler3()returns(Handler3)
+		return(new Handler3{
+							char20 = "abcd", 
+							unicode20 = "xyz", 
+							lchar20 = "defg",
+							lunicode20 = "abc", 
+							bin2sign = 1,
+							bin4sign = 2,
+							bin8sign = 3,
+							dec112 = 45.67,
+							dec15 = 14,
+							num6 = 5,
+							num103 = 11.61,
+							bin2 = 6,
+							bin4  = 7,
+							date1 = "06/24/2011",
+							date2 = "05/19/1997",
+							date3 = "04/03/1922",
+							time1 = "17:54:34",
+							time2 = "07:14:03",
+							time3 = "01:45:43",
+							timestamp1 = "2012/02/11 17:54:34",
+							float4 = 8,
+							float8 = 9
+					});
+	end
+	function recsTest(){@Test {}}
+        LogResult.assertBigIntEqual("Fail rec.getSize()", 2, rec.getSize());
+	end
+	function rec_char20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "].char20.getSize()", 2, rec[idx].char20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[1]", "abcdYYYYY           ", rec[idx].char20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[2]", "EFG YYYYY           ", rec[idx].char20[2]);
+	    end
+	end
+	function rec_unicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "]unicode20.getSize()", 2, rec[idx].unicode20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[1]", "xyz ZZZZZZZZZZ      ", rec[idx].unicode20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[2]", "1234ZZZZZZZZZZ      ", rec[idx].unicode20[2]); 
+		end
+	end
+	function lchar20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lchar20.getSize()", 2, rec[idx].lchar20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[1]", "ABCDYYYYY           ", rec[idx].lchar20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[2]", "efg YYYYY           ", rec[idx].lchar20[2]);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lunicode20.getSize()", 2, rec[idx].lunicode20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[1]", "XYZ ZZZZZZZZZZ      ", rec[idx].lunicode20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[2]", "4321ZZZZZZZZZZ      ", rec[idx].lunicode20[2]);
+		end
+	end
+	function rec_bin2signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign.getSize()", 2, rec[idx].bin2sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[1]", 99, rec[idx].bin2sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[2]", 100, rec[idx].bin2sign[2]);
+		end
+	end
+	function rec_bin4signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign.getSize()", 2, rec[idx].bin4sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[1]", 1001, rec[idx].bin4sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[2]", 1002, rec[idx].bin4sign[2]);
+		end
+	end
+	function rec_bin8signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign.getSize()", 2, rec[idx].bin8sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[1]", 10002, rec[idx].bin8sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[2]", 10003, rec[idx].bin8sign[2]);
+		end
+	end
+	function rec_dec112Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec112.getSize()", 2, rec[idx].dec112.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec112[1]", 1043.67, rec[idx].dec112[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec112[2]", 1062.97, rec[idx].dec112[2]);
+		end
+	end
+	function rec_dec15Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec15.getSize()", 2, rec[idx].dec15.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec15[1]", 1004, rec[idx].dec15[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec15[2]", 1005, rec[idx].dec15[2]);
+		end
+	end
+	function num6Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num6.getSize()", 2, rec[idx].num6.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num6[1]", 10006, rec[idx].num6[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num6[2]", 10007, rec[idx].num6[2]);
+		end
+	end
+	function rec_num103Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num103.getSize()", 2, rec[idx].num103.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num103[1]", 10009.61, rec[idx].num103[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num103[2]", 10054.72, rec[idx].num103[2]);
+		end
+	end
+	function rec_bin2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2.getSize()", 2, rec[idx].bin2.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[1]", 108, rec[idx].bin2[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[2]", 109, rec[idx].bin2[2]);
+		end
+	end
+
+	function rec_bin4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4.getSize()", 2, rec[idx].bin4.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[1]", 1010, rec[idx].bin4[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[2]", 1011, rec[idx].bin4[2]);
+		end
+	end
+	function rec_date1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date1.getSize()", 2, rec[idx].date1.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[1]", "11/29/2016", rec[idx].date1[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[2]", "08/17/1016", rec[idx].date1[2]);
+		end
+	end
+	function rec_date2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date2.getSize()", 2, rec[idx].date2.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[1]", "10/24/2002", rec[idx].date2[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[2]", "06/07/1952", rec[idx].date2[2]);
+		end
+	end
+
+	function rec_date3Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date3.getSize()", 2, rec[idx].date3.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[1]", "09/08/1927", rec[idx].date3[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[2]", "12/29/1827", rec[idx].date3[2]);
+		end
+	end
+	function rec_timestamp1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]timestamp1.getSize()", 2, rec[idx].timestamp1.getSize());
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[1]", "2017/07/16 22:59:39", rec[idx].timestamp1[1]);
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[2]", "1817/11/06 13:50:31", rec[idx].timestamp1[2]);
+		end
+	end
+	function rec_float4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float4.getSize()", 2, rec[idx].float4.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[1]", 14.99 as smallfloat, rec[idx].float4[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[2]", 15.99 as smallfloat, rec[idx].float4[2]);
+		end
+	end
+	function rec_float8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float8.getSize()", 2, rec[idx].float8.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[1]", 16.99, rec[idx].float8[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[2]", 17.99, rec[idx].float8[2]);
+		end
+	end
+	function rec_recTest(){@Test {}}
+		for(idx int from 1 to 2)
+			recTest(rec[idx].rec, "rec[" + idx + "].rec");
+		end
+	end
+	function rec_recATest(){@Test {}}
+		for(idx1 int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx1 + "]recA.getSize()", 2, rec[idx1].recA.getSize());
+			for(idx2 int from 1 to 2)
+				recTest(rec[idx1].recA[idx2], "rec[" + idx1 + "].recA[" + idx2 + "]");
+			end
+		end
+	end
+	private function recTest(rec_rec Handler3 in, name String in)
+        LogResult.assertStringEqual("Fail " + name + ".char20", "abcdYYYYY           ", rec_rec.char20);
+        LogResult.assertStringEqual("Fail " + name + ".unicode20", "xyz ZZZZZZZZZZ      ", rec_rec.unicode20);
+        LogResult.assertStringEqual("Fail " + name + ".lchar20", "defgYYYYY           ", rec_rec.lchar20);
+        LogResult.assertStringEqual("Fail " + name + ".lunicode20", "abc ZZZZZZZZZZ      ", rec_rec.lunicode20);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2sign", 99, rec_rec.bin2sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4sign", 1000, rec_rec.bin4sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin8sign", 10001, rec_rec.bin8sign);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec112", 1043.67, rec_rec.dec112);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec15", 1012, rec_rec.dec15);
+        LogResult.assertDecimalEqual("Fail " + name + ".num6", 10003, rec_rec.num6);
+        LogResult.assertDecimalEqual("Fail " + name + ".num103", 10009.61, rec_rec.num103);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2", 104, rec_rec.bin2);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4", 1005, rec_rec.bin4);
+        LogResult.assertDateEqual("Fail " + name + ".date1", "11/29/2016", rec_rec.date1);
+        LogResult.assertDateEqual("Fail " + name + ".date2", "10/24/2002", rec_rec.date2);
+        LogResult.assertDateEqual("Fail " + name + ".date3", "09/08/1927", rec_rec.date3);
+        LogResult.assertTimestampEqual("Fail " + name + ".timestamp1", "2017/07/16 22:59:39", rec_rec.timestamp1);
+        LogResult.assertFloatEqual("Fail " + name + ".float8", 9.99, rec_rec.float8);
+        LogResult.assertFloatEqual("Fail " + name + ".float4", 8.99 as smallfloat, rec_rec.float4);
+	end
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/arrays/HandlerFields.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/arrays/HandlerFields.egl
new file mode 100644
index 0000000..6a8ee66
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/handlers/arrays/HandlerFields.egl
@@ -0,0 +1,254 @@
+package server.test.handlers.arrays;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.programs.ComplexTypeArrays;
+import server.host.programs.data.handlers.Handler1;
+import server.host.programs.data.handlers.Handler11;
+
+
+// basic library
+library HandlerFields
+	
+	rec Handler11[];
+	function test1(){@Test}
+		rec = new Handler11[0];
+		rec.appendElement(createHandler11());
+		rec.appendElement(createHandler11());
+		try
+        	LogResult.logStdOut("call ComplexTypeArrays.primitiveHostProgram");
+			validCount int;
+			ComplexTypeArrays.primitiveHostProgram11(rec, validCount);
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	private function createHandler11()returns(Handler11)
+		r Handler11{
+					rec = createHandler1(),
+					char20 = ["abcd", "EFG"], 
+					unicode20 = ["xyz", "1234"], 
+					lchar20 = ["ABCD", "efg"], 
+					lunicode20 = ["XYZ", "4321"], 
+					bin2sign = [1,2],
+					bin4sign = [3,4],
+					bin8sign = [4,5],
+					dec112 = [45.67, 64.97],
+					dec15 = [6,7],
+					num6 = [8,9],
+					num103 = [11.61, 56.72],
+					bin2 = [10,11],
+					bin4  = [12,13],
+					date1 = ["06/24/2011" ,"03/12/1011"],
+					date2 = ["05/19/1997", "01/02/1947"],
+					date3 = ["04/03/1922", "07/24/1822"],
+					timestamp1 = ["2012/02/11 17:54:34", "1812/06/01 08:45:26"],
+					float4 = [14,15],
+					float8 = [16,17],
+					recA = new Handler1[0]
+		};
+		r.recA.appendElement(createHandler1());  
+		r.recA.appendElement(createHandler1());  
+		return(r);
+	end
+	private function createHandler1()returns(Handler1)
+		return(new Handler1{
+							char20 = "abcd", 
+							unicode20 = "xyz", 
+							lchar20 = "defg",
+							lunicode20 = "abc", 
+							bin2sign = 1,
+							bin4sign = 2,
+							bin8sign = 3,
+							dec112 = 45.67,
+							dec15 = 14,
+							num6 = 5,
+							num103 = 11.61,
+							bin2 = 6,
+							bin4  = 7,
+							date1 = "06/24/2011",
+							date2 = "05/19/1997",
+							date3 = "04/03/1922",
+							time1 = "17:54:34",
+							time2 = "07:14:03",
+							time3 = "01:45:43",
+							timestamp1 = "2012/02/11 17:54:34",
+							float4 = 8,
+							float8 = 9
+					});
+	end
+	function recsTest(){@Test {}}
+        LogResult.assertBigIntEqual("Fail rec.getSize()", 5, rec.getSize());
+	end
+	function rec_char20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "].char20.getSize()", 4, rec[idx].char20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[1]", "abcdYYYYY", rec[idx].char20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[2]", "EFG YYYYY", rec[idx].char20[2]);
+	    end
+	end
+	function rec_unicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "]unicode20.getSize()", 4, rec[idx].unicode20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[1]", "xyz ZZZZZZZZZZ", rec[idx].unicode20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[2]", "1234ZZZZZZZZZZ", rec[idx].unicode20[2]); 
+		end
+	end
+	function lchar20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lchar20.getSize()", 4, rec[idx].lchar20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[1]", "ABCDYYYYY", rec[idx].lchar20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[2]", "efg YYYYY", rec[idx].lchar20[2]);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lunicode20.getSize()", 4, rec[idx].lunicode20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[1]", "XYZ ZZZZZZZZZZ", rec[idx].lunicode20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[2]", "4321ZZZZZZZZZZ", rec[idx].lunicode20[2]);
+		end
+	end
+	function rec_bin2signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign.getSize()", 4, rec[idx].bin2sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[1]", 99, rec[idx].bin2sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[2]", 100, rec[idx].bin2sign[2]);
+		end
+	end
+	function rec_bin4signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign.getSize()", 4, rec[idx].bin4sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[1]", 1001, rec[idx].bin4sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[2]", 1002, rec[idx].bin4sign[2]);
+		end
+	end
+	function rec_bin8signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign.getSize()", 4, rec[idx].bin8sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[1]", 10002, rec[idx].bin8sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[2]", 10003, rec[idx].bin8sign[2]);
+		end
+	end
+	function rec_dec112Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec112.getSize()", 4, rec[idx].dec112.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec112[1]", 1043.67, rec[idx].dec112[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec112[2]", 1062.97, rec[idx].dec112[2]);
+		end
+	end
+	function rec_dec15Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec15.getSize()", 4, rec[idx].dec15.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec15[1]", 1004, rec[idx].dec15[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec15[2]", 1005, rec[idx].dec15[2]);
+		end
+	end
+	function num6Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num6.getSize()", 4, rec[idx].num6.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num6[1]", 10006, rec[idx].num6[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num6[2]", 10007, rec[idx].num6[2]);
+		end
+	end
+	function rec_num103Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num103.getSize()", 4, rec[idx].num103.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num103[1]", 10009.61, rec[idx].num103[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num103[2]", 10054.72, rec[idx].num103[2]);
+		end
+	end
+	function rec_bin2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2.getSize()", 4, rec[idx].bin2.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[1]", 108, rec[idx].bin2[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[2]", 109, rec[idx].bin2[2]);
+		end
+	end
+
+	function rec_bin4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4.getSize()", 4, rec[idx].bin4.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[1]", 1010, rec[idx].bin4[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[2]", 1011, rec[idx].bin4[2]);
+		end
+	end
+	function rec_date1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date1.getSize()", 4, rec[idx].date1.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[1]", "11/29/2016", rec[idx].date1[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[2]", "08/17/1016", rec[idx].date1[2]);
+		end
+	end
+	function rec_date2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date2.getSize()", 4, rec[idx].date2.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[1]", "10/24/2002", rec[idx].date2[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[2]", "06/07/1952", rec[idx].date2[2]);
+		end
+	end
+
+	function rec_date3Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date3.getSize()", 4, rec[idx].date3.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[1]", "09/08/1927", rec[idx].date3[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[2]", "12/29/1827", rec[idx].date3[2]);
+		end
+	end
+	function rec_timestamp1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]timestamp1.getSize()", 4, rec[idx].timestamp1.getSize());
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[1]", "2017/07/16 22:59:39", rec[idx].timestamp1[1]);
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[2]", "1817/11/06 13:50:31", rec[idx].timestamp1[2]);
+		end
+	end
+	function rec_float4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float4.getSize()", 4, rec[idx].float4.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[1]", 14.99 as smallfloat, rec[idx].float4[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[2]", 15.99 as smallfloat, rec[idx].float4[2]);
+		end
+	end
+	function rec_float8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float8.getSize()", 4, rec[idx].float8.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[1]", 16.99, rec[idx].float8[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[2]", 17.99, rec[idx].float8[2]);
+		end
+	end
+	function rec_recTest(){@Test {}}
+		for(idx int from 1 to 2)
+			recTest(rec[idx].rec, "rec[" + idx + "].rec");
+		end
+	end
+	function rec_recATest(){@Test {}}
+		for(idx1 int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx1 + "]recA.getSize()", 4, rec[idx1].recA.getSize());
+			for(idx2 int from 1 to 2)
+				recTest(rec[idx1].recA[idx2], "rec[" + idx1 + "].recA[" + idx2 + "]");
+			end
+		end
+	end
+	private function recTest(rec_rec Handler1 in, name String in)
+        LogResult.assertStringEqual("Fail " + name + ".char20", "abcdYYYYY", rec_rec.char20);
+        LogResult.assertStringEqual("Fail " + name + ".unicode20", "xyz ZZZZZZZZZZ", rec_rec.unicode20);
+        LogResult.assertStringEqual("Fail " + name + ".lchar20", "defgYYYYY", rec_rec.lchar20);
+        LogResult.assertStringEqual("Fail " + name + ".lunicode20", "abc ZZZZZZZZZZ", rec_rec.lunicode20);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2sign", 99, rec_rec.bin2sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4sign", 1000, rec_rec.bin4sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin8sign", 10001, rec_rec.bin8sign);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec112", 1043.67, rec_rec.dec112);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec15", 1012, rec_rec.dec15);
+        LogResult.assertDecimalEqual("Fail " + name + ".num6", 10003, rec_rec.num6);
+        LogResult.assertDecimalEqual("Fail " + name + ".num103", 10009.61, rec_rec.num103);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2", 104, rec_rec.bin2);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4", 1005, rec_rec.bin4);
+        LogResult.assertDateEqual("Fail " + name + ".date1", "11/29/2016", rec_rec.date1);
+        LogResult.assertDateEqual("Fail " + name + ".date2", "10/24/2002", rec_rec.date2);
+        LogResult.assertDateEqual("Fail " + name + ".date3", "09/08/1927", rec_rec.date3);
+        LogResult.assertTimestampEqual("Fail " + name + ".timestamp1", "2017/07/16 22:59:39", rec_rec.timestamp1);
+        LogResult.assertFloatEqual("Fail " + name + ".float8", 9.99, rec_rec.float8);
+        LogResult.assertFloatEqual("Fail " + name + ".float4", 8.99 as smallfloat, rec_rec.float4);
+	end
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/overrides/EglddTest.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/overrides/EglddTest.egl
new file mode 100644
index 0000000..f2d3bdd
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/overrides/EglddTest.egl
@@ -0,0 +1,58 @@
+package server.test.overrides;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import server.host.programs.EDTOver;
+
+// basic library
+library EglddTest
+	
+	function test1(){@Test {}}
+    	unicode20 string = "XYZAS";
+		try
+        	LogResult.logStdOut("Test use egldd encoding");
+  		  	call EDTOver.PEUTF(unicode20); 
+ 			LogResult.assertTrue1(true);
+            LogResult.assertStringEqual("Fail unicode20", "XYZAZZZZZZZZZZ", unicode20);
+ 		onException(exception AnyException)
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	
+	function test2(){@Test {}}
+    	char20 string = "abcde";
+		try
+        	LogResult.logStdOut("Test override egldd encoding");
+  		  	call EDTOver.PE037(char20); 
+ 			LogResult.assertTrue1(true);
+            LogResult.assertStringEqual("Fail char20", "abcdeYYYYY", char20);
+ 		onException(exception AnyException)
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	
+	function test3(){@Test {}}
+    	date1 date = "05/19/1997";
+		try
+        	LogResult.logStdOut("Test use egldd date format");
+  		  	call EDTOver.PDTEUR(date1);
+ 			LogResult.assertTrue1(true);
+            LogResult.assertDateEqual("Fail date1", "10/24/2002", date1);
+ 		onException(exception AnyException)
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	
+	function test4(){@Test {}}
+    	date1 date = "06/20/1497";
+		try
+        	LogResult.logStdOut("Test override egldd date format");
+  		  	call EDTOver.PDTUSA(date1);
+ 			LogResult.assertTrue1(true);
+            LogResult.assertDateEqual("Fail date1", "11/25/1502", date1);
+ 		onException(exception AnyException)
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/Parameters.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/Parameters.egl
new file mode 100644
index 0000000..2dfac7c
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/Parameters.egl
@@ -0,0 +1,201 @@
+package server.test.primitive;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import server.host.programs.Primitive;
+
+// basic library
+library Parameters
+	
+	char20 string; 
+	lchar20 string(20); 
+	unicode20 string; 
+	lunicode20 string(20); 
+	bin2sign smallint;
+	bin4sign int;
+	bin8sign bigint;
+	dec112 decimal(11,2);
+	dec15 decimal(15);
+	num6 decimal(6);
+	num103 decimal(10,3);
+	bin2 int;
+	bin4 bigint;
+	date1 date;
+	date2 date;
+	date3 date;
+	time1 time;
+	time2 time;
+	time3 time;
+	timestamp1 timestamp("yyyyMMddHHmmss");
+	float4 smallfloat;
+	float8 float;
+	testParameters boolean = true;
+	function test1(){@Test}
+		char20 = "abcd"; 
+		lchar20 = "defg"; 
+		unicode20 = "xyz"; 
+		lunicode20 = "abc"; 
+		bin2sign = 1;
+		bin4sign = 2;
+		bin8sign = 3;
+		dec112 = 45.67;
+		dec15 = 14;
+		num6 = 5;
+		num103 = 11.61;
+		bin2 = 6;
+		bin4  = 7;
+		date1 = "06/24/2011";
+		date2 = "05/19/1997";
+		date3 = "04/03/1922";
+		time1 = "17:54:34";
+		time2 = "07:14:03";
+		time3 = "01:45:43";
+		timestamp1 = "2012/02/11 17:54:34";
+		float4 = 8;
+		float8 = 9;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgram");
+			Primitive.primitiveHostProgram(char20, lchar20, unicode20, lunicode20, bin2sign, bin4sign, bin8sign, dec112, dec15, num6, num103, bin2, bin4, date1, date2, date3, time1, time2, time3, timestamp1, float4, float8);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing char20 value");
+            LogResult.assertStringEqual("Fail char20", "abcdYYYYY", char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing lchar20 value");
+            LogResult.assertStringEqual("Fail lchar20", "defgYYYYY", lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing unicode20 value");
+            LogResult.assertStringEqual("Fail unicode20", "xyz ZZZZZZZZZZ", unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing lunicode20 value");
+            LogResult.assertStringEqual("Fail lunicode20", "abc ZZZZZZZZZZ", lunicode20);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin2sign value");
+            LogResult.assertBigIntEqual("Fail bin2sign", 99, bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin4sign value");
+            LogResult.assertBigIntEqual("Fail bin4sign", 1000, bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin8sign value");
+            LogResult.assertBigIntEqual("Fail bin8sign", 10001, bin8sign);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing dec112 value");
+            LogResult.assertDecimalEqual("Fail dec112", 1043.67, dec112);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing dec15 value");
+            LogResult.assertDecimalEqual("Fail dec15", 1012, dec15);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing num6 value");
+            LogResult.assertDecimalEqual("Fail num6", 10003, num6);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing num103 value");
+            LogResult.assertDecimalEqual("Fail num103", 10009.61, num103);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin2 value");
+            LogResult.assertBigIntEqual("Fail bin2", 104, bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin4 value");
+            LogResult.assertBigIntEqual("Fail bin4", 1005, bin4);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date1 value");
+            LogResult.assertDateEqual("Fail date1", "11/29/2016", date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date2 value");
+            LogResult.assertDateEqual("Fail date2", "10/24/2002", date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date3 value");
+            LogResult.assertDateEqual("Fail date3", "09/08/1927", date3);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time1 value");
+            LogResult.assertTimeEqual("Fail time1", "22:59:39", time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time2 value");
+            LogResult.assertTimeEqual("Fail time2", "12:19:08", time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time3 value");
+            LogResult.assertTimeEqual("Fail time3", "06:50:48", time3);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing timestamp1 value");
+            LogResult.assertTimestampEqual("Fail timestamp1", "2017/07/16 22:59:39", timestamp1);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing float4 value");
+            LogResult.assertFloatEqual("Fail float4", 8.99 as smallfloat, float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing float8 value");
+            LogResult.assertFloatEqual("Fail float8", 9.99, float8);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/Parameters2.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/Parameters2.egl
new file mode 100644
index 0000000..13ab557
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/Parameters2.egl
@@ -0,0 +1,201 @@
+package server.test.primitive;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import server.host.programs.Primitive;
+
+// basic library
+library Parameters2
+	
+	char20 string; 
+	lchar20 string(20); 
+	unicode20 string; 
+	lunicode20 string(20); 
+	bin2sign smallint;
+	bin4sign int;
+	bin8sign bigint;
+	dec112 decimal(11,2);
+	dec15 decimal(15);
+	num6 decimal(6);
+	num103 decimal(10,3);
+	bin2 int;
+	bin4 bigint;
+	date1 date;
+	date2 date;
+	date3 date;
+	time1 time;
+	time2 time;
+	time3 time;
+	timestamp1 timestamp("yyyyMMddHHmmss");
+	float4 smallfloat;
+	float8 float;
+	testParameters boolean = true;
+	function test1(){@Test}
+		char20 = "abcd"; 
+		lchar20 = "defg"; 
+		unicode20 = "xyz"; 
+		lunicode20 = "abc"; 
+		bin2sign = 1;
+		bin4sign = 2;
+		bin8sign = 3;
+		dec112 = 45.67;
+		dec15 = 14;
+		num6 = 5;
+		num103 = 11.61;
+		bin2 = 6;
+		bin4  = 7;
+		date1 = "06/24/2011";
+		date2 = "05/19/1997";
+		date3 = "04/03/1922";
+		time1 = "17:54:34";
+		time2 = "07:14:03";
+		time3 = "01:45:43";
+		timestamp1 = "2012/02/11 17:54:34";
+		float4 = 8;
+		float8 = 9;
+		try
+        	LogResult.logStdOut("call Primitive.primitiveHostProgram2");
+			Primitive.primitiveHostProgram2(char20, lchar20, unicode20, lunicode20, bin2sign, bin4sign, bin8sign, dec112, dec15, num6, num103, bin2, bin4, date1, date2, date3, time1, time2, time3, timestamp1, float4, float8);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing char20 value");
+            LogResult.assertStringEqual("Fail char20", "abcdYYYYY", char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing lchar20 value");
+            LogResult.assertStringEqual("Fail lchar20", "defgYYYYY", lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing unicode20 value");
+            LogResult.assertStringEqual("Fail unicode20", "xyz ZZZZZZZZZZ", unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing lunicode20 value");
+            LogResult.assertStringEqual("Fail lunicode20", "abc ZZZZZZZZZZ", lunicode20);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin2sign value");
+            LogResult.assertBigIntEqual("Fail bin2sign", 99, bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin4sign value");
+            LogResult.assertBigIntEqual("Fail bin4sign", 1000, bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin8sign value");
+            LogResult.assertBigIntEqual("Fail bin8sign", 10001, bin8sign);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing dec112 value");
+            LogResult.assertDecimalEqual("Fail dec112", 1043.67, dec112);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing dec15 value");
+            LogResult.assertDecimalEqual("Fail dec15", 1012, dec15);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing num6 value");
+            LogResult.assertDecimalEqual("Fail num6", 10003, num6);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing num103 value");
+            LogResult.assertDecimalEqual("Fail num103", 10009.61, num103);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin2 value");
+            LogResult.assertBigIntEqual("Fail bin2", 104, bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin4 value");
+            LogResult.assertBigIntEqual("Fail bin4", 1005, bin4);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date1 value");
+            LogResult.assertDateEqual("Fail date1", "11/29/2016", date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date2 value");
+            LogResult.assertDateEqual("Fail date2", "10/24/2002", date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date3 value");
+            LogResult.assertDateEqual("Fail date3", "09/08/1927", date3);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time1 value");
+            LogResult.assertTimeEqual("Fail time1", "22:59:39", time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time2 value");
+            LogResult.assertTimeEqual("Fail time2", "12:19:08", time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time3 value");
+            LogResult.assertTimeEqual("Fail time3", "06:50:48", time3);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing timestamp1 value");
+            LogResult.assertTimestampEqual("Fail timestamp1", "2017/07/16 22:59:39", timestamp1);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing float4 value");
+            LogResult.assertFloatEqual("Fail float4", 8.99 as smallfloat, float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing float8 value");
+            LogResult.assertFloatEqual("Fail float8", 9.99, float8);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/Parameters3.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/Parameters3.egl
new file mode 100644
index 0000000..236fb97
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/Parameters3.egl
@@ -0,0 +1,201 @@
+package server.test.primitive;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import server.host.programs.Primitive;
+
+// basic library
+library Parameters3
+	
+	char20 string; 
+	lchar20 string(20); 
+	unicode20 string; 
+	lunicode20 string(20); 
+	bin2sign smallint;
+	bin4sign int;
+	bin8sign bigint;
+	dec112 decimal(11,2);
+	dec15 decimal(15);
+	num6 decimal(6);
+	num103 decimal(10,3);
+	bin2 int;
+	bin4 bigint;
+	date1 date;
+	date2 date;
+	date3 date;
+	time1 time;
+	time2 time;
+	time3 time;
+	timestamp1 timestamp("yyyyMMddHHmmss");
+	float4 smallfloat;
+	float8 float;
+	testParameters boolean = true;
+	function test1(){@Test}
+		char20 = "abcd"; 
+		lchar20 = "defg"; 
+		unicode20 = "xyz"; 
+		lunicode20 = "abc"; 
+		bin2sign = 1;
+		bin4sign = 2;
+		bin8sign = 3;
+		dec112 = 45.67;
+		dec15 = 14;
+		num6 = 5;
+		num103 = 11.61;
+		bin2 = 6;
+		bin4  = 7;
+		date1 = "06/24/2011";
+		date2 = "05/19/1997";
+		date3 = "04/03/1922";
+		time1 = "17:54:34";
+		time2 = "07:14:03";
+		time3 = "01:45:43";
+		timestamp1 = "2012/02/11 17:54:34";
+		float4 = 8;
+		float8 = 9;
+		try
+        	LogResult.logStdOut("call Primitive.primitiveHostProgram3");
+			Primitive.primitiveHostProgram3(char20, lchar20, unicode20, lunicode20, bin2sign, bin4sign, bin8sign, dec112, dec15, num6, num103, bin2, bin4, date1, date2, date3, time1, time2, time3, timestamp1, float4, float8);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing char20 value");
+            LogResult.assertStringEqual("Fail char20", "abcdYYYYY           ", char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing lchar20 value");
+            LogResult.assertStringEqual("Fail lchar20", "defgYYYYY           ", lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing unicode20 value");
+            LogResult.assertStringEqual("Fail unicode20", "xyz ZZZZZZZZZZ      ", unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing lunicode20 value");
+            LogResult.assertStringEqual("Fail lunicode20", "abc ZZZZZZZZZZ      ", lunicode20);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin2sign value");
+            LogResult.assertBigIntEqual("Fail bin2sign", 99, bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin4sign value");
+            LogResult.assertBigIntEqual("Fail bin4sign", 1000, bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin8sign value");
+            LogResult.assertBigIntEqual("Fail bin8sign", 10001, bin8sign);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing dec112 value");
+            LogResult.assertDecimalEqual("Fail dec112", 1043.67, dec112);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing dec15 value");
+            LogResult.assertDecimalEqual("Fail dec15", 1012, dec15);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing num6 value");
+            LogResult.assertDecimalEqual("Fail num6", 10003, num6);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing num103 value");
+            LogResult.assertDecimalEqual("Fail num103", 10009.61, num103);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin2 value");
+            LogResult.assertBigIntEqual("Fail bin2", 104, bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin4 value");
+            LogResult.assertBigIntEqual("Fail bin4", 1005, bin4);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date1 value");
+            LogResult.assertDateEqual("Fail date1", "11/29/2016", date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date2 value");
+            LogResult.assertDateEqual("Fail date2", "10/24/2002", date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date3 value");
+            LogResult.assertDateEqual("Fail date3", "09/08/1927", date3);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time1 value");
+            LogResult.assertTimeEqual("Fail time1", "22:59:39", time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time2 value");
+            LogResult.assertTimeEqual("Fail time2", "12:19:08", time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time3 value");
+            LogResult.assertTimeEqual("Fail time3", "06:50:48", time3);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing timestamp1 value");
+            LogResult.assertTimestampEqual("Fail timestamp1", "2017/07/16 22:59:39", timestamp1);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing float4 value");
+            LogResult.assertFloatEqual("Fail float4", 8.99 as smallfloat, float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing float8 value");
+            LogResult.assertFloatEqual("Fail float8", 9.99, float8);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/arrays/Parameters.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/arrays/Parameters.egl
new file mode 100644
index 0000000..7d5ae07
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/arrays/Parameters.egl
@@ -0,0 +1,227 @@
+package server.test.primitive.arrays;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.programs.PrimitiveArrays;
+import server.host.programs.primitive;
+
+// basic library
+library Parameters
+	
+	char20 string[]; 
+	lchar20 string(20)[]; 
+	unicode20 string[]; 
+	lunicode20 string(20)[]; 
+	bin2sign smallint[];
+	bin4sign int[];
+	bin8sign bigint[];
+	dec112 decimal(11,2)[];
+	dec15 decimal(15)[];
+	num6 decimal(6)[];
+	num103 decimal(10,3)[];
+	bin2 int[];
+	bin4 bigint[];
+	date1 date[];
+	date2 date[];
+	date3 date[];
+	time1 time[];
+	time2 time[];
+	time3 time[];
+	timestamp1 timestamp("yyyyMMddHHmmss")[];
+	float4 smallfloat[];
+	float8 float[];
+	testParameters boolean = true;
+	function test1(){@Test}
+		char20 = ["abcd", "EFG"]; 
+		lchar20 = ["ABCD", "efg"]; 
+		unicode20 = ["xyz", "1234"]; 
+		lunicode20 = ["XYZ", "4321"]; 
+		bin2sign = [1,2];
+		bin4sign = [3,4];
+		bin8sign = [4,5];
+		dec112 = [45.67, 64.97];
+		dec15 = [6,7];
+		num6 = [8,9];
+		num103 = [11.61, 56.72];
+		bin2 = [10,11];
+		bin4  = [12,13];
+		date1 = ["06/24/2011" ,"03/12/1011"];
+		date2 = ["05/19/1997", "01/02/1947"];
+		date3 = ["04/03/1922", "07/24/1822"];
+		time1 = ["06:24:11" ,"13:12:10"];
+		time2 = ["05:19:19", "11:02:47"];
+		time3 = ["04:03:22", "17:24:18"];
+		timestamp1 = ["2012/02/11 17:54:34", "1812/06/01 08:45:26"];
+		float4 = [14,15];
+		float8 = [16,17];
+		validCount int;
+		try
+	       	LogResult.logStdOut("call PrimitiveArrays.primitiveHostProgram");
+			PrimitiveArrays.primitiveHostProgram(char20, lchar20, unicode20, lunicode20, bin2sign, bin4sign, bin8sign, dec112, dec15, num6, num103, bin2, bin4, date1, date2, date3, time1, time2, time3, timestamp1, float4, float8, validCount);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail char20.getSize()", 4, char20.getSize());
+            LogResult.assertStringEqual("Fail char20[1]", "abcdYYYYY", char20[1]);
+            LogResult.assertStringEqual("Fail char20[2]", "EFG YYYYY", char20[2]);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail lchar20.getSize()", 4, lchar20.getSize());
+            LogResult.assertStringEqual("Fail lchar20[1]", "ABCDYYYYY", lchar20[1]);
+            LogResult.assertStringEqual("Fail lchar20[2]", "efg YYYYY", lchar20[2]);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail unicode20.getSize()", 4, unicode20.getSize());
+            LogResult.assertStringEqual("Fail unicode20[1]", "xyz ZZZZZZZZZZ", unicode20[1]);
+            LogResult.assertStringEqual("Fail unicode20[2]", "1234ZZZZZZZZZZ", unicode20[2]);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail lunicode20.getSize()", 4, lunicode20.getSize());
+            LogResult.assertStringEqual("Fail lunicode20[1]", "XYZ ZZZZZZZZZZ", lunicode20[1]);
+            LogResult.assertStringEqual("Fail lunicode20[2]", "4321ZZZZZZZZZZ", lunicode20[2]);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin2sign.getSize()", 4, bin2sign.getSize());
+            LogResult.assertBigIntEqual("Fail bin2sign[1]", 99, bin2sign[1]);
+            LogResult.assertBigIntEqual("Fail bin2sign[2]", 100, bin2sign[2]);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin4sign.getSize()", 4, bin4sign.getSize());
+            LogResult.assertBigIntEqual("Fail bin4sign[1]", 1001, bin4sign[1]);
+            LogResult.assertBigIntEqual("Fail bin4sign[2]", 1002, bin4sign[2]);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin8sign.getSize()", 4, bin8sign.getSize());
+            LogResult.assertBigIntEqual("Fail bin8sign[1]", 10002, bin8sign[1]);
+            LogResult.assertBigIntEqual("Fail bin8sign[2]", 10003, bin8sign[2]);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail dec112.getSize()", 4, dec112.getSize());
+            LogResult.assertDecimalEqual("Fail dec112[1]", 1043.67, dec112[1]);
+            LogResult.assertDecimalEqual("Fail dec112[2]", 1062.97, dec112[2]);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail dec15.getSize()", 4, dec15.getSize());
+            LogResult.assertDecimalEqual("Fail dec15[1]", 1004, dec15[1]);
+            LogResult.assertDecimalEqual("Fail dec15[2]", 1005, dec15[2]);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail num6.getSize()", 4, num6.getSize());
+            LogResult.assertDecimalEqual("Fail num6[1]", 10006, num6[1]);
+            LogResult.assertDecimalEqual("Fail num6[2]", 10007, num6[2]);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail num103.getSize()", 4, num103.getSize());
+            LogResult.assertDecimalEqual("Fail num103[1]", 10009.61, num103[1]);
+            LogResult.assertDecimalEqual("Fail num103[2]", 10054.72, num103[2]);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin2.getSize()", 4, bin2.getSize());
+            LogResult.assertBigIntEqual("Fail bin2[1]", 108, bin2[1]);
+            LogResult.assertBigIntEqual("Fail bin2[2]", 109, bin2[2]);
+		end
+	end
+
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin4.getSize()", 4, bin4.getSize());
+            LogResult.assertBigIntEqual("Fail bin4[1]", 1010, bin4[1]);
+            LogResult.assertBigIntEqual("Fail bin4[2]", 1011, bin4[2]);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail date1.getSize()", 4, date1.getSize());
+            LogResult.assertDateEqual("Fail date1[1]", "11/29/2016", date1[1]);
+            LogResult.assertDateEqual("Fail date1[2]", "08/17/1016", date1[2]);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail date2.getSize()", 4, date2.getSize());
+            LogResult.assertDateEqual("Fail date2[1]", "10/24/2002", date2[1]);
+            LogResult.assertDateEqual("Fail date2[2]", "06/07/1952", date2[2]);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail date3.getSize()", 4, date3.getSize());
+            LogResult.assertDateEqual("Fail date3[1]", "09/08/1927", date3[1]);
+            LogResult.assertDateEqual("Fail date3[2]", "12/29/1827", date3[2]);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail time1.getSize()", 4, time1.getSize());
+            LogResult.assertTimeEqual("Fail time1[1]", "11:29:16", time1[1]);
+            LogResult.assertTimeEqual("Fail time1[2]", "18:17:15", time1[2]);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail time2.getSize()", 4, time2.getSize());
+            LogResult.assertTimeEqual("Fail time2[1]", "10:24:24", time2[1]);
+            LogResult.assertTimeEqual("Fail time2[2]", "16:07:52", time2[2]);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail time3.getSize()", 4, time3.getSize());
+            LogResult.assertTimeEqual("Fail time3[1]", "09:08:27", time3[1]);
+            LogResult.assertTimeEqual("Fail time3[2]", "22:29:23", time3[2]);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail timestamp1.getSize()", 4, timestamp1.getSize());
+            LogResult.assertTimestampEqual("Fail timestamp1[1]", "2017/07/16 22:59:39", timestamp1[1]);
+            LogResult.assertTimestampEqual("Fail timestamp1[2]", "1817/11/06 13:50:31", timestamp1[2]);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail float4.getSize()", 4, float4.getSize());
+            LogResult.assertFloatEqual("Fail float4[1]", 14.99 as smallfloat, float4[1]);
+            LogResult.assertFloatEqual("Fail float4[2]", 15.99 as smallfloat, float4[2]);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail float8.getSize()", 4, float8.getSize());
+            LogResult.assertFloatEqual("Fail float8[1]", 16.99, float8[1]);
+            LogResult.assertFloatEqual("Fail float8[2]", 17.99, float8[2]);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/arrays/Parameters2.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/arrays/Parameters2.egl
new file mode 100644
index 0000000..ac34f65
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/arrays/Parameters2.egl
@@ -0,0 +1,227 @@
+package server.test.primitive.arrays;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.programs.PrimitiveArrays;
+import server.host.programs.primitive;
+
+// basic library
+library Parameters2
+	
+	char20 string[]; 
+	lchar20 string(20)[]; 
+	unicode20 string[]; 
+	lunicode20 string(20)[]; 
+	bin2sign smallint[];
+	bin4sign int[];
+	bin8sign bigint[];
+	dec112 decimal(11,2)[];
+	dec15 decimal(15)[];
+	num6 decimal(6)[];
+	num103 decimal(10,3)[];
+	bin2 int[];
+	bin4 bigint[];
+	date1 date[];
+	date2 date[];
+	date3 date[];
+	time1 time[];
+	time2 time[];
+	time3 time[];
+	timestamp1 timestamp("yyyyMMddHHmmss")[];
+	float4 smallfloat[];
+	float8 float[];
+	testParameters boolean = true;
+	function test1(){@Test}
+		char20 = ["abcd", "EFG"]; 
+		lchar20 = ["ABCD", "efg"]; 
+		unicode20 = ["xyz", "1234"]; 
+		lunicode20 = ["XYZ", "4321"]; 
+		bin2sign = [1,2];
+		bin4sign = [3,4];
+		bin8sign = [4,5];
+		dec112 = [45.67, 64.97];
+		dec15 = [6,7];
+		num6 = [8,9];
+		num103 = [11.61, 56.72];
+		bin2 = [10,11];
+		bin4  = [12,13];
+		date1 = ["06/24/2011" ,"03/12/1011"];
+		date2 = ["05/19/1997", "01/02/1947"];
+		date3 = ["04/03/1922", "07/24/1822"];
+		time1 = ["06:24:11" ,"13:12:10"];
+		time2 = ["05:19:19", "11:02:47"];
+		time3 = ["04:03:22", "17:24:18"];
+		timestamp1 = ["2012/02/11 17:54:34", "1812/06/01 08:45:26"];
+		float4 = [14,15];
+		float8 = [16,17];
+		validCount int;
+		try
+	       	LogResult.logStdOut("call PrimitiveArrays.primitiveHostProgram2");
+			PrimitiveArrays.primitiveHostProgram2(char20, lchar20, unicode20, lunicode20, bin2sign, bin4sign, bin8sign, dec112, dec15, num6, num103, bin2, bin4, date1, date2, date3, time1, time2, time3, timestamp1, float4, float8, validCount);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail char20.getSize()", 4, char20.getSize());
+            LogResult.assertStringEqual("Fail char20[1]", "abcdYYYYY", char20[1]);
+            LogResult.assertStringEqual("Fail char20[2]", "EFG YYYYY", char20[2]);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail lchar20.getSize()", 4, lchar20.getSize());
+            LogResult.assertStringEqual("Fail lchar20[1]", "ABCDYYYYY", lchar20[1]);
+            LogResult.assertStringEqual("Fail lchar20[2]", "efg YYYYY", lchar20[2]);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail unicode20.getSize()", 4, unicode20.getSize());
+            LogResult.assertStringEqual("Fail unicode20[1]", "xyz ZZZZZZZZZZ", unicode20[1]);
+            LogResult.assertStringEqual("Fail unicode20[2]", "1234ZZZZZZZZZZ", unicode20[2]);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail lunicode20.getSize()", 4, lunicode20.getSize());
+            LogResult.assertStringEqual("Fail lunicode20[1]", "XYZ ZZZZZZZZZZ", lunicode20[1]);
+            LogResult.assertStringEqual("Fail lunicode20[2]", "4321ZZZZZZZZZZ", lunicode20[2]);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin2sign.getSize()", 4, bin2sign.getSize());
+            LogResult.assertBigIntEqual("Fail bin2sign[1]", 99, bin2sign[1]);
+            LogResult.assertBigIntEqual("Fail bin2sign[2]", 100, bin2sign[2]);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin4sign.getSize()", 4, bin4sign.getSize());
+            LogResult.assertBigIntEqual("Fail bin4sign[1]", 1001, bin4sign[1]);
+            LogResult.assertBigIntEqual("Fail bin4sign[2]", 1002, bin4sign[2]);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin8sign.getSize()", 4, bin8sign.getSize());
+            LogResult.assertBigIntEqual("Fail bin8sign[1]", 10002, bin8sign[1]);
+            LogResult.assertBigIntEqual("Fail bin8sign[2]", 10003, bin8sign[2]);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail dec112.getSize()", 4, dec112.getSize());
+            LogResult.assertDecimalEqual("Fail dec112[1]", 1043.67, dec112[1]);
+            LogResult.assertDecimalEqual("Fail dec112[2]", 1062.97, dec112[2]);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail dec15.getSize()", 4, dec15.getSize());
+            LogResult.assertDecimalEqual("Fail dec15[1]", 1004, dec15[1]);
+            LogResult.assertDecimalEqual("Fail dec15[2]", 1005, dec15[2]);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail num6.getSize()", 4, num6.getSize());
+            LogResult.assertDecimalEqual("Fail num6[1]", 10006, num6[1]);
+            LogResult.assertDecimalEqual("Fail num6[2]", 10007, num6[2]);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail num103.getSize()", 4, num103.getSize());
+            LogResult.assertDecimalEqual("Fail num103[1]", 10009.61, num103[1]);
+            LogResult.assertDecimalEqual("Fail num103[2]", 10054.72, num103[2]);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin2.getSize()", 4, bin2.getSize());
+            LogResult.assertBigIntEqual("Fail bin2[1]", 108, bin2[1]);
+            LogResult.assertBigIntEqual("Fail bin2[2]", 109, bin2[2]);
+		end
+	end
+
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin4.getSize()", 4, bin4.getSize());
+            LogResult.assertBigIntEqual("Fail bin4[1]", 1010, bin4[1]);
+            LogResult.assertBigIntEqual("Fail bin4[2]", 1011, bin4[2]);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail date1.getSize()", 4, date1.getSize());
+            LogResult.assertDateEqual("Fail date1[1]", "11/29/2016", date1[1]);
+            LogResult.assertDateEqual("Fail date1[2]", "08/17/1016", date1[2]);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail date2.getSize()", 4, date2.getSize());
+            LogResult.assertDateEqual("Fail date2[1]", "10/24/2002", date2[1]);
+            LogResult.assertDateEqual("Fail date2[2]", "06/07/1952", date2[2]);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail date3.getSize()", 4, date3.getSize());
+            LogResult.assertDateEqual("Fail date3[1]", "09/08/1927", date3[1]);
+            LogResult.assertDateEqual("Fail date3[2]", "12/29/1827", date3[2]);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail time1.getSize()", 4, time1.getSize());
+            LogResult.assertTimeEqual("Fail time1[1]", "11:29:16", time1[1]);
+            LogResult.assertTimeEqual("Fail time1[2]", "18:17:15", time1[2]);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail time2.getSize()", 4, time2.getSize());
+            LogResult.assertTimeEqual("Fail time2[1]", "10:24:24", time2[1]);
+            LogResult.assertTimeEqual("Fail time2[2]", "16:07:52", time2[2]);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail time3.getSize()", 4, time3.getSize());
+            LogResult.assertTimeEqual("Fail time3[1]", "09:08:27", time3[1]);
+            LogResult.assertTimeEqual("Fail time3[2]", "22:29:23", time3[2]);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail timestamp1.getSize()", 4, timestamp1.getSize());
+            LogResult.assertTimestampEqual("Fail timestamp1[1]", "2017/07/16 22:59:39", timestamp1[1]);
+            LogResult.assertTimestampEqual("Fail timestamp1[2]", "1817/11/06 13:50:31", timestamp1[2]);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail float4.getSize()", 4, float4.getSize());
+            LogResult.assertFloatEqual("Fail float4[1]", 14.99 as smallfloat, float4[1]);
+            LogResult.assertFloatEqual("Fail float4[2]", 15.99 as smallfloat, float4[2]);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail float8.getSize()", 4, float8.getSize());
+            LogResult.assertFloatEqual("Fail float8[1]", 16.99, float8[1]);
+            LogResult.assertFloatEqual("Fail float8[2]", 17.99, float8[2]);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/arrays/Parameters3.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/arrays/Parameters3.egl
new file mode 100644
index 0000000..30e1dc3
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/primitive/arrays/Parameters3.egl
@@ -0,0 +1,227 @@
+package server.test.primitive.arrays;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.programs.PrimitiveArrays;
+import server.host.programs.primitive;
+
+// basic library
+library Parameters3
+	
+	char20 string[]; 
+	lchar20 string(20)[]; 
+	unicode20 string[]; 
+	lunicode20 string(20)[]; 
+	bin2sign smallint[];
+	bin4sign int[];
+	bin8sign bigint[];
+	dec112 decimal(11,2)[];
+	dec15 decimal(15)[];
+	num6 decimal(6)[];
+	num103 decimal(10,3)[];
+	bin2 int[];
+	bin4 bigint[];
+	date1 date[];
+	date2 date[];
+	date3 date[];
+	time1 time[];
+	time2 time[];
+	time3 time[];
+	timestamp1 timestamp("yyyyMMddHHmmss")[];
+	float4 smallfloat[];
+	float8 float[];
+	testParameters boolean = true;
+	function test1(){@Test}
+		char20 = ["abcd", "EFG"]; 
+		lchar20 = ["ABCD", "efg"]; 
+		unicode20 = ["xyz", "1234"]; 
+		lunicode20 = ["XYZ", "4321"]; 
+		bin2sign = [1,2];
+		bin4sign = [3,4];
+		bin8sign = [4,5];
+		dec112 = [45.67, 64.97];
+		dec15 = [6,7];
+		num6 = [8,9];
+		num103 = [11.61, 56.72];
+		bin2 = [10,11];
+		bin4  = [12,13];
+		date1 = ["06/24/2011" ,"03/12/1011"];
+		date2 = ["05/19/1997", "01/02/1947"];
+		date3 = ["04/03/1922", "07/24/1822"];
+		time1 = ["06:24:11" ,"13:12:10"];
+		time2 = ["05:19:19", "11:02:47"];
+		time3 = ["04:03:22", "17:24:18"];
+		timestamp1 = ["2012/02/11 17:54:34", "1812/06/01 08:45:26"];
+		float4 = [14,15];
+		float8 = [16,17];
+		validCount int;
+		try
+	       	LogResult.logStdOut("call PrimitiveArrays.primitiveHostProgram3");
+			PrimitiveArrays.primitiveHostProgram3(char20, lchar20, unicode20, lunicode20, bin2sign, bin4sign, bin8sign, dec112, dec15, num6, num103, bin2, bin4, date1, date2, date3, time1, time2, time3, timestamp1, float4, float8, validCount);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail char20.getSize()", 2, char20.getSize());
+            LogResult.assertStringEqual("Fail char20[1]", "abcdYYYYY           ", char20[1]);
+            LogResult.assertStringEqual("Fail char20[2]", "EFG YYYYY           ", char20[2]);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail lchar20.getSize()", 2, lchar20.getSize());
+            LogResult.assertStringEqual("Fail lchar20[1]", "ABCDYYYYY           ", lchar20[1]);
+            LogResult.assertStringEqual("Fail lchar20[2]", "efg YYYYY           ", lchar20[2]);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail unicode20.getSize()", 2, unicode20.getSize());
+            LogResult.assertStringEqual("Fail unicode20[1]", "xyz ZZZZZZZZZZ      ", unicode20[1]);
+            LogResult.assertStringEqual("Fail unicode20[2]", "1234ZZZZZZZZZZ      ", unicode20[2]);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail lunicode20.getSize()", 2, lunicode20.getSize());
+            LogResult.assertStringEqual("Fail lunicode20[1]", "XYZ ZZZZZZZZZZ      ", lunicode20[1]);
+            LogResult.assertStringEqual("Fail lunicode20[2]", "4321ZZZZZZZZZZ      ", lunicode20[2]);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin2sign.getSize()", 2, bin2sign.getSize());
+            LogResult.assertBigIntEqual("Fail bin2sign[1]", 99, bin2sign[1]);
+            LogResult.assertBigIntEqual("Fail bin2sign[2]", 100, bin2sign[2]);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin4sign.getSize()", 2, bin4sign.getSize());
+            LogResult.assertBigIntEqual("Fail bin4sign[1]", 1001, bin4sign[1]);
+            LogResult.assertBigIntEqual("Fail bin4sign[2]", 1002, bin4sign[2]);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin8sign.getSize()", 2, bin8sign.getSize());
+            LogResult.assertBigIntEqual("Fail bin8sign[1]", 10002, bin8sign[1]);
+            LogResult.assertBigIntEqual("Fail bin8sign[2]", 10003, bin8sign[2]);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail dec112.getSize()", 2, dec112.getSize());
+            LogResult.assertDecimalEqual("Fail dec112[1]", 1043.67, dec112[1]);
+            LogResult.assertDecimalEqual("Fail dec112[2]", 1062.97, dec112[2]);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail dec15.getSize()", 2, dec15.getSize());
+            LogResult.assertDecimalEqual("Fail dec15[1]", 1004, dec15[1]);
+            LogResult.assertDecimalEqual("Fail dec15[2]", 1005, dec15[2]);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail num6.getSize()", 2, num6.getSize());
+            LogResult.assertDecimalEqual("Fail num6[1]", 10006, num6[1]);
+            LogResult.assertDecimalEqual("Fail num6[2]", 10007, num6[2]);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail num103.getSize()", 2, num103.getSize());
+            LogResult.assertDecimalEqual("Fail num103[1]", 10009.61, num103[1]);
+            LogResult.assertDecimalEqual("Fail num103[2]", 10054.72, num103[2]);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin2.getSize()", 2, bin2.getSize());
+            LogResult.assertBigIntEqual("Fail bin2[1]", 108, bin2[1]);
+            LogResult.assertBigIntEqual("Fail bin2[2]", 109, bin2[2]);
+		end
+	end
+
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin4.getSize()", 2, bin4.getSize());
+            LogResult.assertBigIntEqual("Fail bin4[1]", 1010, bin4[1]);
+            LogResult.assertBigIntEqual("Fail bin4[2]", 1011, bin4[2]);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail date1.getSize()", 2, date1.getSize());
+            LogResult.assertDateEqual("Fail date1[1]", "11/29/2016", date1[1]);
+            LogResult.assertDateEqual("Fail date1[2]", "08/17/1016", date1[2]);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail date2.getSize()", 2, date2.getSize());
+            LogResult.assertDateEqual("Fail date2[1]", "10/24/2002", date2[1]);
+            LogResult.assertDateEqual("Fail date2[2]", "06/07/1952", date2[2]);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail date3.getSize()", 2, date3.getSize());
+            LogResult.assertDateEqual("Fail date3[1]", "09/08/1927", date3[1]);
+            LogResult.assertDateEqual("Fail date3[2]", "12/29/1827", date3[2]);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail time1.getSize()", 2, time1.getSize());
+            LogResult.assertTimeEqual("Fail time1[1]", "11:29:16", time1[1]);
+            LogResult.assertTimeEqual("Fail time1[2]", "18:17:15", time1[2]);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail time2.getSize()", 2, time2.getSize());
+            LogResult.assertTimeEqual("Fail time2[1]", "10:24:24", time2[1]);
+            LogResult.assertTimeEqual("Fail time2[2]", "16:07:52", time2[2]);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail time3.getSize()", 2, time3.getSize());
+            LogResult.assertTimeEqual("Fail time3[1]", "09:08:27", time3[1]);
+            LogResult.assertTimeEqual("Fail time3[2]", "22:29:23", time3[2]);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail timestamp1.getSize()", 2, timestamp1.getSize());
+            LogResult.assertTimestampEqual("Fail timestamp1[1]", "2017/07/16 22:59:39", timestamp1[1]);
+            LogResult.assertTimestampEqual("Fail timestamp1[2]", "1817/11/06 13:50:31", timestamp1[2]);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail float4.getSize()", 2, float4.getSize());
+            LogResult.assertFloatEqual("Fail float4[1]", 14.99 as smallfloat, float4[1]);
+            LogResult.assertFloatEqual("Fail float4[2]", 15.99 as smallfloat, float4[2]);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail float8.getSize()", 2, float8.getSize());
+            LogResult.assertFloatEqual("Fail float8[1]", 16.99, float8[1]);
+            LogResult.assertFloatEqual("Fail float8[2]", 17.99, float8[2]);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/RecordFields.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/RecordFields.egl
new file mode 100644
index 0000000..ea3c66b
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/RecordFields.egl
@@ -0,0 +1,182 @@
+package server.test.records;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.programs.ComplexTypes;
+import server.host.programs.data.records.Record1;
+
+// basic library
+library RecordFields
+	
+	rec Record1;
+	testParameters boolean = true;
+	function test1(){@Test}
+		rec.char20 = "abcd"; 
+		rec.lchar20 = "defg"; 
+		rec.unicode20 = "xyz"; 
+		rec.lunicode20 = "abc"; 
+		rec.bin2sign = 1;
+		rec.bin4sign = 2;
+		rec.bin8sign = 3;
+		rec.dec112 = 45.67;
+		rec.dec15 = 14;
+		rec.num6 = 5;
+		rec.num103 = 11.61;
+		rec.bin2 = 6;
+		rec.bin4  = 7;
+		rec.date1 = "06/24/2011";
+		rec.date2 = "05/19/1997";
+		rec.date3 = "04/03/1922";
+		rec.time1 = "17:54:34";
+		rec.time2 = "07:14:03";
+		rec.time3 = "01:45:43";
+		rec.timestamp1 = "2012/02/11 17:54:34";
+		rec.float4 = 8;
+		rec.float8 = 9;
+		try
+        	LogResult.logStdOut("call ComplexTypes.primitiveHostProgram");
+			ComplexTypes.primitiveHostProgram(rec);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.char20 value");
+            LogResult.assertStringEqual("Fail rec.char20", "abcdYYYYY", rec.char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lchar20 value");
+            LogResult.assertStringEqual("Fail rec.lchar20", "defgYYYYY", rec.lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.unicode20 value");
+            LogResult.assertStringEqual("Fail rec.unicode20", "xyz ZZZZZZZZZZ", rec.unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lunicode20 value");
+            LogResult.assertStringEqual("Fail rec.lunicode20", "abc ZZZZZZZZZZ", rec.lunicode20);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin2sign", 99, rec.bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin4sign", 1000, rec.bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin8sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin8sign", 10001, rec.bin8sign);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec112 value");
+            LogResult.assertDecimalEqual("Fail rec.dec112", 1043.67, rec.dec112);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec15 value");
+            LogResult.assertDecimalEqual("Fail rec.dec15", 1012, rec.dec15);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num6 value");
+            LogResult.assertDecimalEqual("Fail rec.num6", 10003, rec.num6);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num103 value");
+            LogResult.assertDecimalEqual("Fail rec.num103", 10009.61, rec.num103);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2 value");
+            LogResult.assertBigIntEqual("Fail rec.bin2", 104, rec.bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4 value");
+            LogResult.assertBigIntEqual("Fail rec.bin4", 1005, rec.bin4);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date1 value");
+            LogResult.assertDateEqual("Fail rec.date1", "11/29/2016", rec.date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date2 value");
+            LogResult.assertDateEqual("Fail rec.date2", "10/24/2002", rec.date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date3 value");
+            LogResult.assertDateEqual("Fail rec.date3", "09/08/1927", rec.date3);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time1 value");
+            LogResult.assertTimeEqual("Fail rec.time1", "22:59:39", rec.time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time2 value");
+            LogResult.assertTimeEqual("Fail rec.time2", "12:19:08", rec.time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time3 value");
+            LogResult.assertTimeEqual("Fail rec.time3", "06:50:48", rec.time3);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.timestamp1 value");
+            LogResult.assertTimestampEqual("Fail rec.timestamp1", "2017/07/16 22:59:39", rec.timestamp1);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float4 value");
+            LogResult.assertFloatEqual("Fail rec.float4", 8.99 as smallfloat, rec.float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float8 value");
+            LogResult.assertFloatEqual("Fail rec.float8", 9.99, rec.float8);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/RecordFields2.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/RecordFields2.egl
new file mode 100644
index 0000000..c1bb73e
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/RecordFields2.egl
@@ -0,0 +1,182 @@
+package server.test.records;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.programs.ComplexTypes;
+import server.host.programs.data.records.Record2;
+
+// basic library
+library RecordFields2
+	
+	rec Record2;
+	testParameters boolean = true;
+	function test1(){@Test}
+		rec.char20 = "abcd"; 
+		rec.lchar20 = "defg"; 
+		rec.unicode20 = "xyz"; 
+		rec.lunicode20 = "abc"; 
+		rec.bin2sign = 1;
+		rec.bin4sign = 2;
+		rec.bin8sign = 3;
+		rec.dec112 = 45.67;
+		rec.dec15 = 14;
+		rec.num6 = 5;
+		rec.num103 = 11.61;
+		rec.bin2 = 6;
+		rec.bin4  = 7;
+		rec.date1 = "06/24/2011";
+		rec.date2 = "05/19/1997";
+		rec.date3 = "04/03/1922";
+		rec.time1 = "17:54:34";
+		rec.time2 = "07:14:03";
+		rec.time3 = "01:45:43";
+		rec.timestamp1 = "2012/02/11 17:54:34";
+		rec.float4 = 8;
+		rec.float8 = 9;
+		try
+        	LogResult.logStdOut("call ComplexTypes.primitiveHostProgram2");
+			ComplexTypes.primitiveHostProgram2(rec);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.char20 value");
+            LogResult.assertStringEqual("Fail rec.char20", "abcdYYYYY", rec.char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lchar20 value");
+            LogResult.assertStringEqual("Fail rec.lchar20", "defgYYYYY", rec.lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.unicode20 value");
+            LogResult.assertStringEqual("Fail rec.unicode20", "xyz ZZZZZZZZZZ", rec.unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lunicode20 value");
+            LogResult.assertStringEqual("Fail rec.lunicode20", "abc ZZZZZZZZZZ", rec.lunicode20);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin2sign", 99, rec.bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin4sign", 1000, rec.bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin8sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin8sign", 10001, rec.bin8sign);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec112 value");
+            LogResult.assertDecimalEqual("Fail rec.dec112", 1043.67, rec.dec112);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec15 value");
+            LogResult.assertDecimalEqual("Fail rec.dec15", 1012, rec.dec15);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num6 value");
+            LogResult.assertDecimalEqual("Fail rec.num6", 10003, rec.num6);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num103 value");
+            LogResult.assertDecimalEqual("Fail rec.num103", 10009.61, rec.num103);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2 value");
+            LogResult.assertBigIntEqual("Fail rec.bin2", 104, rec.bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4 value");
+            LogResult.assertBigIntEqual("Fail rec.bin4", 1005, rec.bin4);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date1 value");
+            LogResult.assertDateEqual("Fail rec.date1", "11/29/2016", rec.date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date2 value");
+            LogResult.assertDateEqual("Fail rec.date2", "10/24/2002", rec.date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date3 value");
+            LogResult.assertDateEqual("Fail rec.date3", "09/08/1927", rec.date3);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time1 value");
+            LogResult.assertTimeEqual("Fail rec.time1", "22:59:39", rec.time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time2 value");
+            LogResult.assertTimeEqual("Fail rec.time2", "12:19:08", rec.time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time3 value");
+            LogResult.assertTimeEqual("Fail rec.time3", "06:50:48", rec.time3);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.timestamp1 value");
+            LogResult.assertTimestampEqual("Fail rec.timestamp1", "2017/07/16 22:59:39", rec.timestamp1);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float4 value");
+            LogResult.assertFloatEqual("Fail rec.float4", 8.99 as smallfloat, rec.float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float8 value");
+            LogResult.assertFloatEqual("Fail rec.float8", 9.99, rec.float8);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/RecordFields3.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/RecordFields3.egl
new file mode 100644
index 0000000..960fa23
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/RecordFields3.egl
@@ -0,0 +1,182 @@
+package server.test.records;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.programs.ComplexTypes;
+import server.host.programs.data.records.Record3;
+
+// basic library
+library RecordFields3
+	
+	rec Record3;
+	testParameters boolean = true;
+	function test1(){@Test}
+		rec.char20 = "abcd"; 
+		rec.lchar20 = "defg"; 
+		rec.unicode20 = "xyz"; 
+		rec.lunicode20 = "abc"; 
+		rec.bin2sign = 1;
+		rec.bin4sign = 2;
+		rec.bin8sign = 3;
+		rec.dec112 = 45.67;
+		rec.dec15 = 14;
+		rec.num6 = 5;
+		rec.num103 = 11.61;
+		rec.bin2 = 6;
+		rec.bin4  = 7;
+		rec.date1 = "06/24/2011";
+		rec.date2 = "05/19/1997";
+		rec.date3 = "04/03/1922";
+		rec.time1 = "17:54:34";
+		rec.time2 = "07:14:03";
+		rec.time3 = "01:45:43";
+		rec.timestamp1 = "2012/02/11 17:54:34";
+		rec.float4 = 8;
+		rec.float8 = 9;
+		try
+        	LogResult.logStdOut("call ComplexTypes.primitiveHostProgram3");
+			ComplexTypes.primitiveHostProgram3(rec);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.char20 value");
+            LogResult.assertStringEqual("Fail rec.char20", "abcdYYYYY           ", rec.char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lchar20 value");
+            LogResult.assertStringEqual("Fail rec.lchar20", "defgYYYYY           ", rec.lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.unicode20 value");
+            LogResult.assertStringEqual("Fail rec.unicode20", "xyz ZZZZZZZZZZ      ", rec.unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lunicode20 value");
+            LogResult.assertStringEqual("Fail rec.lunicode20", "abc ZZZZZZZZZZ      ", rec.lunicode20);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin2sign", 99, rec.bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin4sign", 1000, rec.bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin8sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin8sign", 10001, rec.bin8sign);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec112 value");
+            LogResult.assertDecimalEqual("Fail rec.dec112", 1043.67, rec.dec112);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec15 value");
+            LogResult.assertDecimalEqual("Fail rec.dec15", 1012, rec.dec15);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num6 value");
+            LogResult.assertDecimalEqual("Fail rec.num6", 10003, rec.num6);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num103 value");
+            LogResult.assertDecimalEqual("Fail rec.num103", 10009.61, rec.num103);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2 value");
+            LogResult.assertBigIntEqual("Fail rec.bin2", 104, rec.bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4 value");
+            LogResult.assertBigIntEqual("Fail rec.bin4", 1005, rec.bin4);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date1 value");
+            LogResult.assertDateEqual("Fail rec.date1", "11/29/2016", rec.date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date2 value");
+            LogResult.assertDateEqual("Fail rec.date2", "10/24/2002", rec.date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date3 value");
+            LogResult.assertDateEqual("Fail rec.date3", "09/08/1927", rec.date3);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time1 value");
+            LogResult.assertTimeEqual("Fail rec.time1", "22:59:39", rec.time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time2 value");
+            LogResult.assertTimeEqual("Fail rec.time2", "12:19:08", rec.time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time3 value");
+            LogResult.assertTimeEqual("Fail rec.time3", "06:50:48", rec.time3);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.timestamp1 value");
+            LogResult.assertTimestampEqual("Fail rec.timestamp1", "2017/07/16 22:59:39", rec.timestamp1);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float4 value");
+            LogResult.assertFloatEqual("Fail rec.float4", 8.99 as smallfloat, rec.float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float8 value");
+            LogResult.assertFloatEqual("Fail rec.float8", 9.99, rec.float8);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/arrays/Record2Fields.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/arrays/Record2Fields.egl
new file mode 100644
index 0000000..d30a6ca
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/arrays/Record2Fields.egl
@@ -0,0 +1,255 @@
+package server.test.records.arrays;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.programs.ComplexTypeArrays;
+import server.host.programs.data.records.Record1;
+import server.host.programs.data.records.Record11;
+import server.host.programs.data.records.Record12;
+import server.host.programs.data.records.Record2;
+
+// basic library
+library Record2Fields
+	
+	rec Record12[];
+	function test1(){@Test}
+		rec = new Record12[0];
+		rec.appendElement(createRecord12());
+		rec.appendElement(createRecord12());
+		try
+        	LogResult.logStdOut("call ComplexTypeArrays.primitiveHostProgram2");
+			validCount int;
+			ComplexTypeArrays.primitiveHostProgram2(rec, validCount);
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	private function createRecord12()returns(Record12)
+		r Record12{
+					rec = createRecord2(),
+					char20 = ["abcd", "EFG"], 
+					unicode20 = ["xyz", "1234"], 
+					lchar20 = ["ABCD", "efg"], 
+					lunicode20 = ["XYZ", "4321"], 
+					bin2sign = [1,2],
+					bin4sign = [3,4],
+					bin8sign = [4,5],
+					dec112 = [45.67, 64.97],
+					dec15 = [6,7],
+					num6 = [8,9],
+					num103 = [11.61, 56.72],
+					bin2 = [10,11],
+					bin4  = [12,13],
+					date1 = ["06/24/2011" ,"03/12/1011"],
+					date2 = ["05/19/1997", "01/02/1947"],
+					date3 = ["04/03/1922", "07/24/1822"],
+					timestamp1 = ["2012/02/11 17:54:34", "1812/06/01 08:45:26"],
+					float4 = [14,15],
+					float8 = [16,17],
+					recA = new Record2[0]
+		};
+		r.recA.appendElement(createRecord2());  
+		r.recA.appendElement(createRecord2());  
+		return(r);
+	end
+	private function createRecord2()returns(Record2)
+		return(new Record2{
+							char20 = "abcd", 
+							unicode20 = "xyz", 
+							lchar20 = "defg",
+							lunicode20 = "abc", 
+							bin2sign = 1,
+							bin4sign = 2,
+							bin8sign = 3,
+							dec112 = 45.67,
+							dec15 = 14,
+							num6 = 5,
+							num103 = 11.61,
+							bin2 = 6,
+							bin4  = 7,
+							date1 = "06/24/2011",
+							date2 = "05/19/1997",
+							date3 = "04/03/1922",
+							time1 = "17:54:34",
+							time2 = "07:14:03",
+							time3 = "01:45:43",
+							timestamp1 = "2012/02/11 17:54:34",
+							float4 = 8,
+							float8 = 9
+					});
+	end
+	function recsTest(){@Test {}}
+        LogResult.assertBigIntEqual("Fail rec.getSize()", 5, rec.getSize());
+	end
+	function rec_char20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "].char20.getSize()", 4, rec[idx].char20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[1]", "abcdYYYYY", rec[idx].char20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[2]", "EFG YYYYY", rec[idx].char20[2]);
+	    end
+	end
+	function rec_unicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "]unicode20.getSize()", 4, rec[idx].unicode20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[1]", "xyz ZZZZZZZZZZ", rec[idx].unicode20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[2]", "1234ZZZZZZZZZZ", rec[idx].unicode20[2]); 
+		end
+	end
+	function lchar20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lchar20.getSize()", 4, rec[idx].lchar20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[1]", "ABCDYYYYY", rec[idx].lchar20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[2]", "efg YYYYY", rec[idx].lchar20[2]);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lunicode20.getSize()", 4, rec[idx].lunicode20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[1]", "XYZ ZZZZZZZZZZ", rec[idx].lunicode20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[2]", "4321ZZZZZZZZZZ", rec[idx].lunicode20[2]);
+		end
+	end
+	function rec_bin2signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign.getSize()", 4, rec[idx].bin2sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[1]", 99, rec[idx].bin2sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[2]", 100, rec[idx].bin2sign[2]);
+		end
+	end
+	function rec_bin4signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign.getSize()", 4, rec[idx].bin4sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[1]", 1001, rec[idx].bin4sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[2]", 1002, rec[idx].bin4sign[2]);
+		end
+	end
+	function rec_bin8signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign.getSize()", 4, rec[idx].bin8sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[1]", 10002, rec[idx].bin8sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[2]", 10003, rec[idx].bin8sign[2]);
+		end
+	end
+	function rec_dec112Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec112.getSize()", 4, rec[idx].dec112.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec112[1]", 1043.67, rec[idx].dec112[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec112[2]", 1062.97, rec[idx].dec112[2]);
+		end
+	end
+	function rec_dec15Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec15.getSize()", 4, rec[idx].dec15.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec15[1]", 1004, rec[idx].dec15[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec15[2]", 1005, rec[idx].dec15[2]);
+		end
+	end
+	function num6Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num6.getSize()", 4, rec[idx].num6.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num6[1]", 10006, rec[idx].num6[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num6[2]", 10007, rec[idx].num6[2]);
+		end
+	end
+	function rec_num103Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num103.getSize()", 4, rec[idx].num103.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num103[1]", 10009.61, rec[idx].num103[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num103[2]", 10054.72, rec[idx].num103[2]);
+		end
+	end
+	function rec_bin2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2.getSize()", 4, rec[idx].bin2.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[1]", 108, rec[idx].bin2[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[2]", 109, rec[idx].bin2[2]);
+		end
+	end
+
+	function rec_bin4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4.getSize()", 4, rec[idx].bin4.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[1]", 1010, rec[idx].bin4[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[2]", 1011, rec[idx].bin4[2]);
+		end
+	end
+	function rec_date1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date1.getSize()", 4, rec[idx].date1.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[1]", "11/29/2016", rec[idx].date1[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[2]", "08/17/1016", rec[idx].date1[2]);
+		end
+	end
+	function rec_date2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date2.getSize()", 4, rec[idx].date2.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[1]", "10/24/2002", rec[idx].date2[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[2]", "06/07/1952", rec[idx].date2[2]);
+		end
+	end
+
+	function rec_date3Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date3.getSize()", 4, rec[idx].date3.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[1]", "09/08/1927", rec[idx].date3[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[2]", "12/29/1827", rec[idx].date3[2]);
+		end
+	end
+	function rec_timestamp1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]timestamp1.getSize()", 4, rec[idx].timestamp1.getSize());
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[1]", "2017/07/16 22:59:39", rec[idx].timestamp1[1]);
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[2]", "1817/11/06 13:50:31", rec[idx].timestamp1[2]);
+		end
+	end
+	function rec_float4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float4.getSize()", 4, rec[idx].float4.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[1]", 14.99 as smallfloat, rec[idx].float4[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[2]", 15.99 as smallfloat, rec[idx].float4[2]);
+		end
+	end
+	function rec_float8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float8.getSize()", 4, rec[idx].float8.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[1]", 16.99, rec[idx].float8[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[2]", 17.99, rec[idx].float8[2]);
+		end
+	end
+	function rec_recTest(){@Test {}}
+		for(idx int from 1 to 2)
+			recTest(rec[idx].rec, "rec[" + idx + "].rec");
+		end
+	end
+	function rec_recATest(){@Test {}}
+		for(idx1 int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx1 + "]recA.getSize()", 4, rec[idx1].recA.getSize());
+			for(idx2 int from 1 to 2)
+				recTest(rec[idx1].recA[idx2], "rec[" + idx1 + "].recA[" + idx2 + "]");
+			end
+		end
+	end
+	private function recTest(rec_rec Record2 in, name String in)
+        LogResult.assertStringEqual("Fail " + name + ".char20", "abcdYYYYY", rec_rec.char20);
+        LogResult.assertStringEqual("Fail " + name + ".unicode20", "xyz ZZZZZZZZZZ", rec_rec.unicode20);
+        LogResult.assertStringEqual("Fail " + name + ".lchar20", "defgYYYYY", rec_rec.lchar20);
+        LogResult.assertStringEqual("Fail " + name + ".lunicode20", "abc ZZZZZZZZZZ", rec_rec.lunicode20);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2sign", 99, rec_rec.bin2sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4sign", 1000, rec_rec.bin4sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin8sign", 10001, rec_rec.bin8sign);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec112", 1043.67, rec_rec.dec112);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec15", 1012, rec_rec.dec15);
+        LogResult.assertDecimalEqual("Fail " + name + ".num6", 10003, rec_rec.num6);
+        LogResult.assertDecimalEqual("Fail " + name + ".num103", 10009.61, rec_rec.num103);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2", 104, rec_rec.bin2);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4", 1005, rec_rec.bin4);
+        LogResult.assertDateEqual("Fail " + name + ".date1", "11/29/2016", rec_rec.date1);
+        LogResult.assertDateEqual("Fail " + name + ".date2", "10/24/2002", rec_rec.date2);
+        LogResult.assertDateEqual("Fail " + name + ".date3", "09/08/1927", rec_rec.date3);
+        LogResult.assertTimestampEqual("Fail " + name + ".timestamp1", "2017/07/16 22:59:39", rec_rec.timestamp1);
+        LogResult.assertFloatEqual("Fail " + name + ".float8", 9.99, rec_rec.float8);
+        LogResult.assertFloatEqual("Fail " + name + ".float4", 8.99 as smallfloat, rec_rec.float4);
+	end
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/arrays/Record3Fields.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/arrays/Record3Fields.egl
new file mode 100644
index 0000000..bfbfa3b
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/arrays/Record3Fields.egl
@@ -0,0 +1,255 @@
+package server.test.records.arrays;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.programs.ComplexTypeArrays;
+import server.host.programs.data.records.Record12;
+import server.host.programs.data.records.Record13;
+import server.host.programs.data.records.Record2;
+import server.host.programs.data.records.Record3;
+
+// basic library
+library Record3Fields
+	
+	rec Record13[];
+	function test1(){@Test}
+		rec = new Record13[0];
+		rec.appendElement(createRecord13());
+		rec.appendElement(createRecord13());
+		try
+        	LogResult.logStdOut("call ComplexTypeArrays.primitiveHostProgram3");
+			validCount int;
+			ComplexTypeArrays.primitiveHostProgram3(rec, validCount);
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	private function createRecord13()returns(Record13)
+		r Record13{
+					rec = createRecord3(),
+					char20 = ["abcd", "EFG"], 
+					unicode20 = ["xyz", "1234"], 
+					lchar20 = ["ABCD", "efg"], 
+					lunicode20 = ["XYZ", "4321"], 
+					bin2sign = [1,2],
+					bin4sign = [3,4],
+					bin8sign = [4,5],
+					dec112 = [45.67, 64.97],
+					dec15 = [6,7],
+					num6 = [8,9],
+					num103 = [11.61, 56.72],
+					bin2 = [10,11],
+					bin4  = [12,13],
+					date1 = ["06/24/2011" ,"03/12/1011"],
+					date2 = ["05/19/1997", "01/02/1947"],
+					date3 = ["04/03/1922", "07/24/1822"],
+					timestamp1 = ["2012/02/11 17:54:34", "1812/06/01 08:45:26"],
+					float4 = [14,15],
+					float8 = [16,17],
+					recA = new Record3[0]
+		};
+		r.recA.appendElement(createRecord3());  
+		r.recA.appendElement(createRecord3());  
+		return(r);
+	end
+	private function createRecord3()returns(Record3)
+		return(new Record3{
+							char20 = "abcd", 
+							unicode20 = "xyz", 
+							lchar20 = "defg",
+							lunicode20 = "abc", 
+							bin2sign = 1,
+							bin4sign = 2,
+							bin8sign = 3,
+							dec112 = 45.67,
+							dec15 = 14,
+							num6 = 5,
+							num103 = 11.61,
+							bin2 = 6,
+							bin4  = 7,
+							date1 = "06/24/2011",
+							date2 = "05/19/1997",
+							date3 = "04/03/1922",
+							time1 = "17:54:34",
+							time2 = "07:14:03",
+							time3 = "01:45:43",
+							timestamp1 = "2012/02/11 17:54:34",
+							float4 = 8,
+							float8 = 9
+					});
+	end
+	function recsTest(){@Test {}}
+        LogResult.assertBigIntEqual("Fail rec.getSize()", 2, rec.getSize());
+	end
+	function rec_char20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "].char20.getSize()", 2, rec[idx].char20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[1]", "abcdYYYYY           ", rec[idx].char20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[2]", "EFG YYYYY           ", rec[idx].char20[2]);
+	    end
+	end
+	function rec_unicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "]unicode20.getSize()", 2, rec[idx].unicode20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[1]", "xyz ZZZZZZZZZZ      ", rec[idx].unicode20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[2]", "1234ZZZZZZZZZZ      ", rec[idx].unicode20[2]); 
+		end
+	end
+	function lchar20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lchar20.getSize()", 2, rec[idx].lchar20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[1]", "ABCDYYYYY           ", rec[idx].lchar20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[2]", "efg YYYYY           ", rec[idx].lchar20[2]);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lunicode20.getSize()", 2, rec[idx].lunicode20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[1]", "XYZ ZZZZZZZZZZ      ", rec[idx].lunicode20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[2]", "4321ZZZZZZZZZZ      ", rec[idx].lunicode20[2]);
+		end
+	end
+	function rec_bin2signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign.getSize()", 2, rec[idx].bin2sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[1]", 99, rec[idx].bin2sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[2]", 100, rec[idx].bin2sign[2]);
+		end
+	end
+	function rec_bin4signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign.getSize()", 2, rec[idx].bin4sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[1]", 1001, rec[idx].bin4sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[2]", 1002, rec[idx].bin4sign[2]);
+		end
+	end
+	function rec_bin8signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign.getSize()", 2, rec[idx].bin8sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[1]", 10002, rec[idx].bin8sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[2]", 10003, rec[idx].bin8sign[2]);
+		end
+	end
+	function rec_dec112Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec112.getSize()", 2, rec[idx].dec112.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec112[1]", 1043.67, rec[idx].dec112[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec112[2]", 1062.97, rec[idx].dec112[2]);
+		end
+	end
+	function rec_dec15Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec15.getSize()", 2, rec[idx].dec15.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec15[1]", 1004, rec[idx].dec15[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec15[2]", 1005, rec[idx].dec15[2]);
+		end
+	end
+	function num6Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num6.getSize()", 2, rec[idx].num6.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num6[1]", 10006, rec[idx].num6[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num6[2]", 10007, rec[idx].num6[2]);
+		end
+	end
+	function rec_num103Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num103.getSize()", 2, rec[idx].num103.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num103[1]", 10009.61, rec[idx].num103[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num103[2]", 10054.72, rec[idx].num103[2]);
+		end
+	end
+	function rec_bin2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2.getSize()", 2, rec[idx].bin2.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[1]", 108, rec[idx].bin2[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[2]", 109, rec[idx].bin2[2]);
+		end
+	end
+
+	function rec_bin4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4.getSize()", 2, rec[idx].bin4.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[1]", 1010, rec[idx].bin4[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[2]", 1011, rec[idx].bin4[2]);
+		end
+	end
+	function rec_date1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date1.getSize()", 2, rec[idx].date1.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[1]", "11/29/2016", rec[idx].date1[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[2]", "08/17/1016", rec[idx].date1[2]);
+		end
+	end
+	function rec_date2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date2.getSize()", 2, rec[idx].date2.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[1]", "10/24/2002", rec[idx].date2[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[2]", "06/07/1952", rec[idx].date2[2]);
+		end
+	end
+
+	function rec_date3Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date3.getSize()", 2, rec[idx].date3.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[1]", "09/08/1927", rec[idx].date3[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[2]", "12/29/1827", rec[idx].date3[2]);
+		end
+	end
+	function rec_timestamp1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]timestamp1.getSize()", 2, rec[idx].timestamp1.getSize());
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[1]", "2017/07/16 22:59:39", rec[idx].timestamp1[1]);
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[2]", "1817/11/06 13:50:31", rec[idx].timestamp1[2]);
+		end
+	end
+	function rec_float4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float4.getSize()", 2, rec[idx].float4.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[1]", 14.99 as smallfloat, rec[idx].float4[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[2]", 15.99 as smallfloat, rec[idx].float4[2]);
+		end
+	end
+	function rec_float8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float8.getSize()", 2, rec[idx].float8.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[1]", 16.99, rec[idx].float8[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[2]", 17.99, rec[idx].float8[2]);
+		end
+	end
+	function rec_recTest(){@Test {}}
+		for(idx int from 1 to 2)
+			recTest(rec[idx].rec, "rec[" + idx + "].rec");
+		end
+	end
+	function rec_recATest(){@Test {}}
+		for(idx1 int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx1 + "]recA.getSize()", 2, rec[idx1].recA.getSize());
+			for(idx2 int from 1 to 2)
+				recTest(rec[idx1].recA[idx2], "rec[" + idx1 + "].recA[" + idx2 + "]");
+			end
+		end
+	end
+	private function recTest(rec_rec Record3 in, name String in)
+        LogResult.assertStringEqual("Fail " + name + ".char20", "abcdYYYYY           ", rec_rec.char20);
+        LogResult.assertStringEqual("Fail " + name + ".unicode20", "xyz ZZZZZZZZZZ      ", rec_rec.unicode20);
+        LogResult.assertStringEqual("Fail " + name + ".lchar20", "defgYYYYY           ", rec_rec.lchar20);
+        LogResult.assertStringEqual("Fail " + name + ".lunicode20", "abc ZZZZZZZZZZ      ", rec_rec.lunicode20);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2sign", 99, rec_rec.bin2sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4sign", 1000, rec_rec.bin4sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin8sign", 10001, rec_rec.bin8sign);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec112", 1043.67, rec_rec.dec112);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec15", 1012, rec_rec.dec15);
+        LogResult.assertDecimalEqual("Fail " + name + ".num6", 10003, rec_rec.num6);
+        LogResult.assertDecimalEqual("Fail " + name + ".num103", 10009.61, rec_rec.num103);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2", 104, rec_rec.bin2);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4", 1005, rec_rec.bin4);
+        LogResult.assertDateEqual("Fail " + name + ".date1", "11/29/2016", rec_rec.date1);
+        LogResult.assertDateEqual("Fail " + name + ".date2", "10/24/2002", rec_rec.date2);
+        LogResult.assertDateEqual("Fail " + name + ".date3", "09/08/1927", rec_rec.date3);
+        LogResult.assertTimestampEqual("Fail " + name + ".timestamp1", "2017/07/16 22:59:39", rec_rec.timestamp1);
+        LogResult.assertFloatEqual("Fail " + name + ".float8", 9.99, rec_rec.float8);
+        LogResult.assertFloatEqual("Fail " + name + ".float4", 8.99 as smallfloat, rec_rec.float4);
+	end
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/arrays/RecordFields.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/arrays/RecordFields.egl
new file mode 100644
index 0000000..de47076
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/records/arrays/RecordFields.egl
@@ -0,0 +1,253 @@
+package server.test.records.arrays;
+
+import org.eclipse.edt.eunit.runtime.logresult;
+import org.eclipse.edt.eunit.runtime.test;
+import eglx.lang.anyexception;
+import server.host.programs.ComplexTypeArrays;
+import server.host.programs.data.records.Record1;
+import server.host.programs.data.records.Record11;
+
+// basic library
+library RecordFields
+	
+	rec Record11[];
+	function test1(){@Test}
+		rec = new Record11[0];
+		rec.appendElement(createRecord11());
+		rec.appendElement(createRecord11());
+		try
+        	LogResult.logStdOut("call ComplexTypeArrays.primitiveHostProgram");
+			validCount int;
+			ComplexTypeArrays.primitiveHostProgram(rec, validCount);
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	private function createRecord11()returns(Record11)
+		r Record11{
+					rec = createRecord1(),
+					char20 = ["abcd", "EFG"], 
+					unicode20 = ["xyz", "1234"], 
+					lchar20 = ["ABCD", "efg"], 
+					lunicode20 = ["XYZ", "4321"], 
+					bin2sign = [1,2],
+					bin4sign = [3,4],
+					bin8sign = [4,5],
+					dec112 = [45.67, 64.97],
+					dec15 = [6,7],
+					num6 = [8,9],
+					num103 = [11.61, 56.72],
+					bin2 = [10,11],
+					bin4  = [12,13],
+					date1 = ["06/24/2011" ,"03/12/1011"],
+					date2 = ["05/19/1997", "01/02/1947"],
+					date3 = ["04/03/1922", "07/24/1822"],
+					timestamp1 = ["2012/02/11 17:54:34", "1812/06/01 08:45:26"],
+					float4 = [14,15],
+					float8 = [16,17],
+					recA = new Record1[0]
+		};
+		r.recA.appendElement(createRecord1());  
+		r.recA.appendElement(createRecord1());  
+		return(r);
+	end
+	private function createRecord1()returns(Record1)
+		return(new Record1{
+							char20 = "abcd", 
+							unicode20 = "xyz", 
+							lchar20 = "defg",
+							lunicode20 = "abc", 
+							bin2sign = 1,
+							bin4sign = 2,
+							bin8sign = 3,
+							dec112 = 45.67,
+							dec15 = 14,
+							num6 = 5,
+							num103 = 11.61,
+							bin2 = 6,
+							bin4  = 7,
+							date1 = "06/24/2011",
+							date2 = "05/19/1997",
+							date3 = "04/03/1922",
+							time1 = "17:54:34",
+							time2 = "07:14:03",
+							time3 = "01:45:43",
+							timestamp1 = "2012/02/11 17:54:34",
+							float4 = 8,
+							float8 = 9
+					});
+	end
+	function recsTest(){@Test {}}
+        LogResult.assertBigIntEqual("Fail rec.getSize()", 5, rec.getSize());
+	end
+	function rec_char20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "].char20.getSize()", 4, rec[idx].char20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[1]", "abcdYYYYY", rec[idx].char20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[2]", "EFG YYYYY", rec[idx].char20[2]);
+	    end
+	end
+	function rec_unicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "]unicode20.getSize()", 4, rec[idx].unicode20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[1]", "xyz ZZZZZZZZZZ", rec[idx].unicode20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[2]", "1234ZZZZZZZZZZ", rec[idx].unicode20[2]); 
+		end
+	end
+	function lchar20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lchar20.getSize()", 4, rec[idx].lchar20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[1]", "ABCDYYYYY", rec[idx].lchar20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[2]", "efg YYYYY", rec[idx].lchar20[2]);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lunicode20.getSize()", 4, rec[idx].lunicode20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[1]", "XYZ ZZZZZZZZZZ", rec[idx].lunicode20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[2]", "4321ZZZZZZZZZZ", rec[idx].lunicode20[2]);
+		end
+	end
+	function rec_bin2signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign.getSize()", 4, rec[idx].bin2sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[1]", 99, rec[idx].bin2sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[2]", 100, rec[idx].bin2sign[2]);
+		end
+	end
+	function rec_bin4signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign.getSize()", 4, rec[idx].bin4sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[1]", 1001, rec[idx].bin4sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[2]", 1002, rec[idx].bin4sign[2]);
+		end
+	end
+	function rec_bin8signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign.getSize()", 4, rec[idx].bin8sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[1]", 10002, rec[idx].bin8sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[2]", 10003, rec[idx].bin8sign[2]);
+		end
+	end
+	function rec_dec112Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec112.getSize()", 4, rec[idx].dec112.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec112[1]", 1043.67, rec[idx].dec112[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec112[2]", 1062.97, rec[idx].dec112[2]);
+		end
+	end
+	function rec_dec15Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec15.getSize()", 4, rec[idx].dec15.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec15[1]", 1004, rec[idx].dec15[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec15[2]", 1005, rec[idx].dec15[2]);
+		end
+	end
+	function num6Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num6.getSize()", 4, rec[idx].num6.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num6[1]", 10006, rec[idx].num6[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num6[2]", 10007, rec[idx].num6[2]);
+		end
+	end
+	function rec_num103Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num103.getSize()", 4, rec[idx].num103.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num103[1]", 10009.61, rec[idx].num103[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num103[2]", 10054.72, rec[idx].num103[2]);
+		end
+	end
+	function rec_bin2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2.getSize()", 4, rec[idx].bin2.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[1]", 108, rec[idx].bin2[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[2]", 109, rec[idx].bin2[2]);
+		end
+	end
+
+	function rec_bin4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4.getSize()", 4, rec[idx].bin4.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[1]", 1010, rec[idx].bin4[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[2]", 1011, rec[idx].bin4[2]);
+		end
+	end
+	function rec_date1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date1.getSize()", 4, rec[idx].date1.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[1]", "11/29/2016", rec[idx].date1[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[2]", "08/17/1016", rec[idx].date1[2]);
+		end
+	end
+	function rec_date2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date2.getSize()", 4, rec[idx].date2.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[1]", "10/24/2002", rec[idx].date2[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[2]", "06/07/1952", rec[idx].date2[2]);
+		end
+	end
+
+	function rec_date3Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date3.getSize()", 4, rec[idx].date3.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[1]", "09/08/1927", rec[idx].date3[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[2]", "12/29/1827", rec[idx].date3[2]);
+		end
+	end
+	function rec_timestamp1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]timestamp1.getSize()", 4, rec[idx].timestamp1.getSize());
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[1]", "2017/07/16 22:59:39", rec[idx].timestamp1[1]);
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[2]", "1817/11/06 13:50:31", rec[idx].timestamp1[2]);
+		end
+	end
+	function rec_float4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float4.getSize()", 4, rec[idx].float4.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[1]", 14.99 as smallfloat, rec[idx].float4[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[2]", 15.99 as smallfloat, rec[idx].float4[2]);
+		end
+	end
+	function rec_float8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float8.getSize()", 4, rec[idx].float8.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[1]", 16.99, rec[idx].float8[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[2]", 17.99, rec[idx].float8[2]);
+		end
+	end
+	function rec_recTest(){@Test {}}
+		for(idx int from 1 to 2)
+			recTest(rec[idx].rec, "rec[" + idx + "].rec");
+		end
+	end
+	function rec_recATest(){@Test {}}
+		for(idx1 int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx1 + "]recA.getSize()", 4, rec[idx1].recA.getSize());
+			for(idx2 int from 1 to 2)
+				recTest(rec[idx1].recA[idx2], "rec[" + idx1 + "].recA[" + idx2 + "]");
+			end
+		end
+	end
+	private function recTest(rec_rec Record1 in, name String in)
+        LogResult.assertStringEqual("Fail " + name + ".char20", "abcdYYYYY", rec_rec.char20);
+        LogResult.assertStringEqual("Fail " + name + ".unicode20", "xyz ZZZZZZZZZZ", rec_rec.unicode20);
+        LogResult.assertStringEqual("Fail " + name + ".lchar20", "defgYYYYY", rec_rec.lchar20);
+        LogResult.assertStringEqual("Fail " + name + ".lunicode20", "abc ZZZZZZZZZZ", rec_rec.lunicode20);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2sign", 99, rec_rec.bin2sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4sign", 1000, rec_rec.bin4sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin8sign", 10001, rec_rec.bin8sign);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec112", 1043.67, rec_rec.dec112);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec15", 1012, rec_rec.dec15);
+        LogResult.assertDecimalEqual("Fail " + name + ".num6", 10003, rec_rec.num6);
+        LogResult.assertDecimalEqual("Fail " + name + ".num103", 10009.61, rec_rec.num103);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2", 104, rec_rec.bin2);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4", 1005, rec_rec.bin4);
+        LogResult.assertDateEqual("Fail " + name + ".date1", "11/29/2016", rec_rec.date1);
+        LogResult.assertDateEqual("Fail " + name + ".date2", "10/24/2002", rec_rec.date2);
+        LogResult.assertDateEqual("Fail " + name + ".date3", "09/08/1927", rec_rec.date3);
+        LogResult.assertTimestampEqual("Fail " + name + ".timestamp1", "2017/07/16 22:59:39", rec_rec.timestamp1);
+        LogResult.assertFloatEqual("Fail " + name + ".float8", 9.99, rec_rec.float8);
+        LogResult.assertFloatEqual("Fail " + name + ".float4", 8.99 as smallfloat, rec_rec.float4);
+	end
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/HandlerFields.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/HandlerFields.egl
new file mode 100644
index 0000000..01936a3
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/HandlerFields.egl
@@ -0,0 +1,203 @@
+package server.test.rpg.handlers;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.rpg.programs.ComplexTypes;
+import server.host.rpg.programs.data.handlers.Handler1;
+
+// basic library
+library HandlerFields
+	
+	rec Handler1;
+	testParameters boolean = true;
+	function test1(){@Test}
+		rec.char20 = "abcd"; 
+		rec.lchar20 = "defg"; 
+		rec.unicode20 = "xyz"; 
+		rec.lunicode20 = "abc"; 
+		rec.bin1sign = -1;
+		rec.bin2sign = 1;
+		rec.bin4sign = 2;
+		rec.bin8sign = 3;
+		rec.dec174 = 45.67;
+		rec.dec8 = 14;
+		rec.num150 = 5;
+		rec.num112 = 11.61;
+		rec.bin1 = 5;
+		rec.bin2 = 6;
+		rec.bin4  = 7;
+		rec.bin8  = 8;
+		rec.date1 = "06/24/2011";
+		rec.date2 = "05/19/1997";
+		rec.date3 = "04/03/1922";
+		rec.time1 = "17:54:34";
+		rec.time2 = "07:14:03";
+		rec.time3 = "01:45:43";
+		rec.timestamp1 = "2012/02/11 17:54:34";
+		rec.float4 = 8;
+		rec.float8 = 9;
+		try
+        	LogResult.logStdOut("call ComplexTypes.primitiveHostProgram11");
+			ComplexTypes.primitiveHostProgram11(rec);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.char20 value");
+            LogResult.assertStringEqual("Fail rec.char20", "abcdYYYYY", rec.char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lchar20 value");
+            LogResult.assertStringEqual("Fail rec.lchar20", "defgYYYYY", rec.lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.unicode20 value");
+            LogResult.assertStringEqual("Fail rec.unicode20", "xyz ZZZZZZZZZZ", rec.unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lunicode20 value");
+            LogResult.assertStringEqual("Fail rec.lunicode20", "abc ZZZZZZZZZZ", rec.lunicode20);
+		end
+	end
+	function bin1signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin1sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin1sign", 97, rec.bin1sign);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin2sign", 999, rec.bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin4sign", 10000, rec.bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin8sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin8sign", 100001, rec.bin8sign);
+		end
+	end
+	function dec174Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec174 value");
+            LogResult.assertDecimalEqual("Fail rec.dec174", 10043.67, rec.dec174);
+		end
+	end
+	function dec8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec8 value");
+            LogResult.assertDecimalEqual("Fail rec.dec8", 100012, rec.dec8);
+		end
+	end
+	function num150Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num150 value");
+            LogResult.assertDecimalEqual("Fail rec.num150", 1003, rec.num150);
+		end
+	end
+	function num112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num112 value");
+            LogResult.assertDecimalEqual("Fail rec.num112", 109.61, rec.num112);
+		end
+	end
+	function bin1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin1 value");
+            LogResult.assertBigIntEqual("Fail rec.bin1", 103, rec.bin1);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2 value");
+            LogResult.assertBigIntEqual("Fail rec.bin2", 1004, rec.bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4 value");
+            LogResult.assertBigIntEqual("Fail rec.bin4", 10005, rec.bin4);
+		end
+	end
+	function bin8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin8 value");
+            LogResult.assertBigIntEqual("Fail rec.bin8", 100006, rec.bin8);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date1 value");
+            LogResult.assertDateEqual("Fail rec.date1", "11/29/2016", rec.date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date2 value");
+            LogResult.assertDateEqual("Fail rec.date2", "10/24/2002", rec.date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date3 value");
+            LogResult.assertDateEqual("Fail rec.date3", "09/08/1927", rec.date3);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time1 value");
+            LogResult.assertTimeEqual("Fail rec.time1", "22:59:39", rec.time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time2 value");
+            LogResult.assertTimeEqual("Fail rec.time2", "12:19:08", rec.time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time3 value");
+            LogResult.assertTimeEqual("Fail rec.time3", "06:50:48", rec.time3);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.timestamp1 value");
+            LogResult.assertTimestampEqual("Fail rec.timestamp1", "2017/07/16 22:59:39", rec.timestamp1);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float4 value");
+            LogResult.assertFloatEqual("Fail rec.float4", 8.99 as smallfloat, rec.float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float8 value");
+            LogResult.assertFloatEqual("Fail rec.float8", 9.99, rec.float8);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/HandlerFields2.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/HandlerFields2.egl
new file mode 100644
index 0000000..7bec809
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/HandlerFields2.egl
@@ -0,0 +1,203 @@
+package server.test.rpg.handlers;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.rpg.programs.ComplexTypes;
+import server.host.rpg.programs.data.handlers.Handler2;
+
+// basic library
+library HandlerFields2
+	
+	rec Handler2;
+	testParameters boolean = true;
+	function test1(){@Test}
+		rec.char20 = "abcd"; 
+		rec.lchar20 = "defg"; 
+		rec.unicode20 = "xyz"; 
+		rec.lunicode20 = "abc"; 
+		rec.bin1sign = -1;
+		rec.bin2sign = 1;
+		rec.bin4sign = 2;
+		rec.bin8sign = 3;
+		rec.dec174 = 45.67;
+		rec.dec8 = 14;
+		rec.num150 = 5;
+		rec.num112 = 11.61;
+		rec.bin1 = 5;
+		rec.bin2 = 6;
+		rec.bin4  = 7;
+		rec.bin8  = 8;
+		rec.date1 = "06/24/2011";
+		rec.date2 = "05/19/1997";
+		rec.date3 = "04/03/1922";
+		rec.time1 = "17:54:34";
+		rec.time2 = "07:14:03";
+		rec.time3 = "01:45:43";
+		rec.timestamp1 = "2012/02/11 17:54:34";
+		rec.float4 = 8;
+		rec.float8 = 9;
+		try
+        	LogResult.logStdOut("call ComplexTypes.primitiveHostProgram12");
+			ComplexTypes.primitiveHostProgram12(rec);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.char20 value");
+            LogResult.assertStringEqual("Fail rec.char20", "abcdYYYYY", rec.char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lchar20 value");
+            LogResult.assertStringEqual("Fail rec.lchar20", "defgYYYYY", rec.lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.unicode20 value");
+            LogResult.assertStringEqual("Fail rec.unicode20", "xyz ZZZZZZZZZZ", rec.unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lunicode20 value");
+            LogResult.assertStringEqual("Fail rec.lunicode20", "abc ZZZZZZZZZZ", rec.lunicode20);
+		end
+	end
+	function bin1signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin1sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin1sign", 97, rec.bin1sign);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin2sign", 999, rec.bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin4sign", 10000, rec.bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin8sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin8sign", 100001, rec.bin8sign);
+		end
+	end
+	function dec174Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec174 value");
+            LogResult.assertDecimalEqual("Fail rec.dec174", 10043.67, rec.dec174);
+		end
+	end
+	function dec8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec8 value");
+            LogResult.assertDecimalEqual("Fail rec.dec8", 100012, rec.dec8);
+		end
+	end
+	function num150Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num150 value");
+            LogResult.assertDecimalEqual("Fail rec.num150", 1003, rec.num150);
+		end
+	end
+	function num112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num112 value");
+            LogResult.assertDecimalEqual("Fail rec.num112", 109.61, rec.num112);
+		end
+	end
+	function bin1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin1 value");
+            LogResult.assertBigIntEqual("Fail rec.bin1", 103, rec.bin1);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2 value");
+            LogResult.assertBigIntEqual("Fail rec.bin2", 1004, rec.bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4 value");
+            LogResult.assertBigIntEqual("Fail rec.bin4", 10005, rec.bin4);
+		end
+	end
+	function bin8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin8 value");
+            LogResult.assertBigIntEqual("Fail rec.bin8", 100006, rec.bin8);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date1 value");
+            LogResult.assertDateEqual("Fail rec.date1", "11/29/2016", rec.date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date2 value");
+            LogResult.assertDateEqual("Fail rec.date2", "10/24/2002", rec.date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date3 value");
+            LogResult.assertDateEqual("Fail rec.date3", "09/08/1927", rec.date3);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time1 value");
+            LogResult.assertTimeEqual("Fail rec.time1", "22:59:39", rec.time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time2 value");
+            LogResult.assertTimeEqual("Fail rec.time2", "12:19:08", rec.time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time3 value");
+            LogResult.assertTimeEqual("Fail rec.time3", "06:50:48", rec.time3);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.timestamp1 value");
+            LogResult.assertTimestampEqual("Fail rec.timestamp1", "2017/07/16 22:59:39", rec.timestamp1);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float4 value");
+            LogResult.assertFloatEqual("Fail rec.float4", 8.99 as smallfloat, rec.float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float8 value");
+            LogResult.assertFloatEqual("Fail rec.float8", 9.99, rec.float8);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/HandlerFields3.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/HandlerFields3.egl
new file mode 100644
index 0000000..937e291
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/HandlerFields3.egl
@@ -0,0 +1,203 @@
+package server.test.rpg.handlers;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.rpg.programs.ComplexTypes;
+import server.host.rpg.programs.data.handlers.Handler3;
+
+// basic library
+library HandlerFields3
+	
+	rec Handler3;
+	testParameters boolean = true;
+	function test1(){@Test}
+		rec.char20 = "abcd"; 
+		rec.lchar20 = "defg"; 
+		rec.unicode20 = "xyz"; 
+		rec.lunicode20 = "abc"; 
+		rec.bin1sign = -1;
+		rec.bin2sign = 1;
+		rec.bin4sign = 2;
+		rec.bin8sign = 3;
+		rec.dec174 = 45.67;
+		rec.dec8 = 14;
+		rec.num150 = 5;
+		rec.num112 = 11.61;
+		rec.bin1 = 5;
+		rec.bin2 = 6;
+		rec.bin4  = 7;
+		rec.bin8  = 8;
+		rec.date1 = "06/24/2011";
+		rec.date2 = "05/19/1997";
+		rec.date3 = "04/03/1922";
+		rec.time1 = "17:54:34";
+		rec.time2 = "07:14:03";
+		rec.time3 = "01:45:43";
+		rec.timestamp1 = "2012/02/11 17:54:34";
+		rec.float4 = 8;
+		rec.float8 = 9;
+		try
+        	LogResult.logStdOut("call ComplexTypes.primitiveHostProgram13");
+			ComplexTypes.primitiveHostProgram13(rec);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.char20 value");
+            LogResult.assertStringEqual("Fail rec.char20", "abcdYYYYY           ", rec.char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lchar20 value");
+            LogResult.assertStringEqual("Fail rec.lchar20", "defgYYYYY           ", rec.lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.unicode20 value");
+            LogResult.assertStringEqual("Fail rec.unicode20", "xyz ZZZZZZZZZZ      ", rec.unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.lunicode20 value");
+            LogResult.assertStringEqual("Fail rec.lunicode20", "abc ZZZZZZZZZZ      ", rec.lunicode20);
+		end
+	end
+	function bin1signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin1sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin1sign", 97, rec.bin1sign);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin2sign", 999, rec.bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin4sign", 10000, rec.bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin8sign value");
+            LogResult.assertBigIntEqual("Fail rec.bin8sign", 100001, rec.bin8sign);
+		end
+	end
+	function dec174Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec174 value");
+            LogResult.assertDecimalEqual("Fail rec.dec174", 10043.67, rec.dec174);
+		end
+	end
+	function dec8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.dec8 value");
+            LogResult.assertDecimalEqual("Fail rec.dec8", 100012, rec.dec8);
+		end
+	end
+	function num150Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num150 value");
+            LogResult.assertDecimalEqual("Fail rec.num150", 1003, rec.num150);
+		end
+	end
+	function num112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.num112 value");
+            LogResult.assertDecimalEqual("Fail rec.num112", 109.61, rec.num112);
+		end
+	end
+	function bin1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin1 value");
+            LogResult.assertBigIntEqual("Fail rec.bin1", 103, rec.bin1);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin2 value");
+            LogResult.assertBigIntEqual("Fail rec.bin2", 1004, rec.bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin4 value");
+            LogResult.assertBigIntEqual("Fail rec.bin4", 10005, rec.bin4);
+		end
+	end
+	function bin8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.bin8 value");
+            LogResult.assertBigIntEqual("Fail rec.bin8", 100006, rec.bin8);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date1 value");
+            LogResult.assertDateEqual("Fail rec.date1", "11/29/2016", rec.date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date2 value");
+            LogResult.assertDateEqual("Fail rec.date2", "10/24/2002", rec.date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.date3 value");
+            LogResult.assertDateEqual("Fail rec.date3", "09/08/1927", rec.date3);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time1 value");
+            LogResult.assertTimeEqual("Fail rec.time1", "22:59:39", rec.time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time2 value");
+            LogResult.assertTimeEqual("Fail rec.time2", "12:19:08", rec.time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.time3 value");
+            LogResult.assertTimeEqual("Fail rec.time3", "06:50:48", rec.time3);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.timestamp1 value");
+            LogResult.assertTimestampEqual("Fail rec.timestamp1", "2017/07/16 22:59:39", rec.timestamp1);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float4 value");
+            LogResult.assertFloatEqual("Fail rec.float4", 8.99 as smallfloat, rec.float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing rec.float8 value");
+            LogResult.assertFloatEqual("Fail rec.float8", 9.99, rec.float8);
+		end
+	end
+
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/arrays/HandlerFields.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/arrays/HandlerFields.egl
new file mode 100644
index 0000000..9621f32
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/arrays/HandlerFields.egl
@@ -0,0 +1,311 @@
+package server.test.rpg.handlers.arrays;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import server.host.rpg.programs.ComplexTypeArrays;
+import server.host.rpg.programs.data.handlers.Handler1;
+import server.host.rpg.programs.data.handlers.Handler11;
+
+
+// basic library
+library HandlerFields
+	
+	rec Handler11[];
+	function test1(){@Test}
+		rec = new Handler11[0];
+		rec.appendElement(createHandler11());
+		rec.appendElement(createHandler11());
+		try
+        	LogResult.logStdOut("call ComplexTypeArrays.primitiveHostProgram4");
+			validCount int;
+			ComplexTypeArrays.primitiveHostProgram4(rec, validCount);
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	private function createHandler11()returns(Handler11)
+		r Handler11{
+					rec = createHandler1(),
+					char20 = ["abcd", "EFG"], 
+					unicode20 = ["xyz", "1234"], 
+					lchar20 = ["ABCD", "efg"],
+					lunicode20 = ["XYZ", "4321"], 
+					bin1sign = [-1,-2],
+					bin2sign = [1,2],
+					bin4sign = [3,4],
+					bin8sign = [4,5],
+					dec174 = [45.67, 64.97],
+					dec8 = [6,7],
+					num150 = [8,9],
+					num112 = [11.61, 56.72],
+					bin1 = [8,9],
+					bin2 = [10,11],
+					bin4  = [12,13],
+					bin8  = [14,15],
+					date1 = ["06/24/2011" ,"03/12/1011"],
+					date2 = ["05/19/1997", "01/02/1947"],
+					date3 = ["04/03/1922", "07/24/1822"],
+					time1 = ["06:24:20" ,"13:12:11"],
+					time2 = ["05:19:19", "11:02:47"],
+					time3 = ["04:03:22", "17:24:22"],
+					timestamp1 = ["2012/02/11 17:54:34", "1812/06/01 08:45:26"],
+					float4 = [14,15],
+					float8 = [16,17],
+					recA = new Handler1[0]
+		};
+		r.recA.appendElement(createHandler1());  
+		r.recA.appendElement(createHandler1());  
+		return(r);
+	end
+	private function createHandler1()returns(Handler1)
+		return(new Handler1{
+							char20 = "abcd", 
+							unicode20 = "xyz", 
+							lchar20 = "defg", 
+							lunicode20 = "abc", 
+							bin1sign = -1,
+							bin2sign = 1,
+							bin4sign = 2,
+							bin8sign = 3,
+							dec174 = 45.67,
+							dec8 = 14,
+							num150 = 5,
+							num112 = 11.61,
+							bin1 = 5,
+							bin2 = 6,
+							bin4  = 7,
+							bin8  = 8,
+							date1 = "06/24/2011",
+							date2 = "05/19/1997",
+							date3 = "04/03/1922",
+							time1 = "17:54:34",
+							time2 = "07:14:03",
+							time3 = "01:45:43",
+							timestamp1 = "2012/02/11 17:54:34",
+							float4 = 8,
+							float8 = 9
+					});
+	end
+	function recsTest(){@Test {}}
+        LogResult.assertBigIntEqual("Fail rec.getSize()", 5, rec.getSize());
+	end
+	function rec_char20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "].char20.getSize()", 4, rec[idx].char20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[1]", "abcdYYYYY", rec[idx].char20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[2]", "EFGYYYYY", rec[idx].char20[2]);
+	    end
+	end
+	function rec_unicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "]unicode20.getSize()", 4, rec[idx].unicode20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[1]", "xyz ZZZZZZZZZZ", rec[idx].unicode20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[2]", "1234ZZZZZZZZZZ", rec[idx].unicode20[2]); 
+		end
+	end
+	function lchar20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lchar20.getSize()", 4, rec[idx].lchar20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[1]", "ABCDYYYYY", rec[idx].lchar20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[2]", "efgYYYYY", rec[idx].lchar20[2]);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lunicode20.getSize()", 4, rec[idx].lunicode20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[1]", "XYZ ZZZZZZZZZZ", rec[idx].lunicode20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[2]", "4321ZZZZZZZZZZ", rec[idx].lunicode20[2]); 
+		end
+	end
+	function rec_bin1signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1sign.getSize()", 4, rec[idx].bin1sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1sign[1]", 97, rec[idx].bin1sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1sign[2]", 96, rec[idx].bin1sign[2]);
+		end
+	end
+	function rec_bin2signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign.getSize()", 4, rec[idx].bin2sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[1]", 999, rec[idx].bin2sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[2]", 1000, rec[idx].bin2sign[2]);
+		end
+	end
+	function rec_bin4signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign.getSize()", 4, rec[idx].bin4sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[1]", 10001, rec[idx].bin4sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[2]", 10002, rec[idx].bin4sign[2]);
+		end
+	end
+	function rec_bin8signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign.getSize()", 4, rec[idx].bin8sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[1]", 100002, rec[idx].bin8sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[2]", 100003, rec[idx].bin8sign[2]);
+		end
+	end
+	function rec_dec174Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec174.getSize()", 4, rec[idx].dec174.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec174[1]", 10043.67, rec[idx].dec174[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec174[2]", 10062.97, rec[idx].dec174[2]);
+		end
+	end
+	function rec_dec8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec8.getSize()", 4, rec[idx].dec8.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec8[1]", 100004, rec[idx].dec8[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec8[2]", 100005, rec[idx].dec8[2]);
+		end
+	end
+	function num150Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num150.getSize()", 4, rec[idx].num150.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num150[1]", 1006, rec[idx].num150[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num150[2]", 1007, rec[idx].num150[2]);
+		end
+	end
+	function rec_num112Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num112.getSize()", 4, rec[idx].num112.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num112[1]", 109.61, rec[idx].num112[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num112[2]", 154.72, rec[idx].num112[2]);
+		end
+	end
+	function rec_bin1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1.getSize()", 4, rec[idx].bin1.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1[1]", 106, rec[idx].bin1[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1[2]", 107, rec[idx].bin1[2]);
+		end
+	end
+	function rec_bin2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2.getSize()", 4, rec[idx].bin2.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[1]", 1008, rec[idx].bin2[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[2]", 1009, rec[idx].bin2[2]);
+		end
+	end
+
+	function rec_bin4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4.getSize()", 4, rec[idx].bin4.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[1]", 10010, rec[idx].bin4[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[2]", 10011, rec[idx].bin4[2]);
+		end
+	end
+	function rec_bin8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8.getSize()", 4, rec[idx].bin8.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8[1]", 100012, rec[idx].bin8[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8[2]", 100013, rec[idx].bin8[2]);
+		end
+	end
+	function rec_date1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date1.getSize()", 4, rec[idx].date1.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[1]", "11/29/2016", rec[idx].date1[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[2]", "08/17/1016", rec[idx].date1[2]);
+		end
+	end
+	function rec_date2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date2.getSize()", 4, rec[idx].date2.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[1]", "10/24/2002", rec[idx].date2[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[2]", "06/07/1952", rec[idx].date2[2]);
+		end
+	end
+
+	function rec_date3Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date3.getSize()", 4, rec[idx].date3.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[1]", "09/08/1927", rec[idx].date3[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[2]", "12/29/1827", rec[idx].date3[2]);
+		end
+	end
+	function time1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]time1.getSize()", 4, rec[idx].time1.getSize());
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time1[1]", "11:29:25", rec[idx].time1[1]);
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time1[2]", "18:17:16", rec[idx].time1[2]);
+		end
+	end
+	function time2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]time2.getSize()", 4, rec[idx].time2.getSize());
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time2[1]", "10:24:24", rec[idx].time2[1]);
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time2[2]", "16:07:52", rec[idx].time2[2]);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]time3.getSize()", 4, rec[idx].time3.getSize());
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time3[1]", "09:08:27", rec[idx].time3[1]);
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time3[2]", "22:29:27", rec[idx].time3[2]);
+		end
+	end
+	function rec_timestamp1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]timestamp1.getSize()", 4, rec[idx].timestamp1.getSize());
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[1]", "2017/07/16 22:59:39", rec[idx].timestamp1[1]);
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[2]", "1817/11/06 13:50:31", rec[idx].timestamp1[2]);
+		end
+	end
+	function rec_float4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float4.getSize()", 4, rec[idx].float4.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[1]", 14.99 as smallfloat, rec[idx].float4[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[2]", 15.99 as smallfloat, rec[idx].float4[2]);
+		end
+	end
+	function rec_float8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float8.getSize()", 4, rec[idx].float8.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[1]", 16.99, rec[idx].float8[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[2]", 17.99, rec[idx].float8[2]);
+		end
+	end
+	function rec_recTest(){@Test {}}
+		for(idx int from 1 to 2)
+			recTest(rec[idx].rec, "rec[" + idx + "].rec");
+		end
+	end
+	function rec_recATest(){@Test {}}
+		for(idx1 int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx1 + "]recA.getSize()", 4, rec[idx1].recA.getSize());
+			for(idx2 int from 1 to 2)
+				recTest(rec[idx1].recA[idx2], "rec[" + idx1 + "].recA[" + idx2 + "]");
+			end
+		end
+	end
+	private function recTest(rec_rec Handler1 in, name String in)
+        LogResult.assertStringEqual("Fail " + name + ".char20", "abcdYYYYY", rec_rec.char20);
+        LogResult.assertStringEqual("Fail " + name + ".unicode20", "xyz ZZZZZZZZZZ", rec_rec.unicode20);
+        LogResult.assertStringEqual("Fail " + name + ".lchar20", "defgYYYYY", rec_rec.lchar20);
+        LogResult.assertStringEqual("Fail " + name + ".lunicode20", "abc ZZZZZZZZZZ", rec_rec.lunicode20);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin1sign", 97, rec_rec.bin1sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2sign", 999, rec_rec.bin2sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4sign", 10000, rec_rec.bin4sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin8sign", 100001, rec_rec.bin8sign);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec174", 10043.67, rec_rec.dec174);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec8", 100012, rec_rec.dec8);
+        LogResult.assertDecimalEqual("Fail " + name + ".num150", 1003, rec_rec.num150);
+        LogResult.assertDecimalEqual("Fail " + name + ".num112", 109.61, rec_rec.num112);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin1", 103, rec_rec.bin1);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2", 1004, rec_rec.bin2);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4", 10005, rec_rec.bin4);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin8", 100006, rec_rec.bin8);
+        LogResult.assertDateEqual("Fail " + name + ".date1", "11/29/2016", rec_rec.date1);
+        LogResult.assertDateEqual("Fail " + name + ".date2", "10/24/2002", rec_rec.date2);
+        LogResult.assertDateEqual("Fail " + name + ".date3", "09/08/1927", rec_rec.date3);
+        LogResult.assertTimeEqual("Fail " + name + ".time1", "22:59:39", rec_rec.time1);
+        LogResult.assertTimeEqual("Fail " + name + ".time2", "12:19:08", rec_rec.time2);
+        LogResult.assertTimeEqual("Fail " + name + ".time3", "06:50:48", rec_rec.time3);
+        LogResult.assertTimestampEqual("Fail " + name + ".timestamp1", "2017/07/16 22:59:39", rec_rec.timestamp1);
+        LogResult.assertFloatEqual("Fail " + name + ".float8", 9.99, rec_rec.float8);
+        LogResult.assertFloatEqual("Fail " + name + ".float4", 8.99 as smallfloat, rec_rec.float4);
+	end
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/arrays/HandlerFields2.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/arrays/HandlerFields2.egl
new file mode 100644
index 0000000..b409785
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/arrays/HandlerFields2.egl
@@ -0,0 +1,311 @@
+package server.test.rpg.handlers.arrays;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import server.host.rpg.programs.ComplexTypeArrays;
+import server.host.rpg.programs.data.handlers.Handler12;
+import server.host.rpg.programs.data.handlers.Handler2;
+
+
+// basic library
+library HandlerFields2
+	
+	rec Handler12[];
+	function test1(){@Test}
+		rec = new Handler12[0];
+		rec.appendElement(createHandler12());
+		rec.appendElement(createHandler12());
+		try
+        	LogResult.logStdOut("call ComplexTypeArrays.primitiveHostProgram5");
+			validCount int;
+			ComplexTypeArrays.primitiveHostProgram5(rec, validCount);
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	private function createHandler12()returns(Handler12)
+		r Handler12{
+					rec = createHandler2(),
+					char20 = ["abcd", "EFG"], 
+					unicode20 = ["xyz", "1234"], 
+					lchar20 = ["ABCD", "efg"],
+					lunicode20 = ["XYZ", "4321"], 
+					bin1sign = [-1,-2],
+					bin2sign = [1,2],
+					bin4sign = [3,4],
+					bin8sign = [4,5],
+					dec174 = [45.67, 64.97],
+					dec8 = [6,7],
+					num150 = [8,9],
+					num112 = [11.61, 56.72],
+					bin1 = [8,9],
+					bin2 = [10,11],
+					bin4  = [12,13],
+					bin8  = [14,15],
+					date1 = ["06/24/2011" ,"03/12/1011"],
+					date2 = ["05/19/1997", "01/02/1947"],
+					date3 = ["04/03/1922", "07/24/1822"],
+					time1 = ["06:24:20" ,"13:12:11"],
+					time2 = ["05:19:19", "11:02:47"],
+					time3 = ["04:03:22", "17:24:22"],
+					timestamp1 = ["2012/02/11 17:54:34", "1812/06/01 08:45:26"],
+					float4 = [14,15],
+					float8 = [16,17],
+					recA = new Handler2[0]
+		};
+		r.recA.appendElement(createHandler2());  
+		r.recA.appendElement(createHandler2());  
+		return(r);
+	end
+	private function createHandler2()returns(Handler2)
+		return(new Handler2{
+							char20 = "abcd", 
+							unicode20 = "xyz", 
+							lchar20 = "defg", 
+							lunicode20 = "abc", 
+							bin1sign = -1,
+							bin2sign = 1,
+							bin4sign = 2,
+							bin8sign = 3,
+							dec174 = 45.67,
+							dec8 = 14,
+							num150 = 5,
+							num112 = 11.61,
+							bin1 = 5,
+							bin2 = 6,
+							bin4  = 7,
+							bin8  = 8,
+							date1 = "06/24/2011",
+							date2 = "05/19/1997",
+							date3 = "04/03/1922",
+							time1 = "17:54:34",
+							time2 = "07:14:03",
+							time3 = "01:45:43",
+							timestamp1 = "2012/02/11 17:54:34",
+							float4 = 8,
+							float8 = 9
+					});
+	end
+	function recsTest(){@Test {}}
+        LogResult.assertBigIntEqual("Fail rec.getSize()", 5, rec.getSize());
+	end
+	function rec_char20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "].char20.getSize()", 4, rec[idx].char20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[1]", "abcdYYYYY", rec[idx].char20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[2]", "EFGYYYYY", rec[idx].char20[2]);
+	    end
+	end
+	function rec_unicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "]unicode20.getSize()", 4, rec[idx].unicode20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[1]", "xyz ZZZZZZZZZZ", rec[idx].unicode20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[2]", "1234ZZZZZZZZZZ", rec[idx].unicode20[2]); 
+		end
+	end
+	function lchar20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lchar20.getSize()", 4, rec[idx].lchar20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[1]", "ABCDYYYYY", rec[idx].lchar20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[2]", "efgYYYYY", rec[idx].lchar20[2]);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lunicode20.getSize()", 4, rec[idx].lunicode20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[1]", "XYZ ZZZZZZZZZZ", rec[idx].lunicode20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[2]", "4321ZZZZZZZZZZ", rec[idx].lunicode20[2]); 
+		end
+	end
+	function rec_bin1signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1sign.getSize()", 4, rec[idx].bin1sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1sign[1]", 97, rec[idx].bin1sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1sign[2]", 96, rec[idx].bin1sign[2]);
+		end
+	end
+	function rec_bin2signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign.getSize()", 4, rec[idx].bin2sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[1]", 999, rec[idx].bin2sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[2]", 1000, rec[idx].bin2sign[2]);
+		end
+	end
+	function rec_bin4signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign.getSize()", 4, rec[idx].bin4sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[1]", 10001, rec[idx].bin4sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[2]", 10002, rec[idx].bin4sign[2]);
+		end
+	end
+	function rec_bin8signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign.getSize()", 4, rec[idx].bin8sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[1]", 100002, rec[idx].bin8sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[2]", 100003, rec[idx].bin8sign[2]);
+		end
+	end
+	function rec_dec174Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec174.getSize()", 4, rec[idx].dec174.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec174[1]", 10043.67, rec[idx].dec174[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec174[2]", 10062.97, rec[idx].dec174[2]);
+		end
+	end
+	function rec_dec8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec8.getSize()", 4, rec[idx].dec8.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec8[1]", 100004, rec[idx].dec8[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec8[2]", 100005, rec[idx].dec8[2]);
+		end
+	end
+	function num150Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num150.getSize()", 4, rec[idx].num150.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num150[1]", 1006, rec[idx].num150[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num150[2]", 1007, rec[idx].num150[2]);
+		end
+	end
+	function rec_num112Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num112.getSize()", 4, rec[idx].num112.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num112[1]", 109.61, rec[idx].num112[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num112[2]", 154.72, rec[idx].num112[2]);
+		end
+	end
+	function rec_bin1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1.getSize()", 4, rec[idx].bin1.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1[1]", 106, rec[idx].bin1[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1[2]", 107, rec[idx].bin1[2]);
+		end
+	end
+	function rec_bin2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2.getSize()", 4, rec[idx].bin2.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[1]", 1008, rec[idx].bin2[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[2]", 1009, rec[idx].bin2[2]);
+		end
+	end
+
+	function rec_bin4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4.getSize()", 4, rec[idx].bin4.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[1]", 10010, rec[idx].bin4[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[2]", 10011, rec[idx].bin4[2]);
+		end
+	end
+	function rec_bin8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8.getSize()", 4, rec[idx].bin8.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8[1]", 100012, rec[idx].bin8[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8[2]", 100013, rec[idx].bin8[2]);
+		end
+	end
+	function rec_date1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date1.getSize()", 4, rec[idx].date1.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[1]", "11/29/2016", rec[idx].date1[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[2]", "08/17/1016", rec[idx].date1[2]);
+		end
+	end
+	function rec_date2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date2.getSize()", 4, rec[idx].date2.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[1]", "10/24/2002", rec[idx].date2[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[2]", "06/07/1952", rec[idx].date2[2]);
+		end
+	end
+
+	function rec_date3Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date3.getSize()", 4, rec[idx].date3.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[1]", "09/08/1927", rec[idx].date3[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[2]", "12/29/1827", rec[idx].date3[2]);
+		end
+	end
+	function time1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]time1.getSize()", 4, rec[idx].time1.getSize());
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time1[1]", "11:29:25", rec[idx].time1[1]);
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time1[2]", "18:17:16", rec[idx].time1[2]);
+		end
+	end
+	function time2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]time2.getSize()", 4, rec[idx].time2.getSize());
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time2[1]", "10:24:24", rec[idx].time2[1]);
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time2[2]", "16:07:52", rec[idx].time2[2]);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]time3.getSize()", 4, rec[idx].time3.getSize());
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time3[1]", "09:08:27", rec[idx].time3[1]);
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time3[2]", "22:29:27", rec[idx].time3[2]);
+		end
+	end
+	function rec_timestamp1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]timestamp1.getSize()", 4, rec[idx].timestamp1.getSize());
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[1]", "2017/07/16 22:59:39", rec[idx].timestamp1[1]);
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[2]", "1817/11/06 13:50:31", rec[idx].timestamp1[2]);
+		end
+	end
+	function rec_float4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float4.getSize()", 4, rec[idx].float4.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[1]", 14.99 as smallfloat, rec[idx].float4[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[2]", 15.99 as smallfloat, rec[idx].float4[2]);
+		end
+	end
+	function rec_float8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float8.getSize()", 4, rec[idx].float8.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[1]", 16.99, rec[idx].float8[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[2]", 17.99, rec[idx].float8[2]);
+		end
+	end
+	function rec_recTest(){@Test {}}
+		for(idx int from 1 to 2)
+			recTest(rec[idx].rec, "rec[" + idx + "].rec");
+		end
+	end
+	function rec_recATest(){@Test {}}
+		for(idx1 int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx1 + "]recA.getSize()", 4, rec[idx1].recA.getSize());
+			for(idx2 int from 1 to 2)
+				recTest(rec[idx1].recA[idx2], "rec[" + idx1 + "].recA[" + idx2 + "]");
+			end
+		end
+	end
+	private function recTest(rec_rec Handler2 in, name String in)
+        LogResult.assertStringEqual("Fail " + name + ".char20", "abcdYYYYY", rec_rec.char20);
+        LogResult.assertStringEqual("Fail " + name + ".unicode20", "xyz ZZZZZZZZZZ", rec_rec.unicode20);
+        LogResult.assertStringEqual("Fail " + name + ".lchar20", "defgYYYYY", rec_rec.lchar20);
+        LogResult.assertStringEqual("Fail " + name + ".lunicode20", "abc ZZZZZZZZZZ", rec_rec.lunicode20);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin1sign", 97, rec_rec.bin1sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2sign", 999, rec_rec.bin2sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4sign", 10000, rec_rec.bin4sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin8sign", 100001, rec_rec.bin8sign);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec174", 10043.67, rec_rec.dec174);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec8", 100012, rec_rec.dec8);
+        LogResult.assertDecimalEqual("Fail " + name + ".num150", 1003, rec_rec.num150);
+        LogResult.assertDecimalEqual("Fail " + name + ".num112", 109.61, rec_rec.num112);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin1", 103, rec_rec.bin1);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2", 1004, rec_rec.bin2);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4", 10005, rec_rec.bin4);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin8", 100006, rec_rec.bin8);
+        LogResult.assertDateEqual("Fail " + name + ".date1", "11/29/2016", rec_rec.date1);
+        LogResult.assertDateEqual("Fail " + name + ".date2", "10/24/2002", rec_rec.date2);
+        LogResult.assertDateEqual("Fail " + name + ".date3", "09/08/1927", rec_rec.date3);
+        LogResult.assertTimeEqual("Fail " + name + ".time1", "22:59:39", rec_rec.time1);
+        LogResult.assertTimeEqual("Fail " + name + ".time2", "12:19:08", rec_rec.time2);
+        LogResult.assertTimeEqual("Fail " + name + ".time3", "06:50:48", rec_rec.time3);
+        LogResult.assertTimestampEqual("Fail " + name + ".timestamp1", "2017/07/16 22:59:39", rec_rec.timestamp1);
+        LogResult.assertFloatEqual("Fail " + name + ".float8", 9.99, rec_rec.float8);
+        LogResult.assertFloatEqual("Fail " + name + ".float4", 8.99 as smallfloat, rec_rec.float4);
+	end
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/arrays/HandlerFields3.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/arrays/HandlerFields3.egl
new file mode 100644
index 0000000..c3f565b
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/handlers/arrays/HandlerFields3.egl
@@ -0,0 +1,311 @@
+package server.test.rpg.handlers.arrays;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import server.host.rpg.programs.ComplexTypeArrays;
+import server.host.rpg.programs.data.handlers.Handler13;
+import server.host.rpg.programs.data.handlers.Handler3;
+
+
+// basic library
+library HandlerFields3
+	
+	rec Handler13[];
+	function test1(){@Test}
+		rec = new Handler13[0];
+		rec.appendElement(createHandler13());
+		rec.appendElement(createHandler13());
+		try
+        	LogResult.logStdOut("call ComplexTypeArrays.primitiveHostProgram6");
+			validCount int;
+			ComplexTypeArrays.primitiveHostProgram6(rec, validCount);
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	private function createHandler13()returns(Handler13)
+		r Handler13{
+					rec = createHandler3(),
+					char20 = ["abcd", "EFG"], 
+					unicode20 = ["xyz", "1234"], 
+					lchar20 = ["ABCD", "efg"],
+					lunicode20 = ["XYZ", "4321"], 
+					bin1sign = [-1,-2],
+					bin2sign = [1,2],
+					bin4sign = [3,4],
+					bin8sign = [4,5],
+					dec174 = [45.67, 64.97],
+					dec8 = [6,7],
+					num150 = [8,9],
+					num112 = [11.61, 56.72],
+					bin1 = [8,9],
+					bin2 = [10,11],
+					bin4  = [12,13],
+					bin8  = [14,15],
+					date1 = ["06/24/2011" ,"03/12/1011"],
+					date2 = ["05/19/1997", "01/02/1947"],
+					date3 = ["04/03/1922", "07/24/1822"],
+					time1 = ["06:24:20" ,"13:12:11"],
+					time2 = ["05:19:19", "11:02:47"],
+					time3 = ["04:03:22", "17:24:22"],
+					timestamp1 = ["2012/02/11 17:54:34", "1812/06/01 08:45:26"],
+					float4 = [14,15],
+					float8 = [16,17],
+					recA = new Handler3[0]
+		};
+		r.recA.appendElement(createHandler3());  
+		r.recA.appendElement(createHandler3());  
+		return(r);
+	end
+	private function createHandler3()returns(Handler3)
+		return(new Handler3{
+							char20 = "abcd", 
+							unicode20 = "xyz", 
+							lchar20 = "defg", 
+							lunicode20 = "abc", 
+							bin1sign = -1,
+							bin2sign = 1,
+							bin4sign = 2,
+							bin8sign = 3,
+							dec174 = 45.67,
+							dec8 = 14,
+							num150 = 5,
+							num112 = 11.61,
+							bin1 = 5,
+							bin2 = 6,
+							bin4  = 7,
+							bin8  = 8,
+							date1 = "06/24/2011",
+							date2 = "05/19/1997",
+							date3 = "04/03/1922",
+							time1 = "17:54:34",
+							time2 = "07:14:03",
+							time3 = "01:45:43",
+							timestamp1 = "2012/02/11 17:54:34",
+							float4 = 8,
+							float8 = 9
+					});
+	end
+	function recsTest(){@Test {}}
+        LogResult.assertBigIntEqual("Fail rec.getSize()", 2, rec.getSize());
+	end
+	function rec_char20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "].char20.getSize()", 2, rec[idx].char20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[1]", "abcdYYYYY           ", rec[idx].char20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "].char20[2]", "EFGYYYYY            ", rec[idx].char20[2]);
+	    end
+	end
+	function rec_unicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+	        LogResult.assertBigIntEqual("Fail rec[" + idx + "]unicode20.getSize()", 2, rec[idx].unicode20.getSize());
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[1]", "xyz ZZZZZZZZZZ      ", rec[idx].unicode20[1]);
+	        LogResult.assertStringEqual("Fail rec[" + idx + "]unicode20[2]", "1234ZZZZZZZZZZ      ", rec[idx].unicode20[2]); 
+		end
+	end
+	function lchar20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lchar20.getSize()", 2, rec[idx].lchar20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[1]", "ABCDYYYYY           ", rec[idx].lchar20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lchar20[2]", "efgYYYYY            ", rec[idx].lchar20[2]);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]lunicode20.getSize()", 2, rec[idx].lunicode20.getSize());
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[1]", "XYZ ZZZZZZZZZZ      ", rec[idx].lunicode20[1]);
+            LogResult.assertStringEqual("Fail rec[" + idx + "]lunicode20[2]", "4321ZZZZZZZZZZ      ", rec[idx].lunicode20[2]); 
+		end
+	end
+	function rec_bin1signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1sign.getSize()", 2, rec[idx].bin1sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1sign[1]", 97, rec[idx].bin1sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1sign[2]", 96, rec[idx].bin1sign[2]);
+		end
+	end
+	function rec_bin2signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign.getSize()", 2, rec[idx].bin2sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[1]", 999, rec[idx].bin2sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2sign[2]", 1000, rec[idx].bin2sign[2]);
+		end
+	end
+	function rec_bin4signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign.getSize()", 2, rec[idx].bin4sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[1]", 10001, rec[idx].bin4sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4sign[2]", 10002, rec[idx].bin4sign[2]);
+		end
+	end
+	function rec_bin8signTest(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign.getSize()", 2, rec[idx].bin8sign.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[1]", 100002, rec[idx].bin8sign[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8sign[2]", 100003, rec[idx].bin8sign[2]);
+		end
+	end
+	function rec_dec174Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec174.getSize()", 2, rec[idx].dec174.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec174[1]", 10043.67, rec[idx].dec174[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec174[2]", 10062.97, rec[idx].dec174[2]);
+		end
+	end
+	function rec_dec8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]dec8.getSize()", 2, rec[idx].dec8.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec8[1]", 100004, rec[idx].dec8[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]dec8[2]", 100005, rec[idx].dec8[2]);
+		end
+	end
+	function num150Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num150.getSize()", 2, rec[idx].num150.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num150[1]", 1006, rec[idx].num150[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num150[2]", 1007, rec[idx].num150[2]);
+		end
+	end
+	function rec_num112Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]num112.getSize()", 2, rec[idx].num112.getSize());
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num112[1]", 109.61, rec[idx].num112[1]);
+            LogResult.assertDecimalEqual("Fail rec[" + idx + "]num112[2]", 154.72, rec[idx].num112[2]);
+		end
+	end
+	function rec_bin1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1.getSize()", 2, rec[idx].bin1.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1[1]", 106, rec[idx].bin1[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin1[2]", 107, rec[idx].bin1[2]);
+		end
+	end
+	function rec_bin2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2.getSize()", 2, rec[idx].bin2.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[1]", 1008, rec[idx].bin2[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin2[2]", 1009, rec[idx].bin2[2]);
+		end
+	end
+
+	function rec_bin4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4.getSize()", 2, rec[idx].bin4.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[1]", 10010, rec[idx].bin4[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin4[2]", 10011, rec[idx].bin4[2]);
+		end
+	end
+	function rec_bin8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8.getSize()", 2, rec[idx].bin8.getSize());
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8[1]", 100012, rec[idx].bin8[1]);
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]bin8[2]", 100013, rec[idx].bin8[2]);
+		end
+	end
+	function rec_date1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date1.getSize()", 2, rec[idx].date1.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[1]", "11/29/2016", rec[idx].date1[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date1[2]", "08/17/1016", rec[idx].date1[2]);
+		end
+	end
+	function rec_date2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date2.getSize()", 2, rec[idx].date2.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[1]", "10/24/2002", rec[idx].date2[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date2[2]", "06/07/1952", rec[idx].date2[2]);
+		end
+	end
+
+	function rec_date3Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]date3.getSize()", 2, rec[idx].date3.getSize());
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[1]", "09/08/1927", rec[idx].date3[1]);
+            LogResult.assertDateEqual("Fail rec[" + idx + "]date3[2]", "12/29/1827", rec[idx].date3[2]);
+		end
+	end
+	function time1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]time1.getSize()", 2, rec[idx].time1.getSize());
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time1[1]", "11:29:25", rec[idx].time1[1]);
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time1[2]", "18:17:16", rec[idx].time1[2]);
+		end
+	end
+	function time2Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]time2.getSize()", 2, rec[idx].time2.getSize());
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time2[1]", "10:24:24", rec[idx].time2[1]);
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time2[2]", "16:07:52", rec[idx].time2[2]);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]time3.getSize()", 2, rec[idx].time3.getSize());
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time3[1]", "09:08:27", rec[idx].time3[1]);
+            LogResult.assertTimeEqual("Fail rec[" + idx + "]time3[2]", "22:29:27", rec[idx].time3[2]);
+		end
+	end
+	function rec_timestamp1Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]timestamp1.getSize()", 2, rec[idx].timestamp1.getSize());
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[1]", "2017/07/16 22:59:39", rec[idx].timestamp1[1]);
+            LogResult.assertTimestampEqual("Fail rec[" + idx + "]timestamp1[2]", "1817/11/06 13:50:31", rec[idx].timestamp1[2]);
+		end
+	end
+	function rec_float4Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float4.getSize()", 2, rec[idx].float4.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[1]", 14.99 as smallfloat, rec[idx].float4[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float4[2]", 15.99 as smallfloat, rec[idx].float4[2]);
+		end
+	end
+	function rec_float8Test(){@Test {}}
+		for(idx int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx + "]float8.getSize()", 2, rec[idx].float8.getSize());
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[1]", 16.99, rec[idx].float8[1]);
+            LogResult.assertFloatEqual("Fail rec[" + idx + "]float8[2]", 17.99, rec[idx].float8[2]);
+		end
+	end
+	function rec_recTest(){@Test {}}
+		for(idx int from 1 to 2)
+			recTest(rec[idx].rec, "rec[" + idx + "].rec");
+		end
+	end
+	function rec_recATest(){@Test {}}
+		for(idx1 int from 1 to 2)
+            LogResult.assertBigIntEqual("Fail rec[" + idx1 + "]recA.getSize()", 2, rec[idx1].recA.getSize());
+			for(idx2 int from 1 to 2)
+				recTest(rec[idx1].recA[idx2], "rec[" + idx1 + "].recA[" + idx2 + "]");
+			end
+		end
+	end
+	private function recTest(rec_rec Handler3 in, name String in)
+        LogResult.assertStringEqual("Fail " + name + ".char20", "abcdYYYYY           ", rec_rec.char20);
+        LogResult.assertStringEqual("Fail " + name + ".unicode20", "xyz ZZZZZZZZZZ      ", rec_rec.unicode20);
+        LogResult.assertStringEqual("Fail " + name + ".lchar20", "defgYYYYY           ", rec_rec.lchar20);
+        LogResult.assertStringEqual("Fail " + name + ".lunicode20", "abc ZZZZZZZZZZ      ", rec_rec.lunicode20);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin1sign", 97, rec_rec.bin1sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2sign", 999, rec_rec.bin2sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4sign", 10000, rec_rec.bin4sign);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin8sign", 100001, rec_rec.bin8sign);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec174", 10043.67, rec_rec.dec174);
+        LogResult.assertDecimalEqual("Fail " + name + ".dec8", 100012, rec_rec.dec8);
+        LogResult.assertDecimalEqual("Fail " + name + ".num150", 1003, rec_rec.num150);
+        LogResult.assertDecimalEqual("Fail " + name + ".num112", 109.61, rec_rec.num112);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin1", 103, rec_rec.bin1);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin2", 1004, rec_rec.bin2);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin4", 10005, rec_rec.bin4);
+        LogResult.assertBigIntEqual("Fail " + name + ".bin8", 100006, rec_rec.bin8);
+        LogResult.assertDateEqual("Fail " + name + ".date1", "11/29/2016", rec_rec.date1);
+        LogResult.assertDateEqual("Fail " + name + ".date2", "10/24/2002", rec_rec.date2);
+        LogResult.assertDateEqual("Fail " + name + ".date3", "09/08/1927", rec_rec.date3);
+        LogResult.assertTimeEqual("Fail " + name + ".time1", "22:59:39", rec_rec.time1);
+        LogResult.assertTimeEqual("Fail " + name + ".time2", "12:19:08", rec_rec.time2);
+        LogResult.assertTimeEqual("Fail " + name + ".time3", "06:50:48", rec_rec.time3);
+        LogResult.assertTimestampEqual("Fail " + name + ".timestamp1", "2017/07/16 22:59:39", rec_rec.timestamp1);
+        LogResult.assertFloatEqual("Fail " + name + ".float8", 9.99, rec_rec.float8);
+        LogResult.assertFloatEqual("Fail " + name + ".float4", 8.99 as smallfloat, rec_rec.float4);
+	end
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/Parameters.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/Parameters.egl
new file mode 100644
index 0000000..cdac89a
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/Parameters.egl
@@ -0,0 +1,313 @@
+package server.test.rpg.primitive;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import server.host.rpg.programs.Primitive;
+
+// basic library
+library Parameters
+	
+	char20 string; 
+	lchar20 string(20); 
+	unicode20 string; 
+	lunicode20 string(20); 
+	bin1sign smallint;
+	bin2sign smallint;
+	bin4sign int;
+	bin8sign bigint;
+	dec174 decimal(17,4);
+	dec80 decimal(8,0);
+	num15 decimal(15);
+	num112 decimal(11,2);
+	bin1 smallint;
+	bin2 int;
+	bin4 bigint;
+	bin8 decimal(20);
+	date1 date;
+	date2 date;
+	date3 date;
+	time1 time;
+	time2 time;
+	time3 time;
+	timestamp1 timestamp("yyyyMMddHHmmss");
+	float4 smallfloat;
+	float8 float;
+	testParameters boolean = true;
+	function call1(){@Test}
+		char20 = "abcd"; 
+		lchar20 = "defg"; 
+		unicode20 = "xyz"; 
+		lunicode20 = "abc"; 
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramText");
+			Primitive.primitiveHostProgramText(char20, lchar20, unicode20, lunicode20);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing char20 value");
+            LogResult.assertStringEqual("Fail char20", "abcdYYYYY", char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing lchar20 value");
+            LogResult.assertStringEqual("Fail lchar20", "defgYYYYY", lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing unicode20 value");
+            LogResult.assertStringEqual("Fail unicode20", "xyz ZZZZZZZZZZ", unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing lunicode20 value");
+            LogResult.assertStringEqual("Fail lunicode20", "abc ZZZZZZZZZZ", lunicode20);
+		end
+	end
+	function call2(){@Test}
+		bin1sign = -1;
+		bin2sign = 1;
+		bin4sign = 2;
+		bin8sign = 3;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramInt");
+			Primitive.primitiveHostProgramInt(bin1sign, bin2sign, bin4sign, bin8sign);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function bin1signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin1sign value");
+            LogResult.assertBigIntEqual("Fail bin1sign", 97, bin1sign);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin2sign value");
+            LogResult.assertBigIntEqual("Fail bin2sign", 999, bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin4sign value");
+            LogResult.assertBigIntEqual("Fail bin4sign", 10000, bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin8sign value");
+            LogResult.assertBigIntEqual("Fail bin8sign", 100001, bin8sign);
+		end
+	end
+	function call8(){@Test}
+		float4 = 8;
+		float8 = 9;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramFloat");
+			Primitive.primitiveHostProgramFloat(float4, float8);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing float4 value");
+            LogResult.assertFloatEqual("Fail float4", 8.99 as smallfloat, float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing float8 value");
+            LogResult.assertFloatEqual("Fail float8", 9.99, float8);
+		end
+	end
+
+	function call3(){@Test}
+		dec174 = 45.67;
+		dec80 = 14;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramPacked");
+			Primitive.primitiveHostProgramPacked(dec174, dec80);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing dec174 value");
+            LogResult.assertDecimalEqual("Fail dec174", 10043.67, dec174);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing dec80 value");
+            LogResult.assertDecimalEqual("Fail dec80", 100012, dec80);
+		end
+	end
+	function call4(){@Test}
+		num15 = 5;
+		num112 = 11.61;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramZoned");
+			Primitive.primitiveHostProgramZoned(num112, num15);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing num15 value");
+            LogResult.assertDecimalEqual("Fail num15", 1003, num15);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing num112 value");
+            LogResult.assertDecimalEqual("Fail num112", 109.61, num112);
+		end
+	end
+	function call5(){@Test}
+		bin1 = 5;
+		bin2 = 6;
+		bin4  = 7;
+		bin8  = 8;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramUInt");
+			Primitive.primitiveHostProgramUInt(bin1, bin2, bin4, bin8);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function bin1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin1 value");
+            LogResult.assertBigIntEqual("Fail bin1", 103, bin1);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin2 value");
+            LogResult.assertBigIntEqual("Fail bin2", 1004, bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin4 value");
+            LogResult.assertBigIntEqual("Fail bin4", 10005, bin4);
+		end
+	end
+	function bin8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin8 value");
+            LogResult.assertBigIntEqual("Fail bin8", 100006, bin8);
+		end
+	end
+	function call6(){@Test}
+		date1 = "06/24/2011";
+		date2 = "05/19/1997";
+		date3 = "04/03/1922";
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramDate");
+			Primitive.primitiveHostProgramDate(date1, date2, date3);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date1 value");
+            LogResult.assertDateEqual("Fail date1", "11/29/2016", date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date2 value");
+            LogResult.assertDateEqual("Fail date2", "10/24/2002", date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date3 value");
+            LogResult.assertDateEqual("Fail date3", "09/08/1927", date3);
+		end
+	end
+	function call6a(){@Test}
+		time1 = "17:54:34";
+		time2 = "07:14:03";
+		time3 = "01:45:43";
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramTime");
+			Primitive.primitiveHostProgramTime(time1, time2, time3);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time1 value");
+            LogResult.assertTimeEqual("Fail time1", "22:59:39", time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time2 value");
+            LogResult.assertTimeEqual("Fail time2", "12:19:08", time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time3 value");
+            LogResult.assertTimeEqual("Fail time3", "06:50:48", time3);
+		end
+	end
+	function call7(){@Test}
+		timestamp1 = "2012/02/11 17:54:34";
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramTimeStamp");
+			Primitive.primitiveHostProgramTimeStamp(timestamp1);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing timestamp1 value");
+            LogResult.assertTimestampEqual("Fail timestamp1", "2017/07/16 22:59:39", timestamp1);
+		end
+	end
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/Parameters2.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/Parameters2.egl
new file mode 100644
index 0000000..5887ff1
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/Parameters2.egl
@@ -0,0 +1,313 @@
+package server.test.rpg.primitive;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import server.host.rpg.programs.Primitive;
+
+// basic library
+library Parameters2
+	
+	char20 string; 
+	lchar20 string(20); 
+	unicode20 string; 
+	lunicode20 string(20); 
+	bin1sign smallint;
+	bin2sign smallint;
+	bin4sign int;
+	bin8sign bigint;
+	dec174 decimal(17,4);
+	dec80 decimal(8,0);
+	num15 decimal(15);
+	num112 decimal(11,2);
+	bin1 smallint;
+	bin2 int;
+	bin4 bigint;
+	bin8 decimal(20);
+	date1 date;
+	date2 date;
+	date3 date;
+	time1 time;
+	time2 time;
+	time3 time;
+	timestamp1 timestamp("yyyyMMddHHmmss");
+	float4 smallfloat;
+	float8 float;
+	testParameters boolean = true;
+	function call1(){@Test}
+		char20 = "abcd"; 
+		lchar20 = "defg"; 
+		unicode20 = "xyz"; 
+		lunicode20 = "abc"; 
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramText2");
+			Primitive.primitiveHostProgramText2(char20, lchar20, unicode20, lunicode20);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing char20 value");
+            LogResult.assertStringEqual("Fail char20", "abcdYYYYY", char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing lchar20 value");
+            LogResult.assertStringEqual("Fail lchar20", "defgYYYYY", lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing unicode20 value");
+            LogResult.assertStringEqual("Fail unicode20", "xyz ZZZZZZZZZZ", unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing lunicode20 value");
+            LogResult.assertStringEqual("Fail lunicode20", "abc ZZZZZZZZZZ", lunicode20);
+		end
+	end
+	function call2(){@Test}
+		bin1sign = -1;
+		bin2sign = 1;
+		bin4sign = 2;
+		bin8sign = 3;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramInt");
+			Primitive.primitiveHostProgramInt2(bin1sign, bin2sign, bin4sign, bin8sign);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function bin1signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin1sign value");
+            LogResult.assertBigIntEqual("Fail bin1sign", 97, bin1sign);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin2sign value");
+            LogResult.assertBigIntEqual("Fail bin2sign", 999, bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin4sign value");
+            LogResult.assertBigIntEqual("Fail bin4sign", 10000, bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin8sign value");
+            LogResult.assertBigIntEqual("Fail bin8sign", 100001, bin8sign);
+		end
+	end
+	function call8(){@Test}
+		float4 = 8;
+		float8 = 9;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramFloat");
+			Primitive.primitiveHostProgramFloat2(float4, float8);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing float4 value");
+            LogResult.assertFloatEqual("Fail float4", 8.99 as smallfloat, float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing float8 value");
+            LogResult.assertFloatEqual("Fail float8", 9.99, float8);
+		end
+	end
+
+	function call3(){@Test}
+		dec174 = 45.67;
+		dec80 = 14;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramPacked");
+			Primitive.primitiveHostProgramPacked2(dec174, dec80);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing dec174 value");
+            LogResult.assertDecimalEqual("Fail dec174", 10043.67, dec174);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing dec80 value");
+            LogResult.assertDecimalEqual("Fail dec80", 100012, dec80);
+		end
+	end
+	function call4(){@Test}
+		num15 = 5;
+		num112 = 11.61;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramZoned");
+			Primitive.primitiveHostProgramZoned2(num112, num15);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing num15 value");
+            LogResult.assertDecimalEqual("Fail num15", 1003, num15);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing num112 value");
+            LogResult.assertDecimalEqual("Fail num112", 109.61, num112);
+		end
+	end
+	function call5(){@Test}
+		bin1 = 5;
+		bin2 = 6;
+		bin4  = 7;
+		bin8  = 8;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramUInt");
+			Primitive.primitiveHostProgramUInt2(bin1, bin2, bin4, bin8);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function bin1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin1 value");
+            LogResult.assertBigIntEqual("Fail bin1", 103, bin1);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin2 value");
+            LogResult.assertBigIntEqual("Fail bin2", 1004, bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin4 value");
+            LogResult.assertBigIntEqual("Fail bin4", 10005, bin4);
+		end
+	end
+	function bin8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin8 value");
+            LogResult.assertBigIntEqual("Fail bin8", 100006, bin8);
+		end
+	end
+	function call6(){@Test}
+		date1 = "06/24/2011";
+		date2 = "05/19/1997";
+		date3 = "04/03/1922";
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramDate");
+			Primitive.primitiveHostProgramDate2(date1, date2, date3);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date1 value");
+            LogResult.assertDateEqual("Fail date1", "11/29/2016", date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date2 value");
+            LogResult.assertDateEqual("Fail date2", "10/24/2002", date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date3 value");
+            LogResult.assertDateEqual("Fail date3", "09/08/1927", date3);
+		end
+	end
+	function call6a(){@Test}
+		time1 = "17:54:34";
+		time2 = "07:14:03";
+		time3 = "01:45:43";
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramTime");
+			Primitive.primitiveHostProgramTime(time1, time2, time3);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time1 value");
+            LogResult.assertTimeEqual("Fail time1", "22:59:39", time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time2 value");
+            LogResult.assertTimeEqual("Fail time2", "12:19:08", time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time3 value");
+            LogResult.assertTimeEqual("Fail time3", "06:50:48", time3);
+		end
+	end
+	function call7(){@Test}
+		timestamp1 = "2012/02/11 17:54:34";
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramTimeStamp");
+			Primitive.primitiveHostProgramTimeStamp2(timestamp1);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing timestamp1 value");
+            LogResult.assertTimestampEqual("Fail timestamp1", "2017/07/16 22:59:39", timestamp1);
+		end
+	end
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/Parameters3.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/Parameters3.egl
new file mode 100644
index 0000000..7586a92
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/Parameters3.egl
@@ -0,0 +1,313 @@
+package server.test.rpg.primitive;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import server.host.rpg.programs.Primitive;
+
+// basic library
+library Parameters3
+	
+	char20 string; 
+	lchar20 string(20); 
+	unicode20 string; 
+	lunicode20 string(20); 
+	bin1sign smallint;
+	bin2sign smallint;
+	bin4sign int;
+	bin8sign bigint;
+	dec174 decimal(17,4);
+	dec80 decimal(8,0);
+	num15 decimal(15);
+	num112 decimal(11,2);
+	bin1 smallint;
+	bin2 int;
+	bin4 bigint;
+	bin8 decimal(20);
+	date1 date;
+	date2 date;
+	date3 date;
+	time1 time;
+	time2 time;
+	time3 time;
+	timestamp1 timestamp("yyyyMMddHHmmss");
+	float4 smallfloat;
+	float8 float;
+	testParameters boolean = true;
+	function call1(){@Test}
+		char20 = "abcd"; 
+		lchar20 = "defg"; 
+		unicode20 = "xyz"; 
+		lunicode20 = "abc"; 
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramText2");
+			Primitive.primitiveHostProgramText3(char20, lchar20, unicode20, lunicode20);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing char20 value");
+            LogResult.assertStringEqual("Fail char20", "abcdYYYYY           ", char20);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing lchar20 value");
+            LogResult.assertStringEqual("Fail lchar20", "defgYYYYY           ", lchar20);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing unicode20 value");
+            LogResult.assertStringEqual("Fail unicode20", "xyz ZZZZZZZZZZ      ", unicode20);
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing lunicode20 value");
+            LogResult.assertStringEqual("Fail lunicode20", "abc ZZZZZZZZZZ      ", lunicode20);
+		end
+	end
+	function call2(){@Test}
+		bin1sign = -1;
+		bin2sign = 1;
+		bin4sign = 2;
+		bin8sign = 3;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramInt");
+			Primitive.primitiveHostProgramInt3(bin1sign, bin2sign, bin4sign, bin8sign);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function bin1signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin1sign value");
+            LogResult.assertBigIntEqual("Fail bin1sign", 97, bin1sign);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin2sign value");
+            LogResult.assertBigIntEqual("Fail bin2sign", 999, bin2sign);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin4sign value");
+            LogResult.assertBigIntEqual("Fail bin4sign", 10000, bin4sign);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin8sign value");
+            LogResult.assertBigIntEqual("Fail bin8sign", 100001, bin8sign);
+		end
+	end
+	function call8(){@Test}
+		float4 = 8;
+		float8 = 9;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramFloat");
+			Primitive.primitiveHostProgramFloat3(float4, float8);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing float4 value");
+            LogResult.assertFloatEqual("Fail float4", 8.99 as smallfloat, float4);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing float8 value");
+            LogResult.assertFloatEqual("Fail float8", 9.99, float8);
+		end
+	end
+
+	function call3(){@Test}
+		dec174 = 45.67;
+		dec80 = 14;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramPacked");
+			Primitive.primitiveHostProgramPacked3(dec174, dec80);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function dec112Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing dec174 value");
+            LogResult.assertDecimalEqual("Fail dec174", 10043.67, dec174);
+		end
+	end
+	function dec15Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing dec80 value");
+            LogResult.assertDecimalEqual("Fail dec80", 100012, dec80);
+		end
+	end
+	function call4(){@Test}
+		num15 = 5;
+		num112 = 11.61;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramZoned");
+			Primitive.primitiveHostProgramZoned3(num112, num15);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function num6Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing num15 value");
+            LogResult.assertDecimalEqual("Fail num15", 1003, num15);
+		end
+	end
+	function num103Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing num112 value");
+            LogResult.assertDecimalEqual("Fail num112", 109.61, num112);
+		end
+	end
+	function call5(){@Test}
+		bin1 = 5;
+		bin2 = 6;
+		bin4  = 7;
+		bin8  = 8;
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramUInt");
+			Primitive.primitiveHostProgramUInt3(bin1, bin2, bin4, bin8);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function bin1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin1 value");
+            LogResult.assertBigIntEqual("Fail bin1", 103, bin1);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin2 value");
+            LogResult.assertBigIntEqual("Fail bin2", 1004, bin2);
+		end
+	end
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin4 value");
+            LogResult.assertBigIntEqual("Fail bin4", 10005, bin4);
+		end
+	end
+	function bin8Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing bin8 value");
+            LogResult.assertBigIntEqual("Fail bin8", 100006, bin8);
+		end
+	end
+	function call6(){@Test}
+		date1 = "06/24/2011";
+		date2 = "05/19/1997";
+		date3 = "04/03/1922";
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramDate");
+			Primitive.primitiveHostProgramDate3(date1, date2, date3);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date1 value");
+            LogResult.assertDateEqual("Fail date1", "11/29/2016", date1);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date2 value");
+            LogResult.assertDateEqual("Fail date2", "10/24/2002", date2);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing date3 value");
+            LogResult.assertDateEqual("Fail date3", "09/08/1927", date3);
+		end
+	end
+	function call6a(){@Test}
+		time1 = "17:54:34";
+		time2 = "07:14:03";
+		time3 = "01:45:43";
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramTime");
+			Primitive.primitiveHostProgramTime(time1, time2, time3);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time1 value");
+            LogResult.assertTimeEqual("Fail time1", "22:59:39", time1);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time2 value");
+            LogResult.assertTimeEqual("Fail time2", "12:19:08", time2);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing time3 value");
+            LogResult.assertTimeEqual("Fail time3", "06:50:48", time3);
+		end
+	end
+	function call7(){@Test}
+		timestamp1 = "2012/02/11 17:54:34";
+		try
+	       	LogResult.logStdOut("call Primitive.primitiveHostProgramTimeStamp");
+			Primitive.primitiveHostProgramTimeStamp3(timestamp1);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.logStdOut("testing timestamp1 value");
+            LogResult.assertTimestampEqual("Fail timestamp1", "2017/07/16 22:59:39", timestamp1);
+		end
+	end
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/arrays/Parameters.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/arrays/Parameters.egl
new file mode 100644
index 0000000..7e47d58
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/arrays/Parameters.egl
@@ -0,0 +1,349 @@
+package server.test.rpg.primitive.arrays;
+
+import org.eclipse.edt.eunit.runtime.LogResult;
+import org.eclipse.edt.eunit.runtime.Test;
+import eglx.lang.AnyException;
+import server.host.rpg.programs.PrimitiveArrays;
+
+
+// basic library
+library Parameters
+	
+	char20 string[]; 
+	lchar20 string(20)[]; 
+	unicode20 string[]; 
+	lunicode20 string(20)[]; 
+	bin1sign smallint[];
+	bin2sign smallint[];
+	bin4sign int[];
+	bin8sign bigint[];
+	dec174 decimal(17,4)[];
+	dec80 decimal(8,0)[];
+	num150 decimal(15)[];
+	num112 decimal(11,2)[];
+	bin1 smallint[];
+	bin2 int[];
+	bin4 bigint[];
+	bin8 decimal(20)[];
+	date1 date[];
+	date2 date[];
+	date3 date[];
+	time1 time[];
+	time2 time[];
+	time3 time[];
+	timestamp1 timestamp("yyyyMMddHHmmss")[];
+	float4 smallfloat[];
+	float8 float[];
+	testParameters boolean = true;
+	function call1(){@Test}
+		char20 = ["abcd", "EFG"]; 
+		unicode20 = ["xyz", "1234"]; 
+		lchar20 = ["ABCD", "efg"]; 
+		lunicode20 = ["XYZ", "4321"]; 
+		validCount int;
+		try
+	       	LogResult.logStdOut("call PrimitiveArrays.primitiveHostProgramText");
+			PrimitiveArrays.primitiveHostProgramText(char20, lchar20, unicode20, lunicode20, validCount);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail char20.getSize()", 4, char20.getSize());
+            LogResult.assertStringEqual("Fail char20[1]", "abcdYYYYY", char20[1]);
+            LogResult.assertStringEqual("Fail char20[2]", "EFGYYYYY", char20[2]);
+		end
+	end
+	function lchar20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail lchar20.getSize()", 4, lchar20.getSize());
+            LogResult.assertStringEqual("Fail lchar20[1]", "ABCDYYYYY", lchar20[1]);
+            LogResult.assertStringEqual("Fail lchar20[2]", "efgYYYYY", lchar20[2]);
+		end
+	end
+	function unicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail unicode20.getSize()", 4, unicode20.getSize());
+            LogResult.assertStringEqual("Fail unicode20[1]", "xyz ZZZZZZZZZZ", unicode20[1]);
+            LogResult.assertStringEqual("Fail unicode20[2]", "1234ZZZZZZZZZZ", unicode20[2]); 
+		end
+	end
+	function lunicode20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail lunicode20.getSize()", 4, lunicode20.getSize());
+            LogResult.assertStringEqual("Fail lunicode20[1]", "XYZ ZZZZZZZZZZ", lunicode20[1]);
+            LogResult.assertStringEqual("Fail lunicode20[2]", "4321ZZZZZZZZZZ", lunicode20[2]); 
+		end
+	end
+	function call2(){@Test}
+		bin1sign = [-1,-2];
+		bin2sign = [1,2];
+		bin4sign = [3,4];
+		bin8sign = [4,5];
+		validCount int;
+		try
+	       	LogResult.logStdOut("call PrimitiveArrays.primitiveHostProgramInt");
+			PrimitiveArrays.primitiveHostProgramInt(bin1sign, bin2sign, bin4sign, bin8sign, validCount);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function bin1signTest(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin1sign.getSize()", 4, bin1sign.getSize());
+            LogResult.assertBigIntEqual("Fail bin1sign[1]", 97, bin1sign[1]);
+            LogResult.assertBigIntEqual("Fail bin1sign[2]", 96, bin1sign[2]);
+		end
+	end
+	function bin2signTest(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin2sign.getSize()", 4, bin2sign.getSize());
+            LogResult.assertBigIntEqual("Fail bin2sign[1]", 999, bin2sign[1]);
+            LogResult.assertBigIntEqual("Fail bin2sign[2]", 1000, bin2sign[2]);
+		end
+	end
+	function bin4signTest(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin4sign.getSize()", 4, bin4sign.getSize());
+            LogResult.assertBigIntEqual("Fail bin4sign[1]", 10001, bin4sign[1]);
+            LogResult.assertBigIntEqual("Fail bin4sign[2]", 10002, bin4sign[2]);
+		end
+	end
+	function bin8signTest(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin8sign.getSize()", 4, bin8sign.getSize());
+            LogResult.assertBigIntEqual("Fail bin8sign[1]", 100002, bin8sign[1]);
+            LogResult.assertBigIntEqual("Fail bin8sign[2]", 100003, bin8sign[2]);
+		end
+	end
+	function call8(){@Test}
+		float4 = [14,15];
+		float8 = [16,17];
+		validCount int;
+		try
+	       	LogResult.logStdOut("call PrimitiveArrays.primitiveHostProgramFloat");
+			PrimitiveArrays.primitiveHostProgramFloat(float4, float8, validCount);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function float4Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail float4.getSize()", 4, float4.getSize());
+            LogResult.assertFloatEqual("Fail float4[1]", 14.99 as smallfloat, float4[1]);
+            LogResult.assertFloatEqual("Fail float4[2]", 15.99 as smallfloat, float4[2]);
+		end
+	end
+	function float8Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail float8.getSize()", 4, float8.getSize());
+            LogResult.assertFloatEqual("Fail float8[1]", 16.99, float8[1]);
+            LogResult.assertFloatEqual("Fail float8[2]", 17.99, float8[2]);
+		end
+	end
+	function call3(){@Test}
+		dec174 = [45.67, 64.97];
+		dec80 = [6,7];
+		validCount int;
+		try
+	       	LogResult.logStdOut("call PrimitiveArrays.primitiveHostProgramPack");
+			PrimitiveArrays.primitiveHostProgramPack(dec174, dec80, validCount);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function dec174Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail dec174.getSize()", 4, dec174.getSize());
+            LogResult.assertDecimalEqual("Fail dec174[1]", 10043.67, dec174[1]);
+            LogResult.assertDecimalEqual("Fail dec174[2]", 10062.97, dec174[2]);
+		end
+	end
+	function dec80Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail dec80.getSize()", 4, dec80.getSize());
+            LogResult.assertDecimalEqual("Fail dec80[1]", 100004, dec80[1]);
+            LogResult.assertDecimalEqual("Fail dec80[2]", 100005, dec80[2]);
+		end
+	end
+	function call4(){@Test}
+		num150 = [8,9];
+		num112 = [11.61, 56.72];
+		validCount int;
+		try
+	       	LogResult.logStdOut("call PrimitiveArrays.primitiveHostProgramZone");
+			PrimitiveArrays.primitiveHostProgramZone(num150, num112, validCount);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function num150Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail num150.getSize()", 4, num150.getSize());
+            LogResult.assertDecimalEqual("Fail num150[1]", 1006, num150[1]);
+            LogResult.assertDecimalEqual("Fail num150[2]", 1007, num150[2]);
+		end
+	end
+	function num112Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail num112.getSize()", 4, num112.getSize());
+            LogResult.assertDecimalEqual("Fail num112[1]", 109.61, num112[1]);
+            LogResult.assertDecimalEqual("Fail num112[2]", 154.72, num112[2]);
+		end
+	end
+	function call5(){@Test}
+		bin1 = [8,9];
+		bin2 = [10,11];
+		bin4  = [12,13];
+		bin8  = [14,15];
+		validCount int;
+		try
+	       	LogResult.logStdOut("call PrimitiveArrays.primitiveHostProgramUInt");
+			PrimitiveArrays.primitiveHostProgramUInt(bin1, bin2, bin4, bin8, validCount);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function bin1Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin1.getSize()", 4, bin1.getSize());
+            LogResult.assertBigIntEqual("Fail bin1[1]", 106, bin1[1]);
+            LogResult.assertBigIntEqual("Fail bin1[2]", 107, bin1[2]);
+		end
+	end
+	function bin2Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin2.getSize()", 4, bin2.getSize());
+            LogResult.assertBigIntEqual("Fail bin2[1]", 1008, bin2[1]);
+            LogResult.assertBigIntEqual("Fail bin2[2]", 1009, bin2[2]);
+		end
+	end
+
+	function bin4Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin4.getSize()", 4, bin4.getSize());
+            LogResult.assertBigIntEqual("Fail bin4[1]", 10010, bin4[1]);
+            LogResult.assertBigIntEqual("Fail bin4[2]", 10011, bin4[2]);
+		end
+	end
+	function bin8Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail bin8.getSize()", 4, bin8.getSize());
+            LogResult.assertBigIntEqual("Fail bin8[1]", 100012, bin8[1]);
+            LogResult.assertBigIntEqual("Fail bin8[2]", 100013, bin8[2]);
+		end
+	end
+	function call6(){@Test}
+		date1 = ["06/24/2011" ,"03/12/1011"];
+		date2 = ["05/19/1997", "01/02/1947"];
+		date3 = ["04/03/1922", "07/24/1822"];
+		validCount int;
+		try
+	       	LogResult.logStdOut("call PrimitiveArrays.primitiveHostProgramDate");
+			PrimitiveArrays.primitiveHostProgramDate(date1, date2, date3, validCount);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function date1Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail date1.getSize()", 4, date1.getSize());
+            LogResult.assertDateEqual("Fail date1[1]", "11/29/2016", date1[1]);
+            LogResult.assertDateEqual("Fail date1[2]", "08/17/1016", date1[2]);
+		end
+	end
+	function date2Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail date2.getSize()", 4, date2.getSize());
+            LogResult.assertDateEqual("Fail date2[1]", "10/24/2002", date2[1]);
+            LogResult.assertDateEqual("Fail date2[2]", "06/07/1952", date2[2]);
+		end
+	end
+
+	function date3Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail date3.getSize()", 4, date3.getSize());
+            LogResult.assertDateEqual("Fail date3[1]", "09/08/1927", date3[1]);
+            LogResult.assertDateEqual("Fail date3[2]", "12/29/1827", date3[2]);
+		end
+	end
+	function call6a(){@Test}
+		time1 = ["06:24:20" ,"13:12:11"];
+		time2 = ["05:19:19", "11:02:47"];
+		time3 = ["04:03:22", "17:24:22"];
+		validCount int;
+		try
+	       	LogResult.logStdOut("call PrimitiveArrays.primitiveHostProgramTime");
+			PrimitiveArrays.primitiveHostProgramTime(time1, time2, time3, validCount);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function time1Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail time1.getSize()", 4, time1.getSize());
+            LogResult.assertTimeEqual("Fail time1[1]", "11:29:25", time1[1]);
+            LogResult.assertTimeEqual("Fail time1[2]", "18:17:16", time1[2]);
+		end
+	end
+	function time2Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail time2.getSize()", 4, time2.getSize());
+            LogResult.assertTimeEqual("Fail time2[1]", "10:24:24", time2[1]);
+            LogResult.assertTimeEqual("Fail time2[2]", "16:07:52", time2[2]);
+		end
+	end
+
+	function time3Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail time3.getSize()", 4, time3.getSize());
+            LogResult.assertTimeEqual("Fail time3[1]", "09:08:27", time3[1]);
+            LogResult.assertTimeEqual("Fail time3[2]", "22:29:27", time3[2]);
+		end
+	end
+	function call7(){@Test}
+		timestamp1 = ["2012/02/11 17:54:34", "1812/06/01 08:45:26"];
+		validCount int;
+		try
+	       	LogResult.logStdOut("call PrimitiveArrays.primitiveHostProgramTimestamp");
+			PrimitiveArrays.primitiveHostProgramTimestamp(timestamp1, validCount);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function timestamp1Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail timestamp1.getSize()", 4, timestamp1.getSize());
+            LogResult.assertTimestampEqual("Fail timestamp1[1]", "2017/07/16 22:59:39", timestamp1[1]);
+            LogResult.assertTimestampEqual("Fail timestamp1[2]", "1817/11/06 13:50:31", timestamp1[2]);
+		end
+	end
+end
diff --git a/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/arrays/Parameters2.egl b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/arrays/Parameters2.egl
new file mode 100644
index 0000000..c351145
--- /dev/null
+++ b/tests/org.eclipse.edt.eunit.test.ibmi/thirdparty.programs/EGLSource/server/test/rpg/primitive/arrays/Parameters2.egl
@@ -0,0 +1,349 @@
+package server.test.rpg.primitive.arrays;
+
+import org.eclipse.edt.eunit.runtime.logresult;
+import org.eclipse.edt.eunit.runtime.test;
+import eglx.lang.anyexception;
+import server.host.rpg.programs.PrimitiveArrays;
+
+
+// basic library
+library Parameters2
+	
+	char20 string[]; 
+	lchar20 string(20)[]; 
+	unicode20 string[]; 
+	lunicode20 string(20)[]; 
+	bin1sign smallint[];
+	bin2sign smallint[];
+	bin4sign int[];
+	bin8sign bigint[];
+	dec174 decimal(17,4)[];
+	dec80 decimal(8,0)[];
+	num150 decimal(15)[];
+	num112 decimal(11,2)[];
+	bin1 smallint[];
+	bin2 int[];
+	bin4 bigint[];
+	bin8 decimal(20)[];
+	date1 date[];
+	date2 date[];
+	date3 date[];
+	time1 time[];
+	time2 time[];
+	time3 time[];
+	timestamp1 timestamp("yyyyMMddHHmmss")[];
+	float4 smallfloat[];
+	float8 float[];
+	testParameters boolean = true;
+	function call1(){@Test}
+		char20 = ["abcd", "EFG"]; 
+		unicode20 = ["xyz", "1234"]; 
+		lchar20 = ["ABCD", "efg"]; 
+		lunicode20 = ["XYZ", "4321"]; 
+		validCount int;
+		try
+	       	LogResult.logStdOut("call PrimitiveArrays.primitiveHostProgramText2");
+			PrimitiveArrays.primitiveHostProgramText2(char20, lchar20, unicode20, lunicode20, validCount);
+ 			testParameters = true;
+ 			LogResult.assertTrue1(true);
+ 		onException(exception AnyException)
+ 			testParameters = false;
+            LogResult.assertTrue(exception.message, false);
+		end
+	end
+	function char20Test(){@Test {}}
+		if(testParameters)
+            LogResult.assertBigIntEqual("Fail char20.getSize()", 4, char20.getSize());
+            LogResult.assertStringEqual("Fail char20[1]", "abcdYYYYY", char20[1]);
+            LogResult.assertStringEqual("Fail char20[2]", "EFGYYYYY", char20[2]);
+		end
+	end
+	f