ozw.test

package require tcltest 2.0
namespace import ::tcltest::*

configure -verbose ptbe

set STRESS_REPS 1
set DEVICE /dev/cu.SLAB_USBtoUART

test init-1 {
    there should be a couple of arrays for Notification Type mapping
} -body {
        array get ::ozw::notification::TypeStrings
} -returnCodes ok -match glob -result \
    {*25 Type_Error*}
test init-2 {
    there should be a couple of arrays for Notification Type mapping
} -body {
        array get ::ozw::notification::TypeCodes
} -returnCodes ok -match glob -result \
    {*Type_Error 25*}

test options-3 {
    call options with not enough arguments
} -body {
    ozw::options
} -returnCodes error -match glob -result \
    {*wrong # args: should be "ozw::options create|configure|lock* ?arg ...?"*}

test options-4 {
    call options create with bad -option
} -body {
    ozw::options create -foo bar
} -returnCodes error -match glob -result \
    {illegal *create option "-foo"}

test options-5 {
    call options create with missing value in a -option value
} -body {
    ozw::options create -userpath
} -returnCodes error -match glob -result \
    {missing value for option "-userpath"}

test options-6 {
    call options create with proper args
} -body {
    ozw::options create -userpath "./"
} -returnCodes ok -match glob -result \
    {}

test options-7 {
    call options create when it's already been called
} -body {
    ozw::options create -userpath "./"
} -returnCodes error -match glob -result \
    {Options element already exists}

test options-8 {
    call destroy w/ too many args
} -body {
    ozw::options destroy -foo bar
} -returnCodes error -match glob -result \
    {wrong # args: should be "ozw::options destroy"}

test options-9 {
    call destroy correctly
} -body {
    ozw::options destroy
} -returnCodes ok -match glob -result \
    {}

test options-10 {
    call create and destroy a bunch of times
} -body {
    for {set x 0} {$x < $STRESS_REPS} {incr x} {
        ozw::options create -userpath . -commandline ""
        ozw::options destroy
        if {($x % 1000) == 0} {puts -nonewline stderr $x..}
    }
    ozw::options create -userpath . -commandline ""
} -returnCodes ok -match glob -result \
    {}

test options-11 {
   call arelocked w/ wronag number of args
} -body {
    ozw::options arelocked -a b
} -returnCodes error -match glob -result \
    {wrong # args: should be "ozw::options arelocked"}

test options-12 {
   call arelocked
} -body {
    ozw::options arelocked
} -returnCodes ok -match glob -result \
    {0}

test options-13 {
   call lock w/ wrong nunmber of args
} -body {
    ozw::options lock -foo baralicious
} -returnCodes error -match glob -result \
    {wrong # args: should be "ozw::options lock"}

test options-14 {
   call lock 
} -body {
    ozw::options lock
} -returnCodes ok -match glob -result \
    {}

test options-15 {
   call arelocked it should be locked now
} -body {
    ozw::options arelocked
} -returnCodes ok -match glob -result \
    {1}

test options-16 {
   legal addoptionbool command - but options are locked
} -body {
    ozw::options addoptionbool bullwinkle true
} -returnCodes error -match glob -result \
    {Cannot add to locked options}

test options-17 {
    illegal addoptionxxx command
} -body {
    ozw::options destroy 
    ozw::options create -userpath "./" -commandline "" 
    ozw::options addoptionfoo "a" b
} -returnCodes error -match glob -result \
    {illegal options (add) subcommand "addoptionfoo"}

test options-18 {
   illegal addoptionbool command - bad type for value
} -body {
    ozw::options addoptionbool "a" foo
} -returnCodes error -match glob -result \
    {expected boolean value but got "foo"}

test options-19 {
   legal addoptionbool command not enough args
} -body {
    ozw::options addoptionbool 
} -returnCodes error -match glob -result \
    {wrong # args: should be "ozw::options addoptionbool name defaultvalue"}

test options-20 {
   legal addoptionbool command - options not locked
} -body {
    foreach val {0 1 true false yes no} {
        ozw::options addoptionbool legalbool $val
    }
    format OTAY!
} -returnCodes ok -match glob -result \
    {OTAY!}

test options-21 {
   illegal addoptionint command - bad type for value
} -body {
    ozw::options addoptionint funkyint 99.9
} -returnCodes error -match glob -result \
    {expected integer but got "99.9"}

test options-22 {
   illegal addoptionint command - bad type for value
} -body {
    ozw::options addoptionint funkyint foo
} -returnCodes error -match glob -result \
    {expected integer but got "foo"}

test options-23 {
   illegal addoptionint command - ok hex type for value
} -body {
    ozw::options addoptionint legalint 0xdead
} -returnCodes ok -match glob -result \
    {}

test options-24 {
   illegal addoptionint command - ok type for value
} -body {
    ozw::options addoptionint legalint 99999
} -returnCodes ok -match glob -result \
    {}

test options-25 {
   illegal addoptionstring command - wrongs number of args
} -body {
    ozw::options addoptionstring funkystring
} -returnCodes error -match glob -result \
    {wrong # args: should be "ozw::options addoptionstring name defaultvalue appendmode"}

test options-26 {
   illegal addoptionstring command - wrongs number of args -- toomany
} -body {
    ozw::options addoptionstring funkystring "foo" true zabazz
} -returnCodes error -match glob -result \
    {wrong # args: should be "ozw::options addoptionstring name defaultvalue appendmode"}

test options-27 {
   illegal addoptionstring command - bad appendmode value
} -body {
    ozw::options addoptionstring funkystring "foo" figgle-true
} -returnCodes error -match glob -result \
    {expected boolean value but got "figgle-true" (for appendmode parameter)}

test options-28 {
   legal addoptionstring command
} -body {
    ozw::options addoptionstring funkadelic "George Clinton" true
} -returnCodes ok -match glob -result \
    {}

test options-29 {
   legal addoptionstring command
} -body {
    ozw::options addoptionstring funkadelic "Bootsy Collins" true
    ozw::options addoptionstring funkadelic "BucketHead" true
} -returnCodes ok -match glob -result \
    {}

test options-29 {
   legal addoptionstring command
} -body {
    ozw::options addoptionstring funkadelic "Bootsy Collins" false
    ozw::options addoptionstring funkadelic "Bootsy Collins" false
} -returnCodes ok -match glob -result \
    {}

test options-30 {
   getoptiontype command - wrong number of args
} -body {
    ozw::options getoptiontype
} -returnCodes error -match glob -result \
    {wrong # args: should be "ozw::options getoptiontype name"}

test options-31 {
   getoptiontype command - wrong number of args
} -body {
    ozw::options getoptiontype funkadelic wazz
} -returnCodes error -match glob -result \
    {wrong # args: should be "ozw::options getoptiontype name"}

test options-32 {
   getoptiontype command
} -body {
    set l {}
    lappend l [ozw::options getoptiontype funkadelic]
    lappend l [ozw::options getoptiontype legalint]
    lappend l [ozw::options getoptiontype legalbool]
} -returnCodes ok -match glob -result \
    {string int bool}

test options-33 {
   getoptiontype command
} -body {
    ozw::options getoptiontype doesnotexist
} -returnCodes error -match glob -result \
    {Cannot find option "doesnotexist"}

test options-34 {
   getoptionasint command - undefined name
} -body {
    ozw::options getoptionasint
} -returnCodes error -match glob -result \
{wrong # args: should be "ozw::options getoptionasint name"}

test options-35 {
   getoptionasint command - undefined name
} -body {
    ozw::options getoptionasint fooint
} -returnCodes error -match glob -result \
{Cannot get int option "fooint"}

test options-36 {
   getoptionasint command
} -body {
    ozw::options getoptionasint legalint
} -returnCodes ok -match glob -result \
{99999}

test options-37 {
   getoptionasint command - try to get a bool via int itnerface
} -body {
    ozw::options getoptionasint legalbool
} -returnCodes error -match glob -result \
{Cannot get int option*} 

test options-38 {
   getoptionasstring command
} -body {
    ozw::options getoptionasstring funkadelic
} -returnCodes ok -match glob -result \
{}

test options-39 {
   getoptionasbool command - with wrong type option
} -body {
    ozw::options getoptionasbool legalint
} -returnCodes error -match glob -result \
{Cannot get bool option "legalint"*}

test options-40 {
   getoptionasbool command
} -body {
    ozw::options getoptionasbool legalbool
} -returnCodes ok -match glob -result \
{0}

test log-1 {
    not enough args
} -body {
    ::ozw::log
} -returnCodes error -match glob -result \
{wrong # args: should be "::ozw::log subcommand ?arg ... arg?"}

test log-2 {
    bad subcmd
} -body {
    ::ozw::log foo -bar bullwinkle
} -returnCodes error -match glob -result \
{illegal subcommand "foo"}

test log-3 {
        not enoutgh args for write
} -body {
    ::ozw::log write
} -returnCodes error -match glob -result \
{wrong # args: should be "::ozw::log write LogLevel_Xxx messagetext"}

test log-4 {
    too many write args
} -body {
    ::ozw::log write LogLevel_Debug foo bar
} -returnCodes error -match glob -result \
{wrong # args: should be "::ozw::log write LogLevel_Xxx messagetext"}

test log-5 {
        write - illegal log type
} -body {
    ::ozw::log write LogLevel_Foo "hi"
} -returnCodes error -match glob -result \
{"LogLevel_Foo" is not a valid loglevel. should be one of: LogLevel_None, LogLevel_Always, LogLevel_Fatal, LogLevel_Error, LogLevel_Warning, LogLevel_Alert, LogLevel_Info, LogLevel_Detail, LogLevel_Debug, LogLevel_Internal}


test manager-1 {
   bogus manager command
} -body {
    ozw::manager foobalicious
} -returnCodes error -match glob -result \
{illegal manager subcommand "foobalicious"}

test manager-2 {
   manager destroy where there is nothing to destroy
} -body {
    ozw::manager destroy
} -returnCodes error -match glob -result \
{manager does not exist}

test manager-3 {
   manager create foo
} -body {
    ozw::manager create foo
} -returnCodes error -match glob -result \
{wrong # args: should be "ozw::manager create"}

test manager-4 {
   manager create - using unlocked options
} -body {
    ozw::manager create
} -returnCodes error -match glob -result \
{options element is not locked. it needs to be locked to create a manager}

test manager-5 {
   manager create - should work
} -body {
    ozw::options lock
    ozw::manager create
} -returnCodes ok -match glob -result \
{}

test manager-6 {
   manager create - already created
} -body {
    ozw::manager create
} -returnCodes error -match glob -result \
{manager already exists}

test manager-7 {
   manager destroy
} -body {
    ozw::manager destroy
} -returnCodes ok -match glob -result \
{}

test manager-8 {
   manager destroy - already destroyed
} -body {
    ozw::manager destroy
} -returnCodes error -match glob -result \
{manager does not exist}

test manager-9 {
   stress - manager create / destroy a bunch of times
} -body {
    for {set x 0} {$x < $STRESS_REPS} {incr x} {
        ozw::manager create
        ozw::manager destroy
        if {($x % 1000) == 0} {puts -nonewline stderr $x..}
    }
    ozw::manager create
} -returnCodes ok -match glob -result \
{}

test manager-10 {
    manager removewatcher when no add has been done
} -body {
        ozw::manager removewatcher
} -returnCodes error -match glob -result \
{no watcher currently installed}

test manager-11 {
    manager add watcher
} -body {
        ozw::manager addwatcher
} -returnCodes error -match glob -result \
{missing -command option. -command {...} is a required option pair}

test manager-12 {
    manager addwatcher - with bogus option pair
} -body {
        ozw::manager addwatcher -bullwinkle moose
} -returnCodes error -match glob -result \
{illegal option "-bullwinkle"}

test manager-13 {
    manager addwatcher - missing value in option pair
} -body {
        ozw::manager addwatcher -command
} -returnCodes error -match glob -result \
{missing value for option "-command"}

proc ::process_notification {n} {
    puts stderr ------------ 
    ## -valueid
    foreach {opt } {
        -typecode
        -typestring
        -homeid 
        -nodeid 
        -groupidx 
        -event 
        -buttonid 
        -errorcode 
        -getbyte 
    } {
        catch {puts stderr "\t$opt\t[$n cget $opt]"}
    }
    puts stderr ------------ 
}

test manager-14 {
    manager addwatcher
} -body {
    ozw::manager addwatcher -command ::process_notification
} -returnCodes ok -match glob -result \
{}

test manager-16 {
    manager addwatcher - w/ watcher already in place.
} -body {
        ozw::manager addwatcher -command {puts stderr "YOW!"}
} -returnCodes error -match glob -result \
{there is already a watcher installed}

test manager-17 {
    manager adddriver
} -body {
        ozw::manager adddriver
} -returnCodes error -match glob -result \
{wrong # args: should be "ozw::manager adddriver /port/path|usb"}
test manager-18 {
    manager adddriver -- too many args
} -body {
        ozw::manager adddriver /foo/bar bullwinkle
} -returnCodes error -match glob -result \
{wrong # args: should be "ozw::manager adddriver /port/path|usb"}
test manager-19 {
    legal manager adddriver call to add $DEVICE
} -body {
        ozw::manager adddriver $DEVICE
        after 5000
} -returnCodes ok -match glob -result \
{}

test manager-20 {
    manager adddriver -- not enough args
} -body {
        ozw::manager adddriver
} -returnCodes error -match glob -result \
{wrong # args: should be "ozw::manager adddriver /port/path|usb"}

test manager-21 {
    manager removedriver -- too many args
} -body {
        ozw::manager removedriver /foo/bar bullwinkle
} -returnCodes error -match glob -result \
{wrong # args: should be "ozw::manager removedriver /port/path|usb"}

test manager-22 {
    legal manager removedriver call to $DEVICE
} -body {
        ozw::manager removedriver $DEVICE
} -returnCodes ok -match glob -result \
{}

test manager-23 {
} -body {
    lsort [namespace children ::ozw::]
} -returnCodes ok -match glob -result \
{::ozw::notification}

test log-99 {
        write - ok
} -body {
    ::ozw::log write LogLevel_Always "(Always) TEST OF log Write from Tcl Extension"
    ::ozw::log write LogLevel_Info "(Info) TEST OF log Write from Tcl Extension"
    ::ozw::log write LogLevel_Fatal "(Fatal) TEST OF log Write from Tcl Extension"
    ::ozw::log write LogLevel_Debug "(Debug) TEST OF log Write from Tcl Extension"
} -returnCodes ok -match glob -result \
{}

::ozw::exit 0