Template:Str find word/testcases

From MOASSpedia
Jump to navigation Jump to search

{{Testcases notice }}

development links (Nov 2021)
This box: view · edit
mw:Lua manual; m:String m:Infobox m:Yesno m:TableTools · {{nav wtext-handling}} · m:ns detect m:pagetype

SEP

  • SEP=" foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo>
    RETURN VALUE |yes= (default, list of words found): foo
    Arguments: |explain=testcases |andw=foo |s="alpha" "foo" "bar" |sep="
    1.eSep: "
    2.pattern: %f[^"][^"]+%f["]
    1.eSep: "
    2.pattern: %f[^"][^"]+%f["]
    SEP: >"<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= "alpha" "foo" "bar" → <alpha|foo|bar>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
  • SEP=" foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo>
    RETURN VALUE |yes= (default, list of words found): foo
    Arguments: |explain=testcases |andw=foo |s="alpha", "foo", "bar" |sep="
    1.eSep: "
    2.pattern: %f[^"][^"]+%f["]
    1.eSep: "
    2.pattern: %f[^"][^"]+%f["]
    SEP: >"<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= "alpha", "foo", "bar" → <alpha|,|foo|,|bar>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
  • SEP="
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |andw=foo, bar |s="alpha", "bar" "foo", |sep="
    1.eSep: "
    2.pattern: %f[^"][^"]+%f["]
    1.eSep: "
    2.pattern: %f[^"][^"]+%f["]
    SEP: >"<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= "alpha", "bar" "foo", → <alpha|,|bar|foo|,>
    AND words to find: foo, bar → <foo, bar>
    AND words found: <> ⇒ FALSE
  • SEP=| bar|foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <bar|foo>
    RETURN VALUE |yes= (default, list of words found): bar|foo
    Arguments: |explain=testcases |andw=bar|foo |s=alpha|foo|drop|bar |sep=|
    1.eSep: |
    2.pattern: %f[^|][^|]+%f[|]
    1.eSep: |
    2.pattern: %f[^|][^|]+%f[|]
    SEP: >|<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha|foo|drop|bar → <alpha|foo|drop|bar>
    AND words to find: bar|foo → <bar|foo>
    AND words found: <bar|foo> ⇒ TRUE
  • SEP=; foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo>
    RETURN VALUE |yes= (default, list of words found): foo
    Arguments: |explain=testcases |andw=foo |s=alpha; foo; bar |sep=;
    1.eSep: ;
    2.pattern: %f[^;][^;]+%f[;]
    1.eSep: ;
    2.pattern: %f[^;][^;]+%f[;]
    SEP: >;<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha; foo; bar → <alpha|foo|bar>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
  • SEP= foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo>
    RETURN VALUE |yes= (default, list of words found): foo
    Arguments: |andw=foo |s=alpha, foo, bar |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha, foo, bar → <alpha|foo|bar>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
  • SEP= foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo>
    RETURN VALUE |yes= (default, list of words found): foo
    Arguments: |explain=testcases |andw=foo |s=alpha/ foo/ bar |sep=/
    1.eSep: /
    2.pattern: %f[^/][^/]+%f[/]
    1.eSep: /
    2.pattern: %f[^/][^/]+%f[/]
    SEP: >/<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha/ foo/ bar → <alpha|foo|bar>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
  • SEP= foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo>
    RETURN VALUE |yes= (default, list of words found): foo
    Arguments: |explain=testcases |andw=foo |s=alpha% foo% bar |sep=%
    1.eSep: %%
    2.pattern: %f[^%%][^%%]+%f[%%]
    1.eSep: %%
    2.pattern: %f[^%%][^%%]+%f[%%]
    SEP: >%<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha% foo% bar → <alpha|foo|bar>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
  • SEP=,,
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |andw=yes |s=true, 1, bar |sep=,,
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE
  • SEP=,a9,
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |andw=yes |s=true, 1, bar |sep=,a9,
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE


  • dflt T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |andw=yes |s=true, 1, bar |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE
  • empt :
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |andw=yes |s=true, 1, bar |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE
  • comma :
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |andw=yes |s=true, 1, bar |sep=,
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE

bool

dflt=F:
  • dflt F:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |andw=yes |s=true, 1, bar |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE
  • empt F:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |andw=yes |s=true, 1, bar |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE
  • bla F:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |bool=blabla |andw=yes |s=true, 1, bar |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE
  • F->F:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |bool=false |andw=yes |s=true, 1, bar |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE
  • F->T: yes
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <yes>
    RETURN VALUE |yes= (default, list of words found): yes
    Arguments: |bool=false |andw=yes |s=yes, 1, bar |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= yes, 1, bar → <yes|1|bar>
    AND words to find: yes → <yes>
    AND words found: <yes> ⇒ TRUE
  • T->T: true
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <true>
    RETURN VALUE |yes= (default, list of words found): true
    Arguments: |bool=true |andw=yes |s=true, 1, bar |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: true
    SOURCE word list= true, 1, bar → <true|true|bar>
    AND words to find: yes → <true>
    AND words found: <true> ⇒ TRUE
  • T->F:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |bool=true |s=true, 1, bar |explain=testcases |andw=false |orw=no
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: true
    SOURCE word list= true, 1, bar → <true|true|bar>
    AND words to find: false → <false>
    AND words found: <> ⇒ FALSE
    OR words to find: no → <false>
    OR words found: <> ⇒ FALSE
  • multi,T->T: true,true
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <true,true>
    RETURN VALUE |yes= (default, list of words found): true,true
    Arguments: |bool=true |s=true, 1, bar |explain=testcases |andw=yes |orw=1,false
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: true
    SOURCE word list= true, 1, bar → <true|true|bar>
    AND words to find: yes → <true>
    AND words found: <true> ⇒ TRUE
    OR words to find: 1,false → <true|false>
    OR words found: <true> ⇒ TRUE
  • multi,T->T: true,true,true,true,true,true,true
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <true,true,true,true,true,true,true>
    RETURN VALUE |yes= (default, list of words found): true,true,true,true,true,true,true
    Arguments: |bool=true |s=alpha, yes, true, 1, bar |explain=testcases |andw=yes, 1, True |orw=yes, 1, TRUE, 1,false
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: true
    SOURCE word list= alpha, yes, true, 1, bar → <alpha|true|true|true|bar>
    AND words to find: yes, 1, True → <true|true|true>
    AND words found: <true|true|true> ⇒ TRUE
    OR words to find: yes, 1, TRUE, 1,false → <true|true|true|true|false>
    OR words found: <true|true|true|true> ⇒ TRUE

case

  • T, F:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |andw=Foo |s=alpha, foO, |case=true
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: true (Foo ≠ foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha, foO, → <alpha|foO>
    AND words to find: Foo → <Foo>
    AND words found: <> ⇒ FALSE
  • F, T: foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo>
    RETURN VALUE |yes= (default, list of words found): foo
    Arguments: |explain=testcases |andw=Foo |s=alpha, foO, |case=false
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha, foO, → <alpha|foo>
    AND words to find: Foo → <foo>
    AND words found: <foo> ⇒ TRUE

basic t/f/dflt settings

(dflt=F)
  • abs,T: foo,foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo,foo>
    RETURN VALUE |yes= (default, list of words found): foo,foo
    Arguments: |andw=FOO, foo |s=alpha, Foo, |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha, Foo, → <alpha|foo>
    AND words to find: FOO, foo → <foo|foo>
    AND words found: <foo|foo> ⇒ TRUE
  • empt,T: foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo>
    RETURN VALUE |yes= (default, list of words found): foo
    Arguments: |andw=foo |s=alpha, foo, |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha, foo, → <alpha|foo>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
  • bla,T: foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo>
    RETURN VALUE |yes= (default, list of words found): foo
    Arguments: |explain=testcases |andw=foo |s=alpha, foo, |case=bla
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha, foo, → <alpha|foo>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
  • F,T: foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo>
    RETURN VALUE |yes= (default, list of words found): foo
    Arguments: |explain=testcases |andw=foo |s=alpha, foo, |case=F
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha, foo, → <alpha|foo>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
  • T,T: foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo>
    RETURN VALUE |yes= (default, list of words found): foo
    Arguments: |explain=testcases |andw=foo |s=alpha, foo, |case=T
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: true (Foo ≠ foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha, foo, → <alpha|foo>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE

lit

  • =T -> T: "bar,foo"
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <"bar,foo">
    RETURN VALUE |yes= (default, list of words found): "bar,foo"
    Arguments: |explain=testcases |andw="bar,foo" |s="bar,foo", summer |lit=true
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= "bar,foo", summer → <"bar|foo"|summer>
    AND words to find: "bar,foo" → <"bar|foo">
    AND words found: <"bar|foo"> ⇒ TRUE
  • =T -> F: "bar,foo"
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <"bar,foo">
    RETURN VALUE |yes= (default, list of words found): "bar,foo"
    Arguments: |explain=testcases |andw="bar, foo" |s="bar,foo", summer |lit=true
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= "bar,foo", summer → <"bar|foo"|summer>
    AND words to find: "bar, foo" → <"bar|foo">
    AND words found: <"bar|foo"> ⇒ TRUE
  • =F -> T: "bar,foo"
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <"bar,foo">
    RETURN VALUE |yes= (default, list of words found): "bar,foo"
    Arguments: |explain=testcases |andw="bar,foo" |s="bar,foo", summer |lit=false
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: false
    Read booleans: false
    SOURCE word list= "bar,foo", summer → <"bar|foo"|summer>
    AND words to find: "bar,foo" → <"bar|foo">
    AND words found: <"bar|foo"> ⇒ TRUE


  • T -> T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |andw=yes |s=true, 1, bar |lit=true
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE
  • T -> F:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |andw=yes |s=true, 1, bar |lit=true
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE
  • F -> T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |andw=yes |s=true, 1, bar |lit=false
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: false
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE
  • F -> T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |andw=yes |s=true, 1, bar |lit=false
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: false
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE

basic & default

  • abs=dflt:T -> T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |andw=yes |s=true, 1, bar |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE
  • blank:T -> T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |andw=yes |s=true, 1, bar |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE
  • bla:T -> T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |andw=yes |s=true, 1, bar |lit=blabla
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= true, 1, bar → <true|1|bar>
    AND words to find: yes → <yes>
    AND words found: <> ⇒ FALSE

t/f arguments case, bool, lit

omit=dflt

  • basic-dflt:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |word=Foo |source=bar, "foo", 0 |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, "foo", 0 → <bar|"foo"|0>
    AND words to find: Foo → <foo>
    AND words found: <> ⇒ FALSE

set T, F

  • basicT:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |bool=true |word=foo |source=bar, "foo", 0 |explain=testcases |lit=true |case=true
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: true (Foo ≠ foo)
    Read literals: true (found 0)
    Read booleans: true
    SOURCE word list= bar, "foo", 0 → <bar|"foo"|false>
    AND words to find: foo → <foo>
    AND words found: <> ⇒ FALSE
  • basicF:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |bool=false |word=foo |source=bar, "foo", 0 |explain=testcases |lit=false |case=false
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: false
    Read booleans: false
    SOURCE word list= bar, "foo", 0 → <bar|"foo"|0>
    AND words to find: foo → <foo>
    AND words found: <> ⇒ FALSE
long param-name
  • basicT:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |word=Foo |source=bar, "foo", 0 |booleans=true |literals=true |explain=testcases |casesensitive=true
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: true (Foo ≠ foo)
    Read literals: true (found 0)
    Read booleans: true
    SOURCE word list= bar, "foo", 0 → <bar|"foo"|false>
    AND words to find: Foo → <Foo>
    AND words found: <> ⇒ FALSE
  • basicF:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |word=Foo |source=bar, "foo", 0 |booleans=false |literals=false |explain=testcases |casesensitive=false
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: false
    Read booleans: false
    SOURCE word list= bar, "foo", 0 → <bar|"foo"|0>
    AND words to find: Foo → <foo>
    AND words found: <> ⇒ FALSE

Y/N

  • basicT:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |bool=Yes |word=foo, yes |source=bar, "foo", 0 |explain=testcases |lit=Yes |case=Yes
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: true (Foo ≠ foo)
    Read literals: true (found 0)
    Read booleans: true
    SOURCE word list= bar, "foo", 0 → <bar|"foo"|false>
    AND words to find: foo, yes → <foo|true>
    AND words found: <> ⇒ FALSE
  • basicF:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |bool=No |word=foo, yes |source=bar, "foo", 0 |explain=testcases |lit=No |case=No
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: false
    Read booleans: false
    SOURCE word list= bar, "foo", 0 → <bar|"foo"|0>
    AND words to find: foo, yes → <foo|yes>
    AND words found: <> ⇒ FALSE
  • nons:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |bool=oofoof |word=foo, yes |source=bar, "foo", 0 |explain=testcases |lit=akak |case=blabla
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, "foo", 0 → <bar|"foo"|0>
    AND words to find: foo, yes → <foo|yes>
    AND words found: <> ⇒ FALSE

logics

basic

  • T: foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo>
    RETURN VALUE |yes= (default, list of words found): foo
    Arguments: |word=foo |source=bar, foo, 0 |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0 → <bar|foo|0>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
  • F:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |word=nov |source=bar, foo, 0 |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0 → <bar|foo|0>
    AND words to find: nov → <nov>
    AND words found: <> ⇒ FALSE
  • x: foo,bar
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo,bar>
    RETURN VALUE |yes= (default, list of words found): foo,bar
    Arguments: |explain=testcases |source=bar, foo, 0 |andwords=foo, bar
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0 → <bar|foo|0>
    AND words to find: foo, bar → <foo|bar>
    AND words found: <foo|bar> ⇒ TRUE
  • x: foo,bar
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo,bar>
    RETURN VALUE |yes= (default, list of words found): foo,bar
    Arguments: |explain=testcases |source=bar, foo, 0 |andwords=foo, bar
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0 → <bar|foo|0>
    AND words to find: foo, bar → <foo|bar>
    AND words found: <foo|bar> ⇒ TRUE
  • T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |source=bar(), _ foo, 0(12)&^ |andwords=bar
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar(), _ foo, 0(12)&^ → <bar()|_ foo|0(12)&^>
    AND words to find: bar → <bar>
    AND words found: <> ⇒ FALSE
  • F:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |source=bar(), _ foo, 0(12)&^ |andwords=foo, bar
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar(), _ foo, 0(12)&^ → <bar()|_ foo|0(12)&^>
    AND words to find: foo, bar → <foo|bar>
    AND words found: <> ⇒ FALSE

andwords

andwords = combine 2 params
  • T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |word=foo |source=bar, foo, 0 |andwords=bar, 0
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0 → <bar|foo|0>
    AND words to find: foobar, 0 → <foobar|0>
    AND words found: <0> ⇒ FALSE
  • F:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |word=foo |source=bar, foo, 0 |andwords=bar, 1
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0 → <bar|foo|0>
    AND words to find: foobar, 1 → <foobar|1>
    AND words found: <> ⇒ FALSE
empty orw
  • T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |word=foo |source=bar, foo, 0 |andwords=bar, 0
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0 → <bar|foo|0>
    AND words to find: foobar, 0 → <foobar|0>
    AND words found: <0> ⇒ FALSE
  • F: foo
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo>
    RETURN VALUE |yes= (default, list of words found): foo
    Arguments: |word=foo |source=bar, foo, 0 |andwords=,, |explain=testcases |orwords=,
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0 → <bar|foo|0>
    AND words to find: foo,, → <foo>
    AND words found: <foo> ⇒ TRUE

andwords, orwords

  • x:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |word=foo |source=zoop, bar, foo, 0 |andwords=bar, 0 |explain=testcases |orwords=nov, bar, zoop
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= zoop, bar, foo, 0 → <zoop|bar|foo|0>
    AND words to find: foobar, 0 → <foobar|0>
    AND words found: <0> ⇒ FALSE
    OR words to find: nov, bar, zoop → <nov|bar|zoop>
    OR words found: <bar|zoop> ⇒ TRUE
  • x:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |word=foo |source=zoop, bar, foo, 0 |andwords=bar, 1 |explain=testcases |orwords=nov, bar, zoop
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= zoop, bar, foo, 0 → <zoop|bar|foo|0>
    AND words to find: foobar, 1 → <foobar|1>
    AND words found: <> ⇒ FALSE
    OR words to find: nov, bar, zoop → <nov|bar|zoop>
    OR words found: <bar|zoop> ⇒ TRUE

characters, words & whitespace

  • T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |source=bar(), _ foo, 0(12)&^ |orwords=bar |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar(), _ foo, 0(12)&^ → <bar()|_ foo|0(12)&^>
    OR words to find: bar → <bar>
    OR words found: <> ⇒ FALSE
  • T: 0(12)&^
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <0(12)&^>
    RETURN VALUE |yes= (default, list of words found): 0(12)&^
    Arguments: |source=bar(), _ foo, 0(12)&^ |orwords=foo, 0(12)&^ |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar(), _ foo, 0(12)&^ → <bar()|_ foo|0(12)&^>
    OR words to find: foo, 0(12)&^ → <foo|0(12)&^>
    OR words found: <0(12)&^> ⇒ TRUE
  • T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |source=bar(), _ " foo ", 0(12)&^ |orwords=nov, " foo " |lit=false
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: false
    Read booleans: false
    SOURCE word list= bar(), _ " foo ", 0(12)&^ → <bar()|_ " foo "|0(12)&^>
    OR words to find: nov, " foo " → <nov|" foo ">
    OR words found: <> ⇒ FALSE
  • T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |source=bar(), _ " foo ", 0(12)&^ |orwords=nov, " foo " |lit=true
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar(), _ " foo ", 0(12)&^ → <bar()|_ " foo "|0(12)&^>
    OR words to find: nov, " foo " → <nov|" foo ">
    OR words found: <> ⇒ FALSE
  • newlines T: foo,bar
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo,bar>
    RETURN VALUE |yes= (default, list of words found): foo,bar
    Arguments: |1=main |word=foo, bar |s=alpha, foo, lima, bar


, lima |explain=testcases
1.eSep: ,
2.pattern: %f[^,][^,]+%f[,]
1.eSep: ,
2.pattern: %f[^,][^,]+%f[,]
SEP: >,<
Case-sensitive: false (Foo = foo)
Read literals: true (found 0)
Read booleans: false
SOURCE word list= alpha, foo, lima, bar , lima → <alpha|foo|lima|bar|lima>
AND words to find: foo, bar → <foo|bar>
AND words found: <foo|bar> ⇒ TRUE

yes, no options

  • dflt-T: foo,bar
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo,bar>
    RETURN VALUE |yes= (default, list of words found): foo,bar
    Arguments: |orw=bar |andw=foo |s=bar, foo, 0, bla() |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0, bla() → <bar|foo|0|bla()>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
    OR words to find: bar → <bar>
    OR words found: <bar> ⇒ TRUE
  • dflt-F:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |orw=zoop |andw=foo |s=bar, foo, 0, bla() |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0, bla() → <bar|foo|0|bla()>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
    OR words to find: zoop → <zoop>
    OR words found: <> ⇒ FALSE
  • Y/N-empty: foo,bar
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo,bar>
    RETURN VALUE |yes= (default, list of words found): foo,bar
    Arguments: |orw=bar |andw=foo |s=bar, foo, 0, bla() |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0, bla() → <bar|foo|0|bla()>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
    OR words to find: bar → <bar>
    OR words found: <bar> ⇒ TRUE
  • Y/N-empty: N
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= N
    Arguments: |orw=zoop |s=bar, foo, 0, bla() |explain=testcases |no=N |andw=foo
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0, bla() → <bar|foo|0|bla()>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
    OR words to find: zoop → <zoop>
    OR words found: <> ⇒ FALSE
  • Y/N: Y
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo,bar>
    RETURN VALUE |yes= Y
    Arguments: |orw=bar |yes=Y |explain=testcases |no=N |andw=foo |s=bar, foo, 0, bla()
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0, bla() → <bar|foo|0|bla()>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
    OR words to find: bar → <bar>
    OR words found: <bar> ⇒ TRUE
  • Y/N: N
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= N
    Arguments: |orw=zoop |yes=Y |explain=testcases |no=N |andw=foo |s=bar, foo, 0, bla()
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0, bla() → <bar|foo|0|bla()>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
    OR words to find: zoop → <zoop>
    OR words found: <> ⇒ FALSE
  • Y/N: foo,bar
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo,bar>
    RETURN VALUE |yes= (default, list of words found): foo,bar
    Arguments: |orw=bar |s=bar, foo, 0, bla() |explain=testcases |no=No |andw=foo
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0, bla() → <bar|foo|0|bla()>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
    OR words to find: bar → <bar>
    OR words found: <bar> ⇒ TRUE
  • Y/N: No
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= No
    Arguments: |orw=zoop |yes=Y |explain=testcases |no=No |andw=foo |s=bar, foo, 0, bla()
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0, bla() → <bar|foo|0|bla()>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
    OR words to find: zoop → <zoop>
    OR words found: <> ⇒ FALSE

yes, no with image/table/lorem

  • Y/N:

    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.


    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo,bar>
    RETURN VALUE |yes= 

    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris ni ...
    Arguments: |orw=bar |yes=

    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

    |explain=testcases |andw=foo |s=bar, foo, 0, bla()
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0, bla() → <bar|foo|0|bla()>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
    OR words to find: bar → <bar>
    OR words found: <bar> ⇒ TRUE
  • Y/N: Example.png
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo,bar>
    RETURN VALUE |yes= Example.png
    Arguments: |orw=bar |yes=Example.png |explain=testcases |andw=foo |s=bar, foo, 0, bla()
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, foo, 0, bla() → <bar|foo|0|bla()>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
    OR words to find: bar → <bar>
    OR words found: <bar> ⇒ TRUE
  • Y/N:
Hydrogen Helium
Lithium Beryllium Boron Carbon Nitrogen Oxygen Fluorine Neon
Sodium Magnesium Aluminium Silicon Phosphorus Sulfur Chlorine Argon
Potassium Calcium Scandium Titanium Vanadium Chromium Manganese Iron Cobalt Nickel Copper Zinc Gallium Germanium Arsenic Selenium Bromine Krypton
Rubidium Strontium Yttrium Zirconium Niobium Molybdenum Technetium Ruthenium Rhodium Palladium Silver Cadmium Indium Tin Antimony Tellurium Iodine Xenon
Caesium Barium Lanthanum Cerium Praseodymium Neodymium Promethium Samarium Europium Gadolinium Terbium Dysprosium Holmium Erbium Thulium Ytterbium Lutetium Hafnium Tantalum Tungsten Rhenium Osmium Iridium Platinum Gold Mercury (element) Thallium Lead Bismuth Polonium Astatine Radon
Francium Radium Actinium Thorium Protactinium Uranium Neptunium Plutonium Americium Curium Berkelium Californium Einsteinium Fermium Mendelevium Nobelium Lawrencium Rutherfordium Dubnium Seaborgium Bohrium Hassium Meitnerium Darmstadtium Roentgenium Copernicium Nihonium Flerovium Moscovium Livermorium Tennessine Oganesson


Preview report {{Str find word}} explain=testcases
RESULT: Green tick TRUE words found in source: <foo,bar>
RETURN VALUE |yes= <div role="navigation" aria-label="Periodic table" style="float:right; background:#f8f8f8; padding:0.3em; border:1px solid #a9a9a9; margin:0 0 0.25em 0.5em; text-align:center;;"> <div style="margin: ...
Arguments: |orw=bar |yes=
Hydrogen Helium
Lithium Beryllium Boron Carbon Nitrogen Oxygen Fluorine Neon
Sodium Magnesium Aluminium Silicon Phosphorus Sulfur Chlorine Argon
Potassium Calcium Scandium Titanium Vanadium Chromium Manganese Iron Cobalt Nickel Copper Zinc Gallium Germanium Arsenic Selenium Bromine Krypton
Rubidium Strontium Yttrium Zirconium Niobium Molybdenum Technetium Ruthenium Rhodium Palladium Silver Cadmium Indium Tin Antimony Tellurium Iodine Xenon
Caesium Barium Lanthanum Cerium Praseodymium Neodymium Promethium Samarium Europium Gadolinium Terbium Dysprosium Holmium Erbium Thulium Ytterbium Lutetium Hafnium Tantalum Tungsten Rhenium Osmium Iridium Platinum Gold Mercury (element) Thallium Lead Bismuth Polonium Astatine Radon
Francium Radium Actinium Thorium Protactinium Uranium Neptunium Plutonium Americium Curium Berkelium Californium Einsteinium Fermium Mendelevium Nobelium Lawrencium Rutherfordium Dubnium Seaborgium Bohrium Hassium Meitnerium Darmstadtium Roentgenium Copernicium Nihonium Flerovium Moscovium Livermorium Tennessine Oganesson
|explain=testcases |andw=foo |s=bar, foo, 0, bla()
1.eSep: ,
2.pattern: %f[^,][^,]+%f[,]
1.eSep: ,
2.pattern: %f[^,][^,]+%f[,]
1.eSep: ,
2.pattern: %f[^,][^,]+%f[,]
SEP: >,<
Case-sensitive: false (Foo = foo)
Read literals: true (found 0)
Read booleans: false
SOURCE word list= bar, foo, 0, bla() → <bar|foo|0|bla()>
AND words to find: foo → <foo>
AND words found: <foo> ⇒ TRUE
OR words to find: bar → <bar>
OR words found: <bar> ⇒ TRUE
  • Y/N:

    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.


    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 

    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris ni ...
    Arguments: |orw=bar |yes=Y |explain=testcases |no=

    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

    |andw=foo |s=Ba, foo, 0, bla()
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= Ba, foo, 0, bla() → <ba|foo|0|bla()>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
    OR words to find: bar → <bar>
    OR words found: <> ⇒ FALSE
  • Y/N: Example.png
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= Example.png
    Arguments: |orw=bar |yes=Y |explain=testcases |no=Example.png |andw=foo |s=Ba, foo, 0, bla()
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= Ba, foo, 0, bla() → <ba|foo|0|bla()>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
    OR words to find: bar → <bar>
    OR words found: <> ⇒ FALSE
  • Y/N:
Hydrogen Helium
Lithium Beryllium Boron Carbon Nitrogen Oxygen Fluorine Neon
Sodium Magnesium Aluminium Silicon Phosphorus Sulfur Chlorine Argon
Potassium Calcium Scandium Titanium Vanadium Chromium Manganese Iron Cobalt Nickel Copper Zinc Gallium Germanium Arsenic Selenium Bromine Krypton
Rubidium Strontium Yttrium Zirconium Niobium Molybdenum Technetium Ruthenium Rhodium Palladium Silver Cadmium Indium Tin Antimony Tellurium Iodine Xenon
Caesium Barium Lanthanum Cerium Praseodymium Neodymium Promethium Samarium Europium Gadolinium Terbium Dysprosium Holmium Erbium Thulium Ytterbium Lutetium Hafnium Tantalum Tungsten Rhenium Osmium Iridium Platinum Gold Mercury (element) Thallium Lead Bismuth Polonium Astatine Radon
Francium Radium Actinium Thorium Protactinium Uranium Neptunium Plutonium Americium Curium Berkelium Californium Einsteinium Fermium Mendelevium Nobelium Lawrencium Rutherfordium Dubnium Seaborgium Bohrium Hassium Meitnerium Darmstadtium Roentgenium Copernicium Nihonium Flerovium Moscovium Livermorium Tennessine Oganesson


Preview report {{Str find word}} explain=testcases
RESULT: Red X FALSE
RETURN VALUE |no= <div role="navigation" aria-label="Periodic table" style="float:right; background:#f8f8f8; padding:0.3em; border:1px solid #a9a9a9; margin:0 0 0.25em 0.5em; text-align:center;;"> <div style="margin: ...
Arguments: |orw=bar |yes=Y |explain=testcases |no=
Hydrogen Helium
Lithium Beryllium Boron Carbon Nitrogen Oxygen Fluorine Neon
Sodium Magnesium Aluminium Silicon Phosphorus Sulfur Chlorine Argon
Potassium Calcium Scandium Titanium Vanadium Chromium Manganese Iron Cobalt Nickel Copper Zinc Gallium Germanium Arsenic Selenium Bromine Krypton
Rubidium Strontium Yttrium Zirconium Niobium Molybdenum Technetium Ruthenium Rhodium Palladium Silver Cadmium Indium Tin Antimony Tellurium Iodine Xenon
Caesium Barium Lanthanum Cerium Praseodymium Neodymium Promethium Samarium Europium Gadolinium Terbium Dysprosium Holmium Erbium Thulium Ytterbium Lutetium Hafnium Tantalum Tungsten Rhenium Osmium Iridium Platinum Gold Mercury (element) Thallium Lead Bismuth Polonium Astatine Radon
Francium Radium Actinium Thorium Protactinium Uranium Neptunium Plutonium Americium Curium Berkelium Californium Einsteinium Fermium Mendelevium Nobelium Lawrencium Rutherfordium Dubnium Seaborgium Bohrium Hassium Meitnerium Darmstadtium Roentgenium Copernicium Nihonium Flerovium Moscovium Livermorium Tennessine Oganesson
|andw=foo |s=Ba, foo, 0, bla()
1.eSep: ,
2.pattern: %f[^,][^,]+%f[,]
1.eSep: ,
2.pattern: %f[^,][^,]+%f[,]
1.eSep: ,
2.pattern: %f[^,][^,]+%f[,]
SEP: >,<
Case-sensitive: false (Foo = foo)
Read literals: true (found 0)
Read booleans: false
SOURCE word list= Ba, foo, 0, bla() → <ba|foo|0|bla()>
AND words to find: foo → <foo>
AND words found: <foo> ⇒ TRUE
OR words to find: bar → <bar>
OR words found: <> ⇒ FALSE

lit, case, bool options

literals

  • lit=T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |orw=bar |s=bar, "foo", bar, 0 |explain=testcases |andw=foo |lit=T
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, "foo", bar, 0 → <bar|"foo"|bar|0>
    AND words to find: foo → <foo>
    AND words found: <> ⇒ FALSE
    OR words to find: bar → <bar>
    OR words found: <bar> ⇒ TRUE
  • lit=F:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |orw=bar |s=bar, "foo, bar", ozob, 0 |explain=testcases |andw=foo |lit=False
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: false
    Read booleans: false
    SOURCE word list= bar, "foo, bar", ozob, 0 → <bar|"foo|bar"|ozob|0>
    AND words to find: foo → <foo>
    AND words found: <> ⇒ FALSE
    OR words to find: bar → <bar>
    OR words found: <bar> ⇒ TRUE
  • lit=dflt:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |orw=bar |andw=foo |s=bar, "foo", bar, 0 |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, "foo", bar, 0 → <bar|"foo"|bar|0>
    AND words to find: foo → <foo>
    AND words found: <> ⇒ FALSE
    OR words to find: bar → <bar>
    OR words found: <bar> ⇒ TRUE
  • lit=abs:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |orw=bar |andw=foo |s=bar, "foo", bar, 0 |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, "foo", bar, 0 → <bar|"foo"|bar|0>
    AND words to find: foo → <foo>
    AND words found: <> ⇒ FALSE
    OR words to find: bar → <bar>
    OR words found: <bar> ⇒ TRUE
  • lit=blabla:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |orw=bar |s=bar, "foo", bar, 0 |explain=testcases |andw=foo |lit=blabla
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, "foo", bar, 0 → <bar|"foo"|bar|0>
    AND words to find: foo → <foo>
    AND words found: <> ⇒ FALSE
    OR words to find: bar → <bar>
    OR words found: <bar> ⇒ TRUE

case

  • case=T:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |orw=Bar |s=bar, Foo, 0 |explain=testcases |andw=foo |case=T
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: true (Foo ≠ foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, Foo, 0 → <bar|Foo|0>
    AND words to find: foo → <foo>
    AND words found: <> ⇒ FALSE
    OR words to find: Bar → <Bar>
    OR words found: <> ⇒ FALSE
  • case=Y:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |orw=Bar |s=bar, Foo, 0 |explain=testcases |andw=foo |case=Y
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: true (Foo ≠ foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, Foo, 0 → <bar|Foo|0>
    AND words to find: foo → <foo>
    AND words found: <> ⇒ FALSE
    OR words to find: Bar → <Bar>
    OR words found: <> ⇒ FALSE
  • case=Y: Foo,April,Bar
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <Foo,April,Bar>
    RETURN VALUE |yes= (default, list of words found): Foo,April,Bar
    Arguments: |orw=Bar, nov |s=Bar, Foo, April |explain=testcases |andw=Foo, April |case=Y
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: true (Foo ≠ foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= Bar, Foo, April → <Bar|Foo|April>
    AND words to find: Foo, April → <Foo|April>
    AND words found: <Foo|April> ⇒ TRUE
    OR words to find: Bar, nov → <Bar|nov>
    OR words found: <Bar> ⇒ TRUE
  • case=dflt: foo,bar
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo,bar>
    RETURN VALUE |yes= (default, list of words found): foo,bar
    Arguments: |orw=Bar |andw=foo |s=bar, Foo, 0 |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, Foo, 0 → <bar|foo|0>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
    OR words to find: Bar → <bar>
    OR words found: <bar> ⇒ TRUE
  • case=blabla: foo,bar
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <foo,bar>
    RETURN VALUE |yes= (default, list of words found): foo,bar
    Arguments: |orw=Bar |s=bar, Foo, 0 |explain=testcases |andw=foo |case=blabla
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= bar, Foo, 0 → <bar|foo|0>
    AND words to find: foo → <foo>
    AND words found: <foo> ⇒ TRUE
    OR words to find: Bar → <bar>
    OR words found: <bar> ⇒ TRUE

booleans

  • bool=T: false
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <false>
    RETURN VALUE |yes= (default, list of words found): false
    Arguments: |explain=testcases |andw=no |s=foo, false, 0 |booleans=true
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: true
    SOURCE word list= foo, false, 0 → <foo|false|false>
    AND words to find: no → <false>
    AND words found: <false> ⇒ TRUE
  • bool=Y: false
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <false>
    RETURN VALUE |yes= (default, list of words found): false
    Arguments: |explain=testcases |andw=no |s=foo, false, 0 |booleans=Y
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: true
    SOURCE word list= foo, false, 0 → <foo|false|false>
    AND words to find: no → <false>
    AND words found: <false> ⇒ TRUE
  • bool=dflt:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |andw=no |s=foo, false, 0 |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= foo, false, 0 → <foo|false|0>
    AND words to find: no → <no>
    AND words found: <> ⇒ FALSE
  • bool=F:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |andw=no |s=foo, false, 0 |booleans=false
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= foo, false, 0 → <foo|false|0>
    AND words to find: no → <no>
    AND words found: <> ⇒ FALSE
  • bool=abst:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |andw=no |s=foo, false, 0 |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= foo, false, 0 → <foo|false|0>
    AND words to find: no → <no>
    AND words found: <> ⇒ FALSE
  • bool=blabla:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |explain=testcases |andw=no |s=foo, false, 0 |booleans=blabla
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= foo, false, 0 → <foo|false|0>
    AND words to find: no → <no>
    AND words found: <> ⇒ FALSE

explain true / testcases

  • xp-f: bar
  • xp-f: bar
  • xp-t: bar
  • xp-t: bar
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <bar>
    RETURN VALUE |yes= (default, list of words found): bar
    Arguments: |andw=bar |s=alpha$, Foo @, bar, Z |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha$, Foo @, bar, Z → <alpha$|foo @|bar|z>
    AND words to find: bar → <bar>
    AND words found: <bar> ⇒ TRUE
  • xp-t: bar
  • xp-t:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |orw=north, "alpha$", nov, south |andw=bar |s=alpha$, Foo @, bar, Z |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha$, Foo @, bar, Z → <alpha$|foo @|bar|z>
    AND words to find: bar → <bar>
    AND words found: <bar> ⇒ TRUE
    OR words to find: north, "alpha$", nov, south → <north|"alpha$"|nov|south>
    OR words found: <> ⇒ FALSE

by transclusion

  • xp-f: bar
  • xp-f: bar
  • xp-t: bar
  • xp-t: bar
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <bar>
    RETURN VALUE |yes= (default, list of words found): bar
    Arguments: |andw=bar |s=alpha$, Foo @, bar, Z |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha$, Foo @, bar, Z → <alpha$|foo @|bar|z>
    AND words to find: bar → <bar>
    AND words found: <bar> ⇒ TRUE
  • xp-t: bar
  • xp-t:
    Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |orw=north, nov, south |andw=bar |s=alpha$, Foo @, bar, Z |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha$, Foo @, bar, Z → <alpha$|foo @|bar|z>
    AND words to find: bar → <bar>
    AND words found: <bar> ⇒ TRUE
    OR words to find: north, nov, south → <north|nov|south>
    OR words found: <> ⇒ FALSE

errors & warnings

  • The logic does not (can not) produce errors. The result is always logically T or F.
both warnings in preview:
  • T: one,z
  • F:

unk parameter

show report

  • Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |1=bar |duh=north, nov, south |s=alpha$, Foo @, bar, Z |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    no words to check:
    No words to find (|word= |andwords= |orwords=):
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha$, Foo @, bar, Z → <alpha$|foo @|bar|z>

  • Preview report {{Str find word}} explain=testcases
    RESULT: Red X FALSE
    RETURN VALUE |no= 
    Arguments: |1=bar |duh=north, nov, south |s=alpha$, Foo @, bar, Z |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    no words to check:
    No words to find (|word= |andwords= |orwords=):
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha$, Foo @, bar, Z → <alpha$|foo @|bar|z>

xpMaxWordcountReached

  • (prev warn) T: one,z
  • (prev warn) F: z
  • (prev warn) T: one,z
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <one,z>
    RETURN VALUE |yes= (default, list of words found): one,z
    Arguments: |orw=one, t,3,f,5,s,z,e,n,ten,eleven |s=alpha$, one,Z |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha$, one,Z → <alpha$|one|z>
    OR words to find: one, t,3,f,5,s,z,e,n,ten,eleven → <one|t|3|f|5|s|z|e|n|ten|eleven>
    OR words found: <one|z> ⇒ TRUE
  • (prev warn) F: z
    Preview report {{Str find word}} explain=testcases
    RESULT: Green tick TRUE words found in source: <z>
    RETURN VALUE |yes= (default, list of words found): z
    Arguments: |orw=one, t,3,f,5,s,z,e,n,ten,eleven |s=alpha$, Z |explain=testcases
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    1.eSep: ,
    2.pattern: %f[^,][^,]+%f[,]
    SEP: >,<
    Case-sensitive: false (Foo = foo)
    Read literals: true (found 0)
    Read booleans: false
    SOURCE word list= alpha$, Z → <alpha$|z>
    OR words to find: one, t,3,f,5,s,z,e,n,ten,eleven → <one|t|3|f|5|s|z|e|n|ten|eleven>
    OR words found: <z> ⇒ TRUE


Retrieved from "https://moasspedia.org/w/index.php?title=Template:Str_find_word/testcases&oldid=31707"