set test "sid configuration"
sid_config_component_test "base.conf" \
    "load [sid_find_file libmemory.la] mem_component_library" \
    "hw-memory-ram/rom-basic"
pass $test


set test "sid startup"
if [sid_start "base.conf"] then { pass $test } else { fail $test ; return }

set test "attribute list"
sid_assert_includes_all "sid::component::attribute_names $victim" "size state-snapshot"

set test "set size = 512"
sid_assert_success "sid::component::set_attribute_value $victim size 0x200"

set test "get buses"
set robus [sid_cmd "sid::component::find_bus $victim read-only-port"]
set rwbus [sid_cmd "sid::component::find_bus $victim read-write-port"]
if {$robus == "" || $rwbus == ""} then { fail $test } else { pass $test }

set test "fill memory with junk bytes"
set data 4
set size [sid_cmd "sid::component::attribute_value $victim size"]
for {set addr 0} {$addr < $size} {incr addr} {
# some pseudorandom sequence
    set data [expr {(($data * 17) + 23) % 256}]
    set result [sid_cmd "sid::bus::write_h4_l1 $rwbus $addr $data"]
    if {$result != "ok"} then { fail $test ; break }
}
if {$addr == $size} then { pass $test } else { fail $test }

set test "read junk from memory via read-only port"
set data 4
set size [sid_cmd "sid::component::attribute_value $victim size"]
for {set addr 0} {$addr < $size} {incr addr} {
# same pseudorandom sequence as above
    set data [expr {(($data * 17) + 23) % 256}]
    set result [sid_cmd "sid::bus::read_h4_l1 $robus $addr"]
    set status [lindex $result 0]
    if {$status != "ok"} then {fail "$test - bad" ; break }
    set result_data [lindex $result 1]
    if {$result_data != $data} then {fail "$test - mismatch @ $addr - $result_data vs $data" ; break}
}
if {$addr == $size} then { pass $test } else { fail $test }

set test "get memory state dump"
set state [sid_cmd "sid::component::attribute_value $victim state-snapshot"]
if {$state != ""} then { pass $test } else { fail $test }

set test "reset memory size"
sid_assert_success "sid::component::set_attribute_value $victim size 234000"

set test "spot check clear memory"
set result0 [sid_cmd "sid::bus::read_h4_l1 $rwbus 0x0"]
set result1 [sid_cmd "sid::bus::read_h4_l1 $rwbus 0x2F4D"]
set result2 [sid_cmd "sid::bus::read_h4_l1 $rwbus 0x39BA"]
if {$result0 != "ok 0" || $result1 != "ok 0" || $result2 != "ok 0"} then { fail $test } else { pass $test }

set test "set memory state dump"
#set t $timeout ; set timeout 30
set ok [sid_cmd "sid::component::set_attribute_value $victim state-snapshot [list $state]"]
#set timeout $t
if {$ok == "ok"} then { pass $test } else { fail $test }

set test "check memory size after restore"
set new_size [sid_cmd "sid::component::attribute_value $victim size"]
if {$size == $new_size} then { pass $test } else { fail $test }

set test "reread junk from memory after restore"
set data 4
set size [sid_cmd "sid::component::attribute_value $victim size"]
for {set addr 0} {$addr < $size} {incr addr} {
# same pseudorandom sequence as above
    set data [expr {(($data * 17) + 23) % 256}]
    set result [sid_cmd "sid::bus::read_h4_l1 $robus $addr"]
    set status [lindex $result 0]
    if {$status != "ok"} then {fail "$test - bad" ; break}
    set result_data [lindex $result 1]
    if {$result_data != $data} then {fail "$test - mismatch @ $addr - $result_data vs $data" ; break}
}
if {$addr == $size} then { pass $test } else { fail $test }

set test "test for memory leaks"
set iterations 100
for {set i 0} {$i < $iterations} {incr i} {
# some size between 1 .. 16 MB
    set size [expr {1000000 + (($i * 101) % 16) * 1000000}]
    sid_cmd "sid::component::set_attribute_value $victim size $size"
}
sid_assert_success "sid::component::set_attribute_value $victim size 0"

set test "resize memory for file test"  
sid_assert_success "sid::component::set_attribute_value $victim size 7234"

set test "read memory image from a file"
set file [open "test.dat" "w"]
fconfigure $file -translation binary
set data 0
set size [sid_cmd "sid::component::attribute_value $victim size"]
for {set i 0} {$i < $size} {incr i} {
    set data [expr {(($data * 19) + 13) % 256}]
    puts -nonewline $file [binary format "c" $data]
}
close $file
set res [sid_cmd "sid::component::set_attribute_value $victim image-file test.dat"]
set pin [sid_cmd "sid::component::find_pin $victim image-load"]
sid_cmd "sid::pin::driven_h4 $pin 0"
file delete -force $file
if {$res == "ok" && $pin != ""} then { pass $test } else { fail $test }

set test "verify read memory image"
set data 0
set size [sid_cmd "sid::component::attribute_value $victim size"]
for {set i 0} {$i < $size} {incr i} {
    set data [expr {(($data * 19) + 13) % 256}]
    set result [sid_cmd "sid::bus::read_h4_l1 $robus $i"]
    set status [lindex $result 0]
    if {$status != "ok"} then {fail "$test - bad" ; break}
    set result_data [lindex $result 1]
    if {$result_data != $data} then {fail "$test - mismatch @ $i - $result_data vs $data" ; break}
}
if {$i == $size} then { pass $test } else { fail $test }

set test "make a big memory buffer"
set size 10000
sid_assert_success "sid::component::set_attribute_value $victim size $size"

set test "fill it sparsely"
set data 0
set sparse 10
for {set i 0} {$i < $sparse} {incr i} {
    set data [expr {(($data * 19) + 13) % $size}]
    set addr $data
    set result [sid_cmd "sid::bus::write_h4_l1 $rwbus $addr 0xFE"]
    if {$result != "ok"} then { fail $test ; break }
}
if {$i == $sparse} then { pass $test } else { fail $test }

set test "take sparse (RLE) snapshot"
set state [sid_cmd "sid::component::attribute_value $victim state-snapshot"]
if {[string length $state] < 10 || [string length $state] > 5000} then { fail $test } else { pass $test }

set test "clear memory"
set result [sid_cmd "sid::component::set_attribute_value $victim size 0"]
if {$result == "ok"} then { pass $test } else { fail $test }

set test "reload sparse (RLE) snapshot"
set result [sid_cmd "sid::component::set_attribute_value $victim state-snapshot [list $state]"]
if {$result == "ok"} then { pass $test } else { fail $test }

set test "load junk snapshot"
set result [sid_cmd "sid::component::set_attribute_value $victim state-snapshot bad-crap-bad-crap"]
if {$result == "bad_value"} then { pass $test } else { fail $test }

set test "save & restore large memory snapshot"
set o1 [sid_cmd "sid::component::set_attribute_value $victim size 800000"]
set state [sid_cmd "sid::component::attribute_value $victim state-snapshot"]
set o2 [sid_cmd "sid::component::set_attribute_value $victim state-snapshot [list $state]"]
if {$state != "" && $o1 == "ok" && $o2 == "ok"} then { pass $test } else { fail "$test - $o1 $o2" }

set test "sid stop"
if [sid_stop] then { pass $test } else { fail $test ; return }


# zap temp file if tests were successful 
global exit_status
if {$exit_status == "0"} then { file delete "base.conf" }