use Test;
use lib 'lib';
use lib 't/lib';
use TestHelper;
use NativeCall;
use Notcurses::Native;
use Notcurses::Native::Types;
use Notcurses::Native::Plane;
use Notcurses::Native::Cell;
use Notcurses::Native::Widgets;
plan 8;
my $opts = NotcursesOptions.new(
:loglevel(NCLOGLEVEL_SILENT),
:flags(NCOPTION_SUPPRESS_BANNERS +| NCOPTION_NO_ALTERNATE_SCREEN +| NCOPTION_INHIBIT_SETLOCALE),
);
my ($nc, $) = test-init-nc($opts);
unless $nc.defined {
skip 'No terminal available', 8;
exit 0;
}
LEAVE { notcurses_stop($nc) if $nc.defined }
my $std = notcurses_stdplane($nc);
# === 1. Progress bar lifecycle ===
subtest 'Progress bar lifecycle' => {
plan 16;
my $plane = ncplane_create($std, NcplaneOptions.new(:rows(1), :cols(40)));
ok $plane.defined, 'Created plane for progress bar';
my $popts = NcprogbarOptions.new(:ulchannel(0), :urchannel(0), :blchannel(0), :brchannel(0));
my $bar = ncprogbar_create($plane, $popts);
ok $bar.defined, 'Progress bar created';
# Set and verify progress at multiple points
my int32 $rc;
$rc = ncprogbar_set_progress($bar, 0e0);
is $rc, 0, 'Set progress to 0.0';
my num64 $p = ncprogbar_progress($bar);
ok $p >= -0.01e0 && $p <= 0.01e0, "Read back progress 0.0 (got $p)";
$rc = ncprogbar_set_progress($bar, 0.25e0);
is $rc, 0, 'Set progress to 0.25';
$p = ncprogbar_progress($bar);
ok $p >= 0.24e0 && $p <= 0.26e0, "Read back progress 0.25 (got $p)";
$rc = ncprogbar_set_progress($bar, 0.5e0);
is $rc, 0, 'Set progress to 0.5';
$p = ncprogbar_progress($bar);
ok $p >= 0.49e0 && $p <= 0.51e0, "Read back progress 0.5 (got $p)";
$rc = ncprogbar_set_progress($bar, 0.75e0);
is $rc, 0, 'Set progress to 0.75';
$p = ncprogbar_progress($bar);
ok $p >= 0.74e0 && $p <= 0.76e0, "Read back progress 0.75 (got $p)";
$rc = ncprogbar_set_progress($bar, 1e0);
is $rc, 0, 'Set progress to 1.0';
$p = ncprogbar_progress($bar);
ok $p >= 0.99e0 && $p <= 1.01e0, "Read back progress 1.0 (got $p)";
# Verify plane accessor
my $bplane = ncprogbar_plane($bar);
ok $bplane.defined, 'ncprogbar_plane returns a valid plane';
# Test retrograde flag
my $plane2 = ncplane_create($std, NcplaneOptions.new(:rows(1), :cols(40)));
my $retro-opts = NcprogbarOptions.new(:flags(NCPROGBAR_OPTION_RETROGRADE));
my $retro-bar = ncprogbar_create($plane2, $retro-opts);
ok $retro-bar.defined, 'Retrograde progress bar created';
$rc = ncprogbar_set_progress($retro-bar, 0.5e0);
is $rc, 0, 'Set retrograde bar progress to 0.5';
$p = ncprogbar_progress($retro-bar);
ok $p >= 0.49e0 && $p <= 0.51e0, "Retrograde bar reads back 0.5 (got $p)";
ncprogbar_destroy($retro-bar);
ncprogbar_destroy($bar);
};
# === 2. Reel lifecycle ===
subtest 'Reel lifecycle' => {
plan 5;
my $plane = ncplane_create($std, NcplaneOptions.new(:rows(10), :cols(30)));
ok $plane.defined, 'Created plane for reel';
my $ropts = NcreelOptions.new;
my $reel = ncreel_create($plane, $ropts);
ok $reel.defined, 'Reel created';
is ncreel_tabletcount($reel), 0, 'Empty reel has 0 tablets';
my $rplane = ncreel_plane($reel);
ok $rplane.defined, 'ncreel_plane returns a valid plane';
my int32 $rc = ncreel_redraw($reel);
is $rc, 0, 'ncreel_redraw succeeds on empty reel';
ncreel_destroy($reel);
};
# === 3. Tabbed full lifecycle ===
subtest 'Tabbed full lifecycle' => {
plan 24;
my $plane = ncplane_create($std, NcplaneOptions.new(:rows(10), :cols(50)));
ok $plane.defined, 'Created plane for tabbed widget';
my $topts = NctabbedOptions.new(:separator(' | '));
my $tabbed = nctabbed_create($plane, $topts);
ok $tabbed.defined, 'Tabbed widget created';
is nctabbed_tabcount($tabbed), 0, 'No tabs initially';
# Add 3 tabs (pass type objects for NULL after/before, Pointer for NULL callback/opaque)
my $tab1 = nctabbed_add($tabbed, NctabHandle, NctabHandle, Pointer, 'Tab1', Pointer);
ok $tab1.defined, 'Added Tab1';
my $tab2 = nctabbed_add($tabbed, NctabHandle, NctabHandle, Pointer, 'Tab2', Pointer);
ok $tab2.defined, 'Added Tab2';
my $tab3 = nctabbed_add($tabbed, NctabHandle, NctabHandle, Pointer, 'Tab3', Pointer);
ok $tab3.defined, 'Added Tab3';
is nctabbed_tabcount($tabbed), 3, 'Tab count is 3 after adding 3 tabs';
# Get selected tab and verify its name
my $selected = nctabbed_selected($tabbed);
ok $selected.defined, 'Got selected tab handle';
my $name = nctab_name($selected);
ok $name.defined, "Selected tab has a name: $name";
# Navigate forward
my $next = nctabbed_next($tabbed);
ok $next.defined, 'nctabbed_next returns a tab';
my $next-name = nctab_name($next);
ok $next-name.defined, "Next tab name: $next-name";
# Navigate backward
my $prev = nctabbed_prev($tabbed);
ok $prev.defined, 'nctabbed_prev returns a tab';
# Verify separator
my $sep = nctabbed_separator($tabbed);
is $sep, ' | ', 'Separator is " | "';
my int32 $sep-width = nctabbed_separator_width($tabbed);
is $sep-width, 3, 'Separator width is 3';
# Get/set channels
my uint64 $hdrchan = nctabbed_hdrchan($tabbed);
ok $hdrchan.defined, "Got hdrchan: $hdrchan";
my uint64 $selchan = nctabbed_selchan($tabbed);
ok $selchan.defined, "Got selchan: $selchan";
my uint64 $sepchan = nctabbed_sepchan($tabbed);
ok $sepchan.defined, "Got sepchan: $sepchan";
nctabbed_set_hdrchan($tabbed, 0x0000FF00_0000FF00);
my uint64 $new-hdr = nctabbed_hdrchan($tabbed);
is $new-hdr, 0x0000FF00_0000FF00, 'Set and read back hdrchan';
# Set tab name
my int32 $rc = nctab_set_name($tab1, 'Renamed');
is $rc, 0, 'nctab_set_name succeeded';
my $renamed = nctab_name($tab1);
is $renamed, 'Renamed', 'Tab name updated to Renamed';
# Move tabs
nctab_move_right($tabbed, $tab1);
nctab_move_left($tabbed, $tab1);
ok True, 'Move right/left did not crash';
# Get content plane
my $cplane = nctabbed_content_plane($tabbed);
ok $cplane.defined, 'Got content plane';
# Delete a tab
$rc = nctabbed_del($tabbed, $tab3);
is $rc, 0, 'Deleted Tab3';
is nctabbed_tabcount($tabbed), 2, 'Tab count is 2 after deletion';
# Redraw and destroy
nctabbed_redraw($tabbed);
nctabbed_destroy($tabbed);
};
# === 4. uint64 Plot lifecycle ===
subtest 'uint64 Plot lifecycle' => {
plan 8;
my $plane = ncplane_create($std, NcplaneOptions.new(:rows(5), :cols(40)));
ok $plane.defined, 'Created plane for uint64 plot';
my $popts = NcplotOptions.new(:rangex(10));
my $plot = ncuplot_create($plane, $popts, 0, 100);
ok $plot.defined, 'ncuplot created with range 0..100';
my $pplane = ncuplot_plane($plot);
ok $pplane.defined, 'ncuplot_plane returns valid plane';
my int32 $rc;
$rc = ncuplot_add_sample($plot, 0, 50);
is $rc, 0, 'ncuplot_add_sample(0, 50) succeeded';
$rc = ncuplot_add_sample($plot, 1, 75);
is $rc, 0, 'ncuplot_add_sample(1, 75) succeeded';
$rc = ncuplot_set_sample($plot, 2, 25);
is $rc, 0, 'ncuplot_set_sample(2, 25) succeeded';
# Read back sample at slot 2
my uint64 $y = 0;
$rc = ncuplot_sample($plot, 2, $y);
is $rc, 0, 'ncuplot_sample read succeeded';
is $y, 25, 'ncuplot_sample reads back 25 at slot 2';
ncuplot_destroy($plot);
};
# === 5. double Plot lifecycle ===
subtest 'double Plot lifecycle' => {
plan 8;
my $plane = ncplane_create($std, NcplaneOptions.new(:rows(5), :cols(40)));
ok $plane.defined, 'Created plane for double plot';
my $popts = NcplotOptions.new(:rangex(10));
my $plot = ncdplot_create($plane, $popts, 0e0, 100e0);
ok $plot.defined, 'ncdplot created with range 0.0..100.0';
my $pplane = ncdplot_plane($plot);
ok $pplane.defined, 'ncdplot_plane returns valid plane';
my int32 $rc;
$rc = ncdplot_add_sample($plot, 0, 50.5e0);
is $rc, 0, 'ncdplot_add_sample(0, 50.5) succeeded';
$rc = ncdplot_set_sample($plot, 1, 75.25e0);
is $rc, 0, 'ncdplot_set_sample(1, 75.25) succeeded';
# Read back sample at slot 1
my num64 $y = 0e0;
$rc = ncdplot_sample($plot, 1, $y);
is $rc, 0, 'ncdplot_sample read succeeded';
ok $y >= 75.24e0 && $y <= 75.26e0, "ncdplot_sample reads back ~75.25 at slot 1 (got $y)";
$rc = ncdplot_set_sample($plot, 2, 0e0);
is $rc, 0, 'ncdplot_set_sample(2, 0.0) succeeded for boundary value';
ncdplot_destroy($plot);
};
# === 6. Reader lifecycle ===
subtest 'Reader lifecycle' => {
plan 10;
my $plane = ncplane_create($std, NcplaneOptions.new(:rows(3), :cols(30)));
ok $plane.defined, 'Created plane for reader';
my $ropts = NcreaderOptions.new(:flags(NCREADER_OPTION_CURSOR));
my $reader = ncreader_create($plane, $ropts);
ok $reader.defined, 'Reader created with cursor option';
my $rplane = ncreader_plane($reader);
ok $rplane.defined, 'ncreader_plane returns valid plane';
# Write text character by character
my int32 $rc;
$rc = ncreader_write_egc($reader, 'H');
is $rc, 0, 'Wrote "H" to reader';
$rc = ncreader_write_egc($reader, 'i');
is $rc, 0, 'Wrote "i" to reader';
# Read contents back
my $contents = ncreader_contents($reader);
ok $contents.defined && $contents.contains('Hi'), "Contents contain 'Hi' (got: {$contents.raku})";
# Move cursor left and right
$rc = ncreader_move_left($reader);
ok $rc == 0 || $rc == -1, "ncreader_move_left returned $rc (0 or -1 acceptable)";
$rc = ncreader_move_right($reader);
ok $rc == 0 || $rc == -1, "ncreader_move_right returned $rc (0 or -1 acceptable)";
# Clear the reader
$rc = ncreader_clear($reader);
is $rc, 0, 'ncreader_clear succeeded';
# Contents after clear should be empty or whitespace
my $after-clear = ncreader_contents($reader);
ok !$after-clear.defined || $after-clear.trim eq '', "Contents after clear are empty (got: {($after-clear // '').raku})";
ncreader_destroy($reader, Pointer);
};
# === 7. Multiselector lifecycle ===
subtest 'Multiselector lifecycle' => {
plan 3;
my $plane = ncplane_create($std, NcplaneOptions.new(:rows(10), :cols(40)));
ok $plane.defined, 'Created plane for multiselector';
# Create with no items (empty options)
my $msopts = NcmultiselectorOptions.new(:title('Select items'), :footer('Space to toggle'));
my $msel = ncmultiselector_create($plane, $msopts);
ok $msel.defined, 'Multiselector created';
my $msplane = ncmultiselector_plane($msel);
ok $msplane.defined, 'ncmultiselector_plane returns valid plane';
ncmultiselector_destroy($msel);
};
# === 8. Selector lifecycle ===
subtest 'Selector lifecycle' => {
plan 10;
my $plane = ncplane_create($std, NcplaneOptions.new(:rows(10), :cols(40)));
ok $plane.defined, 'Created plane for selector';
my $sopts = NcselectorOptions.new(:title('Pick one'), :footer('Use arrows'));
my $sel = ncselector_create($plane, $sopts);
ok $sel.defined, 'Selector created';
my $splane = ncselector_plane($sel);
ok $splane.defined, 'ncselector_plane returns valid plane';
# Add items
my $item-a = NcselectorItem.new(:option('alpha'), :desc('First option'));
my int32 $rc = ncselector_additem($sel, $item-a);
is $rc, 0, 'Added item alpha';
my $item-b = NcselectorItem.new(:option('beta'), :desc('Second option'));
$rc = ncselector_additem($sel, $item-b);
is $rc, 0, 'Added item beta';
my $item-c = NcselectorItem.new(:option('gamma'), :desc('Third option'));
$rc = ncselector_additem($sel, $item-c);
is $rc, 0, 'Added item gamma';
# Get selected — should be the first item
my $selected = ncselector_selected($sel);
ok $selected.defined, "Selected item: $selected";
# Navigate forward
my $next = ncselector_nextitem($sel);
ok $next.defined, "After nextitem, selected: $next";
# Navigate backward
my $prev = ncselector_previtem($sel);
ok $prev.defined, "After previtem, selected: $prev";
# Delete an item
$rc = ncselector_delitem($sel, 'gamma');
is $rc, 0, 'Deleted item gamma';
ncselector_destroy($sel, Pointer);
};
done-testing;