dyndoc-ruby-core 1.0.0

data/dyndoc/Std/DynVar.dyn

@@ -0,0 +1,23 @@
+{#meth]set.DynVar[#,]field[:out][#,]content[][#rb<]@vars.extract_raw(#{=.ObjectName})[#{field}]=#{=content}[#}
+
+{#meth]delete.DynVar[#,]field[:out][#?]#{=field}[0,1]!=":"[#=]field[:#{field}]
+[#?]#{field} != :val[#rb<]@vars.extract_raw(#{=.ObjectName}).delete(#{field})
+[#}
+
+{#meth]rep.DynVar[#>]{#rep]#{#{.ObjectName}}[#}[#}
+
+{#meth]split.DynVar[#,]field[:split][#,]sep[&][#rb<] @vars.extract_raw(#{=.ObjectName})[#{field}]=#{=.content}.split(#{=sep})[#}
+
+{#meth]replicate.DynVar[#,]along[][#,]field[:out]
+[#?]#{=field}[0,1]!=":"[#=]field[:#{field}]
+[#?]#{field} != :val
+[#rb<]var,indices=#{=along}.split(" in ").map{|e| e.strip}
+#p indices
+[#rb<]indices=:r{c(:{indices})} #rb< is required!
+#p indices
+res=[][#rb<] 
+for :{var} in indices do 
+  res << {#<]#{.content!}[#}
+end
+@vars.extract_raw(#{=.ObjectName})[#{field}]=res
+[#}

data/dyndoc/Std/File.dyn

@@ -0,0 +1,55 @@
+{#def]pwd[#>] [#{_PWD_}] [#}
+
+{#def]filename[#>] [#{_FILENAME_}][#}
+
+{#def]curpath[#,]name[][#rb>]File.join(File.dirname("#{_FILENAME_}"),"#{name}")[#}
+
+{#def]curExpPath[#,]name[][#rb>]require 'dyndoc/common/file';CqlsDoc.expand_path(File.join(File.dirname("#{_FILENAME_CURRENT_}"),"#{name}"))[#}
+
+{#def]home[#rb>][ENV["HOME"]][#}
+
+{#def]modedoc[#rb>]Dyndoc.tmpl_mngr.fmt[#}
+
+{#def]local_use[#rb>]$dyndoc_web and $dyndoc_web[:local][#def}
+
+
+This doc mode is used to know if it is obtained by web
+{#def]dyndoc_mode[#rb>]Dyndoc.tmpl_mngr.dyndocMode.inspect[#}
+
+{#def]format_output[#rb>]Dyndoc.tmpl_mngr.fmtOutput[#}
+
+{#def]cqlsdir[#rb>]File.join(ENV["HOME"],"cqls")[#}
+
+{#def]dyndir[#rb>]File.join(ENV["HOME"],"dyndoc")[#}
+
+{#def]prjpath[#,]prj[][#,]type[rsrc]
+[#>][{#case]#{type}
+[#when]rsrc[#rb>][File.join(ENV["CQLS_PRJ_ROOT"],"share","rsrc","#{prj}")]
+[#when]img[#rb>][File.join(ENV["CQLS_PRJ_ROOT"],"share","rsrc","#{prj}","img")]
+[#when]data[#rb>][File.join(ENV["CQLS_PRJ_ROOT"],"share","rsrc","#{prj}","data")]
+[#case}]
+[#}
+
+{#def]cqlsweb_path[#,]path[][#,]root[/export/cqlsWeb]
+[#rb>]dyndocWeb_path=(File.exists? File.join(ENV["HOME"],"dyndoc","web")) ? File.join(ENV["HOME"],"dyndoc","web") : #{=root}
+File.join(dyndocWeb_path,#{=path})
+[#def}
+
+{#def]cqlsweb_rsrc_path[#,]path[][#>]{#cqlsweb_path]public/rsrc/#{path}[#cqlsweb_path}[#def}
+
+{#def]cqlsweb_auto_img[#,]path[][#,]max[5000]
+[#=]path2[{#cqlsweb_path]public/rsrc/img/#{path}[#}]
+[#rb<]now=Time.now;Dir["#{path2}*"].each {|f| begin p f;FileUtils.rm(f) end if now-File.mtime(f) > 60}
+[#>][#{path2}:{`uuidgen`.strip}]
+[#def}
+
+{#def]cqlsweb_public_imgName[#,]path[]
+[#rb<]root="{#cqlsweb_path]path[][#}"+"public/"
+puts "root";p root
+rbpath=#{=path}
+p rbpath
+tmp=/^#{root}/.match(rbpath)
+p tmp
+res = tmp ? tmp.post_match : "error"
+[#>]:{"/"+res}
+[#def}

data/dyndoc/Std/Git.dyn

@@ -0,0 +1,34 @@
+[#%] Git for dyn: accessing file in some git directory
+require grit or maybe simply import the used functions
+[#first][#rb<]$dyn_git=[]
+[#main][#<]
+{#def]git[#,]from[.git][#,]branch[HEAD][#,]path[][#,]as[][#%]as is UNUSED from now
+[#?]#{0?as}[#>]as[#{path}][#?]end
+[#rb<]
+from_pathname=File.expand_path(#{=from})
+if File.exist? from_pathname
+  if !(from_pathname =~ /\.git$/) and File.exist?(File.join(from_pathname,".git"))
+    from_pathname=File.join(from_pathname,".git")
+  else
+    puts "WARNING! #{from_pathname} does not contain a git repository!"
+  end 
+elsif File.exist? from_pathname+".git"
+  from_pathname=from_pathname+".git"
+end
+#p from_pathname
+pathname=File.expand_path(#{=path})
+if File.exist? pathname
+  FileUtils.cp(pathname,pathname+".__DYN_ORIG__")
+end
+[#rb<]
+`git --git-dir=:{from_pathname} checkout #{branch} :{pathname}`
+[#rb<]
+as_pathname=pathname+".__DYN_GIT__"
+FileUtils.mv(pathname,as_pathname)
+$dyn_git << as_pathname
+FileUtils.mv(pathname+".__DYN_ORIG__",pathname) if File.exist? pathname+".__DYN_ORIG__"
+[#rb>]as_pathname
+[#def}
+[#last][#rb<]$dyn_git.uniq.each{|pathname| 
+  FileUtils.rm_f(pathname)
+} 

data/dyndoc/Std/List.dyn

@@ -0,0 +1,46 @@
+## each and keys methods for List class (see dyndoc-ruby-demo/BaseLang/List.dyn)
+
+
+{#hide]
+Does not work! To debug! 
+{#meth]keys.List[#rb>]@vars.extract("self.content").keys[#}
+[#hide}
+
+{#meth]listkeys.List[#rb>]@vars.extract("self.content").keys[#}
+
+{#meth]each.List[#,]fct[]
+[#?]#{0?fct}[#rb>]
+@vars.extract_raw(".content").each do |k,v| #
+  {#>][#=].key[:{k}][#=].value[:{v[:val]}][#yield]default[#>}
+end
+[#?]else[#rb>]
+@vars.extract_raw(".content").each do |k,v| #
+  {#>][#=].key[:{k}][#=].value[:{v[:val]}][#>]{#call]#{fct}[#,]#{.key}[#,]#{.value}[#call}[#>}
+end
+[#meth}
+
+## The code below is just here for old compatibility but would be remove or update soon
+
+{#def]List[#,]list[#rb<]@vars.local[:prev][#{=list}]={}[#}
+
+{#meth]apply.List[#,]_key_[key][#,]_elt_[val]
+[#rb>]_key_[#{=_key_}.strip]
+[#rb>]_elt_[#{=_elt_}.strip]
+[#rb<]
+@nb={} unless @nb
+@keysList={} unless @keysList
+@nb[#{=_elt_}]=#{#.content}
+@keysList[#{=_elt_}]=@vars.extract("self.content").keys.sort
+@ind={} unless @ind
+@ind[#{=_elt_}]=-1
+[#>]
+[{#loop][#rb<][@ind[#{=_elt_}]+=1]
+[#=]#{_key_}[:{@keysList[#{=_elt_}][@ind[#{=_elt_}]]}]
+[#=]#{_elt_}[:self.content.#{#{_key_}}]
+[#yield]default
+[#break]:{@ind[#{=_elt_}]==@nb[#{=_elt_}]-1}
+[#}]
+[#rb<]@ind[#{=_elt_}]=-1
+@nb.delete(#{=_elt_})
+@keysList.delete(#{=_elt_})
+[#}

data/dyndoc/Std/OOP.dyn

@@ -0,0 +1,32 @@
+
+{#meth]class.Object[#>]#{self.Class}[#}
+
+{#meth]objname.Object[#>]#{self.ObjectName}[#}
+
+{#meth]self.Object[#>]:#{self.ObjectName}[#}
+
+{#meth]link.Object[#,]to[][#<]{#if]@vars.extract("self").respond_to? "keys" and @vars.extract(#{=to}).respond_to? "keys"
+[#rb<]p #{=to};p @vars.extract("self").keys; p @vars.extract(#{=to}).keys;p #{=to}
+vset=@vars.extract(#{=to}).keys - @vars.extract("self").keys
+i=-1
+[#<]{#loop][#rb<]v=vset[i+=1]
+p v;p [#{=.ObjectName},#{=to}]
+[#=].:{v}[:#{to}.:{v}]
+[#break]vset.length==i
+[#loop}
+[#if}
+[#meth}
+
+{#meth]inspect.Object[#,]verbatim[true]
+[#?]#{verbatim}[#>]\begin{verbatim}
+[#>] [Class: [#{self.Class}]]
+[#?]#{=self.ObjectName}[#>][
+  |ObjectName: [#{self.ObjectName}]
+  |True variable content: 
+  |:{@vars.extract_list(#{=self.ObjectName})}]
+[#?]#{=self.content}[#>][
+  |self variable content:
+  |:{@vars.extract_list("self.content")}]
+[#?]#{verbatim}[#>][<\n>\end][#>][{verbatim}]
+[#}
+

data/dyndoc/Std/Signal.dyn

@@ -0,0 +1,18 @@
+[#first][#rb<]$dyn_signal={}
+[#main]
+{#def]connect[#,]signal[][#,]object[][#,]method[][#,]priority[100]
+[#rb<]
+$dyn_signal[#{=signal}]=[] unless $dyn_signal[#{=signal}]
+$dyn_signal[#{=signal}] << [#{priority},#{=object},#{=method}]
+$dyn_signal[#{=signal}].sort!{|e,e2| ((e[0]<e2[0] or (e[0]==e2[0] and e[1]<e2[1])) ? -1 : 1)}
+[#}
+ 
+{#def]emit[#,]signal[][#,]args[]
+  [#rb<]
+  signal=$dyn_signal[#{=signal}]
+  ind=-1
+  [#>]{#loop][#break]ind==signal.length-1
+	[#rb<][priority,object,method=signal[ind+=1]]
+	[#>][{#call]:{method}[#,]:{object}[#,]_args_[:args][#}]
+      [#}
+[#}

data/dyndoc/Std/String.dyn

@@ -0,0 +1,22 @@
+{#meth]rep.String[#,]nb[1][#,]sep[][#,]along[]
+[#?]#{0?along}[#rb>](#{=.content.value}+#{=sep})*(#{nb}-1)[#>][#{.content.value}]
+[#?]else[#%]string is supposed to be a #code block
+[#rb<]res=[][#<]{#for]#{along}[#rb<]res << #{=.content.value!}[#}
+[#rb>][res.join(#{=sep})]
+[#}
+
+{#meth]join.String[#,]sep[][#>]{#join]self.content.ary[#}[#}
+
+{#meth]apply.String[#,]_elt_[elt]
+[#rb<]
+  @nb={} unless @nb
+  @nb[#{=_elt_}]=#{#.content.ary}
+  @ind={} unless @ind
+  @ind[#{=_elt_}]=-1
+[#>]
+[{#loop][#rb<]@ind[#{=_elt_}]+=1
+  [#>]#{_elt_}[#{self.content.ary.:{@ind[#{=_elt_}]}}]
+  [#yield]default
+  [#break]:{@ind[#{=_elt_}]==@nb[#{=_elt_}]-1}
+[#}]
+[#}

data/dyndoc/Std/Styles.dyn

@@ -0,0 +1 @@
+{#require]Style/Text/Std[#}

data/dyndoc/Std/Test.dyn

@@ -0,0 +1,282 @@
+[#package]\usepackage{xcolor}
+[#preamble]\newcommand{\ok}{ \textcolor{green}{\large$\surd$}}
+\newcommand{\nok}{ \textcolor{red}{\large X}}
+[#main][#<]
+
+New Mode: since #test exists and allows
+
+-> In some directory, place all the result files!
+-> The first time, (i.e. if the file does not exist) the file is created.
+-> In the mode of documentation: the code is output and the result too.
+-> When asking for the result, it is extracted from the result file.
+-> In the testing mode: the code is executed and compred with the result file.
+Rmk: the weird  thing is that code is in the dyn file when the resukt is not!!!!
+I guess that the two modes need to be consistent! The result has to be embedded in the dyn file when the code is too.
+
+
+ 
+# OLD STUFF!
+{#def]openTag[#,]tag[blck][#,]verb![false]
+[#?]#{verb}[#>][\verb!][#?]end
+[#>]
+  [_{_#|
+  |#{tag}]]
+[#?]#{verb}[#>][!]
+[#}
+
+{#def]closeTag[#,]tag[][#,]verb![false]
+[#?]#{verb}[#>][\verb!][#?]end
+[#>] 
+  [[#|
+  |#{tag}_}_] 
+[#?]#{verb}[#>][!]
+[#}
+
+{#def]instrTag[#,]tag[][#,]verb![false]
+[#?]#{verb}[#>][\verb!][#?]end
+[#>] 
+  [[#|
+  |#{tag}]] 
+[#?]#{verb}[#>][!]
+[#}
+
+{#def]checkCode[#,]key[][#,]result[]
+[#r<] p #{=result}
+[#?]#{=result}=='{#dyn]test|#{key}[#}'[#>]\ok[#?]else[#>]\nok[#>][\hrulefill]
+[#}
+
+## OLD STUFF
+
+{#def]dynverb[#,]code[][#,]file[]
+[#rb>]code[(#{=file}.empty?) ? @protected_txt : (Utils.protect_txt_block(CqlsDoc.input_from_file(#{=file})))]
+[#>][{#verb]#{code}[#}]
+[#}
+
+
+{#def]runTestCode[#,]code[][#,]verbatim[true]
+[#>]result[{#dyn]#{code}[#}]
+[#>] [\noindent \fbox{\textbf{Code}} \hrulefill
+{#beginVerb#}
+:{@protected_txt}
+{#endVerb#}
+\noindent \fbox{\textbf{Result}} \hrulefill<\n>] 
+[#?]#{verbatim}[#>][{#beginVerb#}<\n>]
+[#?]true[#>]#{result}
+[#?]#{verbatim}[#>]{#endVerb#}
+[#?]true[#>]\hrule
+\vspace*{.5cm}
+[#}
+
+{#def]testCodeAndCheck[#,]file[test][#,]code[]
+[#>]result[{#dyn]#{code}[#}]
+[#>>]#{file}.output?[#{result}]
+[#>] [\noindent \fbox{\textbf{Code}: :{CqlsDoc::Utils.escape(#{=file},["\_","\\\_"])}}\hrulefill\\
+{#beginVerb#} 
+:{@protected_txt}
+{#endVerb#}
+\noindent \fbox{\textbf{Result}: :{CqlsDoc::Utils.escape(#{=file},["\_","\\\_"])}}\hrulefill\\ #{result}\\
+\noindent \fbox{\textbf{Checked}: :{CqlsDoc::Utils.escape(#{=file},["\_","\\\_"])}    {#if]#{=result}=='#F{#{file}.output}'[#>]\ok[#else]\nok[#}}\hrulefill
+]
+[#}
+
+
+
+{#def]testFile[#,]file[test.dyn][#,]verbatim[true]
+[#>] code [#F{!:{CqlsDoc.doc_filename(#{=file})}}]
+[#rb<]code=Utils.protect_txt_block(CqlsDoc.input_from_file("#{file}"))
+[#>] [\noindent \fbox{\textbf{Code (from file \texttt{:{CqlsDoc::Utils.escape(#{=file},["\_","\\\_"])}})}}  \hrulefill
+{#beginVerb#}
+:{code}
+{#endVerb#}
+]
+[#>]result[{#dyn]#{code}[#}]
+[#>] [\noindent \fbox{\textbf{Result}} \hrulefill] 
+[#?]#{verbatim}[#rb>]result[#{=result}.gsub("\\begin{verbatim}","\\begin{__VERBATIM__}").gsub("\\end{verbatim}","\\end{__VERBATIM__}")][#>][{#beginVerb#}
+][#?]end
+[#>][#{result}]
+[#?]#{verbatim}[#>][
+{#endVerb#}
+]
+[#?]true[#>]\hrule
+\vspace*{.5cm}
+[#}
+
+{#def]testFileAndCheck[#,]file[test]
+[#>] code [#F{#{file}.dyn}]
+[#rb<]code=Utils.protect_txt_block(File.read("#{file}.dyn"))
+[#>]result[{#dyn]#{code}[#}]
+[#>>]#{file}.output?[#{result}]
+[#>] [\noindent \fbox{\textbf{Code}: :{CqlsDoc::Utils.escape(#{=file},["\_","\\\_"])}}\hrulefill
+{#beginVerb#}
+#rb{code}
+{#endVerb#}
+\noindent \fbox{\textbf{Result}: :{CqlsDoc::Utils.escape(#{=file},["\_","\\\_"])}}\hrulefill\\ #{result}\\
+\noindent \fbox{\textbf{Checked}: :{CqlsDoc::Utils.escape(#{=file},["\_","\\\_"])}    {#if]#{=result}=='#F{#{file}.output}'[#>]\ok[#else]\nok[#}}\hrulefill
+]
+[#}
+
+{#def]protxt[#rb>]@protected_txt[#}
+
+ 
+
+{#hide]
+NEW SPIRIT!!!!
+
+===========================
+Object for testing dyn code
+===========================
+
+[#<]
+
+{#meth]new.Tester[#,].dir[output/][#=].report@[{}][#=].tests@[[]][#}
+
+{#meth]testCode.Tester[#,]key[][#,]code[][#,]file[][#,]expected[][#,]descr[][#,]view[false]
+[#?]#{=key}[-1,1]=="!"[#rb>]key[#{=key}[0...-1]][#=]view[true][#rb<]p "key #{key} registered!" [#?]else[#rb<]p "too bad!"
+[#?]#{+?file}
+  [#=]code[#F{#{file}.dyn}]
+  [#rb<]code=Utils.protect_txt_block(File.read("#{file}.dyn"))
+[#?]else
+  [#rb<]code=@protected_txt;#p code;p #{=code}
+[#?]end
+[#=]result[{#dyn]#{code}[#}]
+[#rb<]
+expectedFile=File.join(#{=.dir},<key:>)
+
+<expected:> = File.read(expectedFile) if <expected:>.empty? and File.exists?(expectedFile)
+
+unless File.exists?(expectedFile)
+  File.open(expectedFile,"w") do |f| 
+    #puts "result"; p #{=result}
+    f << <result:>
+  end 
+end
+
+<.tests@> << <key:>
+#p <.codes@>
+<.report@>[<key:>]={:type=>:code,:code=>code,:expected=> <expected:> ,:result=> <result:>,:file=> <file:>,:descr => <descr:>}
+[#?]#{view}[#>]{#theCode]self[#,]#{key}[#}
+[#meth-test}
+
+{#meth]testRCode.Tester[#,]key[][#,]code[][#,]file[][#,]expected[][#,]seed[10][#,]descr[]
+[#?]#{+?file}[#=]code[#F{#{file}.dyn}][#?]end
+[#rb<]code=#{=code}.strip
+[#r<]set.seed(#{seed})
+[#=]result[{#rverb]:{code}[#}]
+[#rb<]
+expectedFile=File.join(#{=.dir},<key:>)
+
+<expected:> = File.read(expectedFile) if <expected:>.empty? and File.exists?(expectedFile)
+
+unless File.exists?(expectedFile)
+  File.open(expectedFile,"w") do |f| #do not remove!!!!!
+    #puts "result"; p #{=result}
+    f << <result:>
+  end 
+end
+
+<.tests@> << <key:>
+#p <.codes@>
+<.report@>[<key:>]={:type=>:codeR,:code=> code,:expected=> <expected:> ,:result=> <result:>,:file=> <file:>,:descr => <descr:>}
+[#meth-test}
+
+{#meth]testRImg.Tester[#,]key[][#,]code[][#,]file[][#,]expected[][#,]seed[10][#,]descr[]
+[#?]#{+?file}[#=]code[#F{#{file}.dyn}][#?]end
+[#rb<]
+code=#{=code}.strip
+result=File.join(#{=.dir},<key:>+".png")
+[#r<]set.seed(#{seed})
+[#<]{#rpng]:{code}[#img]:{result}[#newR]TRUE[#}
+[#rb<]
+unless <expected:>.empty?
+  tmpExpected=File.join(#{=.dir},<expected:>)
+  <expected:> = tmpExpected if !File.exists?(<expected:>) and File.exists?(tmpExpected)
+else 
+  tmpExpected = File.join(#{=.dir},<key:>+"-expected.png")
+  if File.exists? tmpExpected
+    <expected:> = tmpExpected
+  elsif File.exists?(result)
+    <expected:> = tmpExpected
+    require 'fileutils'
+    FileUtils.cp(result,<expected:>)
+  end
+end
+raise "Boom! expected image file "+<expected:>+" does not exists!" unless File.exists?(<expected:>)
+<.tests@> << <key:>
+#p <.codes@>
+<.report@>[<key:>]={:type=>:imgR,:code=>code,:expected=> <expected:> ,:result=> result,:file=> <file:>,:descr => <descr:>}
+[#meth-test}
+
+{#meth]check.Tester[#>]
+\begin{tabular}{|c|c|} \hline
+[#rb>]
+<.tests@>.each{|key| #
+  {#>]:{key} & [#>} 
+  if {#<<]{#isValid]self[#key]:{key}[#}[#<<}
+    {#>]\ok[#>}  
+  else
+     {#>]\nok[#>} 
+  end
+  {#>]\\\hline[#nl][#>}
+}
+[#>]\end{tabular}
+[#meth-report}
+
+{#meth]theCode.Tester[#,]key[][#,]verbSep[!][#rb>]
+case <.report@>[<key:>][:type]
+when :code 
+  {#>]{@verbatim]:{<.report@>[<key:>][:code]}[@}[#} #make a comment in the doc! This works since <.report@>[<key:>] is converted befaore the code execution in ruby object!!!!
+when :codeR, :imgR
+  {#>]{@verbatim]:{<.report@>[<key:>][:code]}[@}[#}
+end
+[#meth}
+
+{#meth]result.Tester[#,]key[][#,]verbSep[!][#rb>]
+case <.report@>[<key:>][:type]
+when :code
+  {#>]{@verbatim]:{<.report@>[<key:>][:result]}[@}[#}
+when :codeR
+  {#>][#rb>][<.report@>[<key:>][:result]][#}
+when :imgR
+  {#>]\includegraphics[scale=.5]{:{<.report@>[<key:>][:result]}}[#}
+end
+[#}
+
+{#meth]expected.Tester[#,]key[][#,]verbSep[!][#rb>]
+case <.report@>[<key:>][:type]
+when :code
+  {#>]{@verbatim]:{<.report@>[<key:>][:expected]}[@}[#}
+when :codeR
+  {#>][#rb>][<.report@>[<key:>][:expected]][#}
+when :imgR
+  {#>]\includegraphics[scale=.5]{:{<.report@>[<key:>][:expected]}}[#}
+end
+[#meth}
+
+{#meth]isValid.Tester[#,]key[]
+[#rb>]
+require 'digest'
+case <.report@>[<key:>][:type]
+when :code, :codeR
+  Digest::SHA1.hexdigest(<.report@>[<key:>][:result])==Digest::SHA1.hexdigest(<.report@>[<key:>][:expected])
+when :imgR
+  Digest::SHA1.hexdigest(File.read(<.report@>[<key:>][:result]))==Digest::SHA1.hexdigest(File.read(<.report@>[<key:>][:expected]))
+end
+[#meth}
+
+CREATION OF THE GLOBAL TESTER: {#new]::Test[#of]Tester[#}
+
+IN THE STYLE MODE: 
+{@Tester:new@}
+
+{@Tester:testCode][@,]key[][@,]code[][@,]file[][@,]expected[][@,]descr[][@,]view[false][@>]{#testCode]Test[#}[@}
+
+{@Tester:testRCode][@,]key[][@,]code[][@,]file[][@,]expected[][@,]seed[10][@,]descr[][@>]{#testRCode]Test[#}[@}
+
+{@Tester:theCode][@,]key[][@,]verbSep[!][@>]{#theCode]Test[#}[@}
+
+{@Tester:theResult][@,]key[][@,]verbSep[!][@>]{#result]Test[#}[@}
+
+{@Tester:expectedResult][@,]key[][@,]verbSep[!][@>]{#expected]Test[#}[@}
+
+[#hide}
+