package require Tcl 8.5
package require debug
package require debug::caller
package require cmdr::tty

# # ## ### ##### ######## ############# #####################






namespace eval ::cmdr::color {
    namespace export activate active define

    namespace ensemble create \
	-unknown [namespace current]::Unknown
    # Note, the option ensures that all unknown methods are treated as
    # (list of) color codes to apply to some text, effectively
    # creating the virtual command
    #
    #    ::cmdr::color <codelist> <text>
................................................................................
# # ## ### ##### ######## ############# #####################

debug define cmdr/color
debug level  cmdr/color
debug prefix cmdr/color {[debug caller] | }

# # ## ### ##### ######## ############# #####################
## TODO undef?
## TODO multi-def (load)
## TODO get (display)
## officer and private for std commands (show, define).

proc ::cmdr::color::activate {{flag 1}} {
    debug.cmdr/color {}
    variable active $flag
    return
}

proc ::cmdr::color::active {} {
    debug.cmdr/color {}
    variable active
    return  $active
}



















































proc ::cmdr::color::define {name spec} {
    debug.cmdr/color {}
    variable def
    variable char

    # TODO: spec may be
    # => reference to other color name, or

    # => raw control sequence, or
    # => RGB spec.

    # Syntax:
    # ref = anything already found as key in the database.
    # rgb = 
    # raw = 




    if {[dict exists $def $spec]} {

	if {$spec eq $name} {
	    return -code error \
		-errorcode [list CMDR COLOR CIRCLE $name] \
		"Rejected self-referential definition of \"$name\""
	}





	debug.cmdr/color {reference, resolved => [S [dict get $char $spec]]}
	dict set def  $name $spec
	dict set char $name [dict get $char $spec]
	return
    }



    if {[regexp {^%(\d+),(\d+),(\d+)$} $spec -> r g b]} {




	# R, G, B all in range 0..5
	set r [Clamp $r]
	set g [Clamp $g]
	set b [Clamp $b]
	# 256 mapping
	# code = 16 + 36R + 6G + B --> [16..236]
	set code [expr {16 + 36*$r + 6*$g + $b}]

	debug.cmdr/color {RGB encoded => [S [C $code]]}
	dict set def  $name $spec
	dict set char $name [C $code]
	return

	# Legacy mapping
	# R,G,B mapping 0,1 --> 0, 2,3 --> 1, 4,5 --> 2
	# bold mapping: 0,1,2 --> 0,1,1 (set if any of R, G, B)
	# code = 8bold + R + 2G + 4B
	#      = 8, for R==G==B != 0, special case.

    }

    # Raw control sequence, simply save
    dict set def  $name $spec
    dict set char $name $spec
    return
}
................................................................................
    if {!$active} {
	debug.cmdr/color {not active}
	return $text
    }

    variable char
    foreach c $codes {
	if {[dict exists $char $c]} {
	    return -code error \
		-errorcode [list CMDR COLOR UNKNOWN $c] \
		"Expected a color name, got \"$c\""
	}
	append r [dict get $char $c]
    }
    append r $text
    append r [dict get $char reset]

    debug.cmdr/color {/done}
    return $r
}

proc ::cmdr::color::S {text} {
    # quote all non-printable characters (< space, > ~)
    variable smap
    return [string map $smap $text]
}

proc ::cmdr::color::C {args} {
    return \033\[[join $args \;]m
}

proc ::cmdr::color::Clamp {x} {
    if {$x < 0} { return 0 }
    if {$x > 5} { return 5 }
    return $x


}

# # ## ### ##### ######## ############# #####################

namespace eval ::cmdr::color {
    # Boolean flag controlling use of color sequences.
    # Default based on tty-ness of stdout. Active if yes.
................................................................................
    # dictionaries hold the user-level specification and the
    # full-resolved character sequence.

    variable def  {}
    variable char {}

    # Colors. Foreground/Text.
    define  black        [C 30]  ; # Black  
    define  red          [C 31]  ; # Red    
    define  green        [C 32]  ; # Green  
    define  yellow       [C 33]  ; # Yellow 
    define  blue         [C 34]  ; # Blue   
    define  magenta      [C 35]  ; # Magenta
    define  cyan         [C 36]  ; # Cyan   
    define  white        [C 37]  ; # White  
    define  default      [C 39]  ; # Default (Black)

    # Colors. Background.
    define  bg-black     [C 40]  ; # Black  
    define  bg-red       [C 41]  ; # Red    
    define  bg-green     [C 42]  ; # Green  
    define  bg-yellow    [C 43]  ; # Yellow 
    define  bg-blue      [C 44]  ; # Blue   
    define  bg-magenta   [C 45]  ; # Magenta
    define  bg-cyan      [C 46]  ; # Cyan   
    define  bg-white     [C 47]  ; # White  
    define  bg-default   [C 49]  ; # Default (Transparent)

    # Non-color attributes. Activation.
    define  bold         [C  1]  ; # Bold  
    define  dim          [C  2]  ; # Dim
    define  italic       [C  3]  ; # Italics      
    define  underline    [C  4]  ; # Underscore   
    define  blink        [C  5]  ; # Blink
    define  revers       [C  7]  ; # Reverse      
    define  hidden       [C  8]  ; # Hidden
    define  strike       [C  9]  ; # StrikeThrough

    # Non-color attributes. Deactivation.
    define  no-bold      [C 22]  ; # Bold  
    define  no-dim       [C __]  ; # Dim
    define  no-italic    [C 23]  ; # Italics      
    define  no-underline [C 24]  ; # Underscore   
    define  no-blink     [C 25]  ; # Blink
    define  no-revers    [C 27]  ; # Reverse      
    define  no-hidden    [C 28]  ; # Hidden
    define  no-strike    [C 29]  ; # StrikeThrough

    # Remainder
    define  reset        [C  0]  ; # Reset

    # And now the standard symbolic names

    define  confirm red
    define  error   red
    define  warning yellow
    define  note    blue
    define  good    green
    define  name    blue

    # header command stopped advisory crashed failure success name prompt table warning
    # bl/whi bl/yel  bl/grey bl/yel   bl/red  bl/red  bl/gre  bl/cy bl/cy bl/cy bl/mag
    # stdout - white, stderr - red
    # app-header sys-header
    # bl/yel     bl/cy

    # others ...
    # name	<>	blue,
    # neutral	<>	blue,
    # good	<>	green,
    # bad	<>	red,
    # error	<>	magenta,




    # unknown	<>	cyan,
    # warning	<>	yellow,
    # instance<>	yellow,
    # number	<>	green,
    # prompt	<>	blue,
    # yes	<>	green,
    # no	<>	red


    variable smap {}
}

apply {{} {
    variable smap
    for {set i 0} {$i < 32} {incr i} {
	set c [format %c $i]
	set o \\[format %03o $i] 
	lappend smap $c $o
    }
    lappend smap \127 \\127
}} ::cmdr::color

# # ## ### ##### ######## ############# #####################
## Ready
package provide cmdr::color 0

package require Tcl 8.5
package require debug
package require debug::caller
package require cmdr::tty

# # ## ### ##### ######## ############# #####################

namespace eval ::cmdr {
    namespace export color
    namespace ensemble create
}

namespace eval ::cmdr::color {
    namespace export \
	activate active names get get-def define exists unset
    namespace ensemble create \
	-unknown [namespace current]::Unknown
    # Note, the option ensures that all unknown methods are treated as
    # (list of) color codes to apply to some text, effectively
    # creating the virtual command
    #
    #    ::cmdr::color <codelist> <text>
................................................................................
# # ## ### ##### ######## ############# #####################

debug define cmdr/color
debug level  cmdr/color
debug prefix cmdr/color {[debug caller] | }

# # ## ### ##### ######## ############# #####################

## TODO multi-def aka bulk-def aka load

## TODO officer and private for std commands (show, define).

proc ::cmdr::color::activate {{flag 1}} {
    debug.cmdr/color {}
    variable active $flag
    return
}

proc ::cmdr::color::active {} {
    debug.cmdr/color {}
    variable active
    return  $active
}

proc ::cmdr::color::names {} {
    debug.cmdr/color {}
    variable def
    return [dict keys $def]
}

proc ::cmdr::color::unset {name} {
    debug.cmdr/color {}
    variable def
    if {![dict exists $def $name]} {
	return -code error \
	    -errorcode [list CMDR COLOR BAD $name] \
	    "Expected a color name, got \"$name\""
    }

    variable char
    dict unset def  $name
    dict unset char $name
    return
}

proc ::cmdr::color::get {name} {
    debug.cmdr/color {}
    variable def
    if {![dict exists $def $name]} {
	return -code error \
	    -errorcode [list CMDR COLOR BAD $name] \
	    "Expected a color name, got \"$name\""
    }
    variable char
    return [dict get $char $name]
}

proc ::cmdr::color::get-def {name} {
    debug.cmdr/color {}
    variable def
    if {![dict exists $def $name]} {
	return -code error \
	    -errorcode [list CMDR COLOR BAD $name] \
	    "Expected a color name, got \"$name\""
    }
    return [dict get $def $name]
}

proc ::cmdr::color::exists {name} {
    debug.cmdr/color {}
    variable def
    return [dict exists $def $name]
}

proc ::cmdr::color::define {name spec} {
    debug.cmdr/color {}
    variable def
    variable char

    # The spec may be
    # (1) A reference to other color name.
    # (2) An RGB spec.
    # (3) A raw control sequence.


    # Syntax:



    # (1) ref := =<name>
    # (2) rgb := %<r>,<g>,<b>
    # (3) raw := anything else


    if {[regexp {^=(.*)$} $spec -> ref]} {
	if {$ref eq $name} {
	    return -code error \
		-errorcode [list CMDR COLOR CIRCLE $name] \
		"Rejected self-referential definition of \"$name\""
	} elseif {![dict exists $def $ref]} {
	    return -code error \
		-errorcode [list CMDR COLOR BAD $ref] \
		"Expected a color name, got \"$ref\""
	} else {
	    set raw [dict get $char $ref]
	    debug.cmdr/color {reference, resolved => [Quote $raw]}
	    dict set def  $name $spec
	    dict set char $name $raw
	    return
	}
    }

    if {[regexp {^%(.*)$} $spec -> rgb]} {
	if {![regexp {^(\d+),(\d+),(\d+)$} $rgb -> r g b]} {
	    return -code error \
		-errorcode [list CMDR COLOR BAD-RGB SYNTAX $rgb] \
		"Expected an RGB tuple, got \"$rgb\""
	} {
	    # R, G, B all in range 0..5
	    Clamp R $r
	    Clamp G $g
	    Clamp B $b
	    # 256-color mapping
	    # code = 16 + 36R + 6G + B --> [16..236]
	    set point [expr {16 + 36*$r + 6*$g + $b}]
	    set code [Code $point]
	    debug.cmdr/color {RGB encoded => [Quote $code]}
	    dict set def  $name $spec
	    dict set char $name $code
	    return

	    # Legacy mapping
	    # R,G,B mapping 0,1 --> 0, 2,3 --> 1, 4,5 --> 2
	    # bold mapping: 0,1,2 --> 0,1,1 (set if any of R, G, B)
	    # code = 8bold + R + 2G + 4B
	    #      = 8, for R==G==B != 0, special case.
	}
    }

    # Raw control sequence, simply save
    dict set def  $name $spec
    dict set char $name $spec
    return
}
................................................................................
    if {!$active} {
	debug.cmdr/color {not active}
	return $text
    }

    variable char
    foreach c $codes {
	if {![dict exists $char $c]} {
	    return -code error \
		-errorcode [list CMDR COLOR UNKNOWN $c] \
		"Expected a color name, got \"$c\""
	}
	append r [dict get $char $c]
    }
    append r $text
    append r [dict get $char reset]

    debug.cmdr/color {/done}
    return $r
}

proc ::cmdr::color::Quote {text} {
    # quote all non-printable characters (< space, > ~)
    variable smap
    return [string map $smap $text]
}

proc ::cmdr::color::Code {args} {
    return \033\[[join $args \;]m
}

proc ::cmdr::color::Clamp {label x} {
    if {($x >= 0) && ($x <= 5)} { return $x }

    return -code error \
	-errorcode [list CMDR COLOR BAD-RGB RANGE $x] \
	"RGB channel $label out of range, got $x"
}

# # ## ### ##### ######## ############# #####################

namespace eval ::cmdr::color {
    # Boolean flag controlling use of color sequences.
    # Default based on tty-ness of stdout. Active if yes.
................................................................................
    # dictionaries hold the user-level specification and the
    # full-resolved character sequence.

    variable def  {}
    variable char {}

    # Colors. Foreground/Text.
    define  black        [Code 30]  ; # Black  
    define  red          [Code 31]  ; # Red    
    define  green        [Code 32]  ; # Green  
    define  yellow       [Code 33]  ; # Yellow 
    define  blue         [Code 34]  ; # Blue   
    define  magenta      [Code 35]  ; # Magenta
    define  cyan         [Code 36]  ; # Cyan   
    define  white        [Code 37]  ; # White  
    define  default      [Code 39]  ; # Default (Black)

    # Colors. Background.
    define  bg-black     [Code 40]  ; # Black  
    define  bg-red       [Code 41]  ; # Red    
    define  bg-green     [Code 42]  ; # Green  
    define  bg-yellow    [Code 43]  ; # Yellow 
    define  bg-blue      [Code 44]  ; # Blue   
    define  bg-magenta   [Code 45]  ; # Magenta
    define  bg-cyan      [Code 46]  ; # Cyan   
    define  bg-white     [Code 47]  ; # White  
    define  bg-default   [Code 49]  ; # Default (Transparent)

    # Non-color attributes. Activation.
    define  bold         [Code  1]  ; # Bold  
    define  dim          [Code  2]  ; # Dim
    define  italic       [Code  3]  ; # Italics      
    define  underline    [Code  4]  ; # Underscore   
    define  blink        [Code  5]  ; # Blink
    define  revers       [Code  7]  ; # Reverse      
    define  hidden       [Code  8]  ; # Hidden
    define  strike       [Code  9]  ; # StrikeThrough

    # Non-color attributes. Deactivation.
    define  no-bold      [Code 22]  ; # Bold  
    define  no-dim       [Code __]  ; # Dim
    define  no-italic    [Code 23]  ; # Italics      
    define  no-underline [Code 24]  ; # Underscore   
    define  no-blink     [Code 25]  ; # Blink
    define  no-revers    [Code 27]  ; # Reverse      
    define  no-hidden    [Code 28]  ; # Hidden
    define  no-strike    [Code 29]  ; # StrikeThrough

    # Remainder
    define  reset        [Code  0]  ; # Reset

    # And now the standard symbolic names

    define  advisory =yellow
    define  bad      =red
    define  confirm  =red
    define  error    =magenta
    define  good     =green
    define  name     =blue









    define  neutral  =blue



    define  no       =red
    define  note     =blue
    define  number   =green
    define  prompt   =blue
    define  unknown  =cyan
    define  warning  =yellow





    define  yes      =green

    variable smap {}
}

apply {{} {
    variable smap
    for {set i 0} {$i < 32} {incr i} {
	set c [format %c $i]
	set o \\[format %03o $i] 
	lappend smap $c $o
    }
    lappend smap \127 \\127
} ::cmdr::color}

# # ## ### ##### ######## ############# #####################
## Ready
package provide cmdr::color 0

# -*- tcl -*- tcl.tk//DSL tcltest//EN//2.0
# # ## ### ##### ######## ############# #####################
## Testing the cmdr::color package.

kt check Tcl     8.5
kt check tcltest 2

kt require support Tclx
kt require support debug
kt require support debug::caller

kt local   support cmdr::tty
kt local   testing cmdr::color

set thecolors {advisory bad bg-black bg-blue bg-cyan bg-default bg-green bg-magenta bg-red bg-white bg-yellow black blink blue bold confirm cyan default dim error good green hidden italic magenta name neutral no no-blink no-bold no-dim no-hidden no-italic no-revers no-strike no-underline note number prompt red reset revers strike underline unknown warning white yellow yes}

set thechars {
    advisory	{\033[33m}
    bad		{\033[31m}
    bg-black	{\033[40m}
    bg-blue	{\033[44m}
    bg-cyan	{\033[46m}
    bg-default	{\033[49m}
    bg-green	{\033[42m}
    bg-magenta	{\033[45m}
    bg-red	{\033[41m}
    bg-white	{\033[47m}
    bg-yellow	{\033[43m}
    black	{\033[30m}
    blink	{\033[5m}
    blue	{\033[34m}
    bold	{\033[1m}
    confirm	{\033[31m}
    cyan	{\033[36m}
    default	{\033[39m}
    dim		{\033[2m}
    error	{\033[35m}
    good	{\033[32m}
    green	{\033[32m}
    hidden	{\033[8m}
    italic	{\033[3m}
    magenta	{\033[35m}
    name	{\033[34m}
    neutral	{\033[34m}
    no		{\033[31m}
    no-blink	{\033[25m}
    no-bold	{\033[22m}
    no-dim	{\033[__m}
    no-hidden	{\033[28m}
    no-italic	{\033[23m}
    no-revers	{\033[27m}
    no-strike	{\033[29m}
    no-underline {\033[24m}
    note	{\033[34m}
    number	{\033[32m}
    prompt	{\033[34m}
    red		{\033[31m}
    reset	{\033[0m}
    revers	{\033[7m}
    strike	{\033[9m}
    underline	{\033[4m}
    unknown	{\033[36m}
    warning	{\033[33m}
    white	{\033[37m}
    yellow	{\033[33m}
    yes		{\033[32m}
}

set thedefs {
    advisory	=yellow
    bad		=red
    bg-black	{\033[40m}
    bg-blue	{\033[44m}
    bg-cyan	{\033[46m}
    bg-default	{\033[49m}
    bg-green	{\033[42m}
    bg-magenta	{\033[45m}
    bg-red	{\033[41m}
    bg-white	{\033[47m}
    bg-yellow	{\033[43m}
    black	{\033[30m}
    blink	{\033[5m}
    blue	{\033[34m}
    bold	{\033[1m}
    confirm	=red
    cyan	{\033[36m}
    default	{\033[39m}
    dim		{\033[2m}
    error	=magenta
    good	=green
    green	{\033[32m}
    hidden	{\033[8m}
    italic	{\033[3m}
    magenta	{\033[35m}
    name	=blue
    neutral	=blue
    no		=red
    no-blink	{\033[25m}
    no-bold	{\033[22m}
    no-dim	{\033[__m}
    no-hidden	{\033[28m}
    no-italic	{\033[23m}
    no-revers	{\033[27m}
    no-strike	{\033[29m}
    no-underline {\033[24m}
    note	=blue
    number	=green
    prompt	=blue
    red		{\033[31m}
    reset	{\033[0m}
    revers	{\033[7m}
    strike	{\033[9m}
    underline	{\033[4m}
    unknown	=cyan
    warning	=yellow
    white	{\033[37m}
    yellow	{\033[33m}
    yes		=green
}

# # ## ### ##### ######## ############# #####################
## Basic wrong#args checks.

test cmdr-color-1.0 {color, wrong num args, not enough} -body {
    cmdr color
} -returnCodes error \
    -result {wrong # args: should be "cmdr color subcommand ?argument ...?"}

test cmdr-color-1.1 {color, bogus sub-command, not enough args} -body {
    cmdr color foo
} -returnCodes error \
    -result {wrong # args: should be "::cmdr::color::Unknown cmd codes text"}

test cmdr-color-1.2 {color, bogus sub-command, bogus color name} -setup {
    set save [cmdr color active]
    cmdr color activate 1
} -body {
    cmdr color foo text
} -cleanup {
    cmdr color activate $save
    unset save
} -returnCodes error -result {Expected a color name, got "foo"}

test cmdr-color-2.0 {color, formatting, single code} -setup {
    set save [cmdr color active]
    cmdr color activate 1
} -body {
    cmdr color red text
} -cleanup {
    cmdr color activate $save
    unset save
} -result "\033\[31mtext\033\[0m"

test cmdr-color-2.1 {color, formatting, multi-code} -setup {
    set save [cmdr color active]
    cmdr color activate 1
} -body {
    cmdr color {bold red} text
} -cleanup {
    cmdr color activate $save
    unset save
} -result "\033\[1m\033\[31mtext\033\[0m"

# # ## ### ##### ######## ############# #####################
## Go through the API commands.
## active, activate, names, get, get-def, define, exists

# # ## ### ##### ######## ############# #####################
## active

test cmdr-color-active-1.0 {color active, wrong num args, too many} -body {
    cmdr color active X
} -returnCodes error \
    -result {wrong # args: should be "cmdr color active"}

test cmdr-color-active-1.1 {color active, default} -body {
    cmdr color active
} -result [cmdr tty stdout]

# # ## ### ##### ######## ############# #####################
## activate

test cmdr-color-activate-1.0 {color activate, wrong num args, too many} -body {
    cmdr color activate 0 X
} -returnCodes error \
    -result {wrong # args: should be "cmdr color activate ?flag?"}

test cmdr-color-activate-1.1 {color activate, activate explicit} -body {
    cmdr color activate 1
    cmdr color active
} -result 1

test cmdr-color-activate-1.2 {color activate, deactivate} -body {
    cmdr color activate 0
    cmdr color active
} -result 0

test cmdr-color-activate-1.3 {color activate, activate, implicit} -body {
    cmdr color activate
    cmdr color active
} -result 1

# # ## ### ##### ######## ############# #####################
## names

test cmdr-color-names-1.0 {color names, wrong num args, too many} -body {
    cmdr color names X
} -returnCodes error \
    -result {wrong # args: should be "cmdr color names"}

test cmdr-color-names-1.0 {color names, wrong num args, too many} -body {
    lsort -dict [cmdr color names]
} -result $thecolors

# # ## ### ##### ######## ############# #####################
## unset

test cmdr-color-unset-1.0 {color unset, wrong num args, not enough} -body {
    cmdr color unset
} -returnCodes error \
    -result {wrong # args: should be "cmdr color unset name"}

test cmdr-color-unset-1.1 {color unset, wrong num args, too many} -body {
    cmdr color unset N X
} -returnCodes error \
    -result {wrong # args: should be "cmdr color unset name"}

test cmdr-color-unset-1.2 {color unset, bogus color} -body {
    cmdr color unset foo
} -returnCodes error \
    -result {Expected a color name, got "foo"}

test cmdr-color-unset-1.2 {color unset, known color} -setup {
    cmdr color define foo =red
} -body {
    cmdr color unset foo
} -result {}

# # ## ### ##### ######## ############# #####################
## get

test cmdr-color-get-1.0 {color get, wrong num args, not enough} -body {
    cmdr color get
} -returnCodes error \
    -result {wrong # args: should be "cmdr color get name"}

test cmdr-color-get-1.1 {color get, wrong num args, too many} -body {
    cmdr color get N X
} -returnCodes error \
    -result {wrong # args: should be "cmdr color get name"}

test cmdr-color-get-1.2 {color get, bogus color} -body {
    cmdr color get foo
} -returnCodes error \
    -result {Expected a color name, got "foo"}

set n 0
foreach color $thecolors {
    incr n
    test cmdr-color-get-2.$n "color get, $color" -body {
	cmdr color get $color
    } -result [subst -nocommands -novariables \
		   [dict get $thechars $color]]
}

# # ## ### ##### ######## ############# #####################
## get-def

test cmdr-color-get-def-1.0 {color get-def, wrong num args, not enough} -body {
    cmdr color get-def
} -returnCodes error \
    -result {wrong # args: should be "cmdr color get-def name"}

test cmdr-color-get-def-1.1 {color get-def, wrong num args, too many} -body {
    cmdr color get-def N X
} -returnCodes error \
    -result {wrong # args: should be "cmdr color get-def name"}

test cmdr-color-get-def-1.2 {color get-def, bogus color} -body {
    cmdr color get-def foo
} -returnCodes error \
    -result {Expected a color name, got "foo"}

set n 0
foreach color $thecolors {
    incr n
    test cmdr-color-get-def-2.$n "color get-def, $color" -body {
	cmdr color get-def $color
    } -result [subst -nocommands -novariables \
		   [dict get $thedefs $color]]
}

# # ## ### ##### ######## ############# #####################
## exists

test cmdr-color-exists-1.0 {color exists, wrong num args, not enough} -body {
    cmdr color exists
} -returnCodes error \
    -result {wrong # args: should be "cmdr color exists name"}

test cmdr-color-exists-1.1 {color exists, wrong num args, too many} -body {
    cmdr color exists N X
} -returnCodes error \
    -result {wrong # args: should be "cmdr color exists name"}

test cmdr-color-exists-2.0 {color exists, unknown} -body {
    cmdr color exists foo
} -result 0

set n 0
foreach color $thecolors {
    incr n
    test cmdr-color-exists-2.$n "color exists, $color" -body {
	cmdr color exists $color
    } -result 1
}

# # ## ### ##### ######## ############# #####################
## define

test cmdr-color-define-1.0 {color define, wrong num args, not enough} -body {
    cmdr color define
} -returnCodes error \
    -result {wrong # args: should be "cmdr color define name spec"}

test cmdr-color-define-1.1 {color define, wrong num args, not enough} -body {
    cmdr color define N
} -returnCodes error \
    -result {wrong # args: should be "cmdr color define name spec"}

test cmdr-color-define-1.2 {color define, wrong num args, too many} -body {
    cmdr color define N S X
} -returnCodes error \
    -result {wrong # args: should be "cmdr color define name spec"}

test cmdr-color-define-2.0 {color define, bad reference} -body {
    cmdr color define aname =bogus
} -returnCodes error \
    -result {Expected a color name, got "bogus"}

test cmdr-color-define-2.1 {color define, bad reference, cyclic} -body {
    cmdr color define aname =aname
} -returnCodes error \
    -result {Rejected self-referential definition of "aname"}

test cmdr-color-define-2.2 {color define, reference} -body {
    lappend r [cmdr color exists aname]
    lappend r [cmdr color define aname =red]
    lappend r [cmdr color exists aname]
    lappend r [cmdr color get aname]
    lappend r [cmdr color get-def aname]
} -cleanup {
    cmdr color unset aname
    unset r
} -result [list 0 {} 1 \033\[31m =red]

test cmdr-color-define-3.0 {color define, bad rgb, syntax} -body {
    cmdr color define aname %foo
} -returnCodes error \
    -result {Expected an RGB tuple, got "foo"}

test cmdr-color-define-3.1 {color define, bad rgb, range R} -body {
    cmdr color define aname %7,3,3
} -returnCodes error \
    -result {RGB channel R out of range, got 7}

test cmdr-color-define-3.2 {color define, bad rgb, range G} -body {
    cmdr color define aname %3,7,3
} -returnCodes error \
    -result {RGB channel G out of range, got 7}

test cmdr-color-define-3.3 {color define, bad rgb, range B} -body {
    cmdr color define aname %3,3,7
} -returnCodes error \
    -result {RGB channel B out of range, got 7}

test cmdr-color-define-3.4 {color define, rgb} -body {
    lappend r [cmdr color exists aname]
    lappend r [cmdr color define aname %2,4,3]
    lappend r [cmdr color exists aname]
    lappend r [cmdr color get aname]
    lappend r [cmdr color get-def aname]
} -cleanup {
    cmdr color unset aname
    unset r
} -result [list 0 {} 1 \033\[115m %2,4,3]

test cmdr-color-define-4.0 {color define, raw control} -body {
    lappend r [cmdr color exists aname]
    lappend r [cmdr color define aname blimfizzle]
    lappend r [cmdr color exists aname]
    lappend r [cmdr color get aname]
    lappend r [cmdr color get-def aname]
} -cleanup {
    cmdr color unset aname
    unset r
} -result [list 0 {} 1 blimfizzle blimfizzle]

# # ## ### ##### ######## ############# #####################
cleanupTests
return