204 lines
7.9 KiB
C++
204 lines
7.9 KiB
C++
#include "../../src/gui/main_window.hpp"
|
|
#include <FL/Fl.H>
|
|
#include <FL/Fl_Box.H>
|
|
#include <FL/Fl_Button.H>
|
|
#include <FL/Fl_Group.H>
|
|
#include <FL/Fl_Menu_Bar.H>
|
|
#include <FL/Fl_Tabs.H>
|
|
#include <chrono>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <initializer_list>
|
|
|
|
/* Fake only the public C backend boundary. Real FLTK widgets, callbacks and
|
|
* timers run under Xvfb; no server/device is required or touched. */
|
|
struct xtc_backend { int running = 0; };
|
|
namespace {
|
|
xtc_backend handle;
|
|
xtc_result open_result = XTC_OK, start_result = XTC_OK, stop_result = XTC_OK, close_result = XTC_OK;
|
|
xtc_result status_result = XTC_OK;
|
|
xtc_backend_status engine_status = {};
|
|
bool partial_open = false;
|
|
unsigned int opens = 0, starts = 0, stops = 0, closes = 0, collects = 0, alive = 0;
|
|
int failures = 0;
|
|
#define CHECK(c) do { if (!(c)) { std::fprintf(stderr,"FAIL %s:%d: %s\n",__FILE__,__LINE__,#c); ++failures; } } while (0)
|
|
void pump()
|
|
{
|
|
const auto end = std::chrono::steady_clock::now() + std::chrono::milliseconds(180);
|
|
while (std::chrono::steady_clock::now() < end) Fl::wait(0.02);
|
|
}
|
|
Fl_Widget *find(Fl_Group *group, const char *label)
|
|
{
|
|
for (int i = 0; i < group->children(); ++i) {
|
|
Fl_Widget *child = group->child(i);
|
|
if (child->label() != nullptr && std::strcmp(child->label(), label) == 0) return child;
|
|
auto *nested = dynamic_cast<Fl_Group *>(child);
|
|
if (nested != nullptr) if (auto *match = find(nested, label)) return match;
|
|
}
|
|
return nullptr;
|
|
}
|
|
bool contains(Fl_Group *group, const char *text)
|
|
{
|
|
for (int i = 0; i < group->children(); ++i) {
|
|
Fl_Widget *child = group->child(i);
|
|
if (child->label() != nullptr && std::strstr(child->label(), text) != nullptr) return true;
|
|
if (auto *nested = dynamic_cast<Fl_Group *>(child)) if (contains(nested, text)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
void press(Fl_Widget *widget)
|
|
{
|
|
CHECK(widget != nullptr);
|
|
if (widget != nullptr) widget->do_callback();
|
|
}
|
|
void reset()
|
|
{
|
|
CHECK(alive == 0U);
|
|
open_result = start_result = stop_result = close_result = status_result = XTC_OK;
|
|
engine_status = {};
|
|
engine_status.sample_rate = 48000U;
|
|
engine_status.buffer_frames = 1024U;
|
|
partial_open = false;
|
|
}
|
|
}
|
|
extern "C" {
|
|
xtc_result xtc_backend_open(const xtc_backend_config *config, xtc_backend **out)
|
|
{
|
|
CHECK(config->kind == XTC_BACKEND_JACK && config->channel_count == 1U);
|
|
++opens;
|
|
*out = open_result == XTC_OK || partial_open ? &handle : nullptr;
|
|
if (*out != nullptr) { ++alive; handle.running = 0; }
|
|
return open_result;
|
|
}
|
|
xtc_result xtc_backend_close(xtc_backend *backend)
|
|
{
|
|
if (backend == nullptr) return XTC_OK;
|
|
++closes;
|
|
if (close_result == XTC_OK) { CHECK(alive == 1U); --alive; handle.running = 0; }
|
|
return close_result;
|
|
}
|
|
xtc_result xtc_backend_start(xtc_backend *backend)
|
|
{ CHECK(backend == &handle); ++starts; if (start_result == XTC_OK) handle.running = 1; return start_result; }
|
|
xtc_result xtc_backend_stop(xtc_backend *backend)
|
|
{ CHECK(backend == &handle); ++stops; if (stop_result == XTC_OK) handle.running = 0; return stop_result; }
|
|
xtc_result xtc_backend_get_status(const xtc_backend *backend, xtc_backend_status *status)
|
|
{
|
|
CHECK(backend == &handle && alive == 1U);
|
|
*status = engine_status;
|
|
status->running = handle.running && !status->server_lost;
|
|
return status_result;
|
|
}
|
|
void xtc_backend_collect(xtc_backend *backend)
|
|
{ CHECK(backend == &handle && alive == 1U); ++collects; }
|
|
}
|
|
int main(int argc, char **argv)
|
|
{
|
|
reset();
|
|
{
|
|
MainWindow window;
|
|
window.show(argc, argv);
|
|
auto *play = find(&window, "Play");
|
|
auto *stop = find(&window, "Stop");
|
|
auto *reconnect = find(&window, "Reconnect");
|
|
CHECK(play != nullptr && stop != nullptr && reconnect != nullptr);
|
|
if (play == nullptr || stop == nullptr || reconnect == nullptr) return 1;
|
|
CHECK(play->active() && !stop->active());
|
|
CHECK(contains(&window, "ready / stopped"));
|
|
press(play);
|
|
CHECK(starts == 1U && !play->active() && stop->active());
|
|
CHECK(contains(&window, "running (silence"));
|
|
press(stop);
|
|
CHECK(stops == 1U && play->active() && !stop->active());
|
|
start_result = XTC_ERR_IO;
|
|
press(play);
|
|
CHECK(contains(&window, "Start engine failed: I/O error"));
|
|
pump(); // A refresh must not erase a command error.
|
|
CHECK(contains(&window, "Start engine failed: I/O error"));
|
|
start_result = XTC_OK;
|
|
press(play);
|
|
CHECK(!contains(&window, "Start engine failed"));
|
|
stop_result = XTC_ERR_IO;
|
|
press(stop);
|
|
CHECK(contains(&window, "Stop engine failed") && stop->active());
|
|
stop_result = XTC_OK;
|
|
press(stop);
|
|
Fl_Menu_Bar *menu = nullptr;
|
|
Fl_Tabs *tabs = nullptr;
|
|
for (int i = 0; i < window.children(); ++i) {
|
|
if (auto *found = dynamic_cast<Fl_Menu_Bar *>(window.child(i))) menu = found;
|
|
if (auto *found = dynamic_cast<Fl_Tabs *>(window.child(i))) tabs = found;
|
|
}
|
|
CHECK(menu != nullptr && tabs != nullptr);
|
|
if (menu == nullptr || tabs == nullptr) return 1;
|
|
for (const char *view : {"View/Mixer", "View/Modular Graph", "View/Sequencer"}) {
|
|
const Fl_Menu_Item *item = menu->find_item(view);
|
|
CHECK(item != nullptr);
|
|
if (item != nullptr) {
|
|
menu->picked(item);
|
|
CHECK(std::strcmp(tabs->value()->label(), std::strchr(view, '/') + 1) == 0);
|
|
}
|
|
}
|
|
engine_status.xruns = 3U;
|
|
engine_status.processed_blocks = 123U;
|
|
pump();
|
|
CHECK(contains(&window, "123 blocks | 3 xruns"));
|
|
engine_status.sample_rate_changed = 1;
|
|
pump();
|
|
CHECK(contains(&window, "sample rate changed") && !play->active());
|
|
engine_status.sample_rate_changed = 0;
|
|
engine_status.server_lost = 1;
|
|
pump();
|
|
CHECK(contains(&window, "server lost") && !play->active());
|
|
engine_status.server_lost = 0;
|
|
press(reconnect);
|
|
CHECK(contains(&window, "ready / stopped") && play->active());
|
|
status_result = XTC_ERR_IO;
|
|
pump();
|
|
CHECK(contains(&window, "status unavailable") && !play->active());
|
|
status_result = XTC_OK;
|
|
press(reconnect);
|
|
close_result = XTC_ERR_IO;
|
|
press(reconnect);
|
|
CHECK(contains(&window, "Reconnect could not close JACK") && alive == 1U);
|
|
window.do_callback();
|
|
CHECK(window.shown() && alive == 1U && contains(&window, "window kept open for retry"));
|
|
close_result = XTC_OK;
|
|
menu->picked(menu->find_item("File/Quit"));
|
|
CHECK(!window.shown() && alive == 0U);
|
|
unsigned int before = collects;
|
|
pump();
|
|
CHECK(collects == before); // Removed timer cannot call a closed backend.
|
|
}
|
|
for (xtc_result failure : {XTC_ERR_IO, XTC_ERR_UNSUPPORTED}) {
|
|
reset();
|
|
open_result = failure;
|
|
MainWindow window;
|
|
window.show(argc, argv);
|
|
CHECK(contains(&window, "Open JACK failed") && !find(&window, "Play")->active());
|
|
open_result = XTC_OK;
|
|
press(find(&window, "Reconnect"));
|
|
CHECK(find(&window, "Play")->active());
|
|
press(find(&window, "Play"));
|
|
window.do_callback(); // Close while running, without a preceding stop.
|
|
CHECK(!window.shown() && alive == 0U);
|
|
}
|
|
reset();
|
|
partial_open = true;
|
|
open_result = XTC_ERR_IO;
|
|
{
|
|
MainWindow window;
|
|
CHECK(alive == 1U && !find(&window, "Play")->active());
|
|
window.do_callback(); // Partially initialized handles are closed only.
|
|
CHECK(alive == 0U);
|
|
}
|
|
reset();
|
|
for (int i = 0; i < 10; ++i) {
|
|
MainWindow window;
|
|
press(find(&window, "Play"));
|
|
window.do_callback();
|
|
}
|
|
CHECK(alive == 0U);
|
|
if (failures != 0) return 1;
|
|
std::printf("GUI controls/errors/views/timers/cleanup passed: %u opens, %u closes.\n", opens, closes);
|
|
return 0;
|
|
}
|