int main(void)
{
LOGD("main() Entered!\n");
RunAllTests();
LOGD("main() Finished!\n");
return 0;
}
void main(int argc, char* argv[]) {
struct Options options;
SetDefaultOptions(&options, 0, MAX_FFT_ORDER);
ProcessCommandLine(&options, argc, argv,
"Test forward and inverse floating-point FFT\n");
verbose = options.verbose_;
if (verbose > 255)
DumpOptions(stderr, &options);
if (options.test_mode_) {
struct TestInfo info;
info.real_only_ = options.real_only_;
info.max_fft_order_ = options.max_fft_order_;
info.min_fft_order_ = options.min_fft_order_;
info.do_forward_tests_ = options.do_forward_tests_;
info.do_inverse_tests_ = options.do_inverse_tests_;
/* No known failures */
info.known_failures_ = 0;
info.forward_threshold_ = 138.81;
info.inverse_threshold_ = 138.81;
RunAllTests(&info);
} else {
TestFloatFFT(options.fft_log_size_,
options.signal_type_,
options.signal_value_);
}
}
void CNsIRequest::OnStartTests(UINT nMenuID)
{
if (nMenuID == ID_INTERFACES_NSIREQUEST_RUNALLTESTS)
RunAllTests(9);
else
RunIndividualTests(nMenuID, 9);
}
int main(void)
{
#ifdef _DEBUG
if (shouldRunTests)
{
bool TestsPassed = RunAllTests();
if (!TestsPassed) return -1;
}
#endif
ApplicationClass* App = new ApplicationClass();
bool success = App->Initialize();
if (!success)
return -1;
while (App->Active())
{
App->Run();
}
App->ShutDown();
delete App;
App = 0;
return 0;
}
int
main(
void)
{
RunAllTests();
return 0;
}
int main(void) {
#ifdef RUN_TESTS
RunAllTests();
#else
app();
#endif
}
void CnsIEditSession::OnStartTests(UINT nMenuID)
{
switch(nMenuID)
{
case ID_INTERFACES_NSIEDITINGSESSION_RUNALLTESTS :
RunAllTests();
break;
case ID_INTERFACES_NSIEDITINGSESSION_INIT :
InitTest(2);
break;
case ID_INTERFACES_NSIEDITINGSESSION_MAKEWINDOWEDITABLE :
MakeWinEditTest(PR_FALSE, 2);
break;
case ID_INTERFACES_NSIEDITINGSESSION_WINDOWISEDITABLE :
WinIsEditTest(PR_TRUE, 2);
break;
case ID_INTERFACES_NSIEDITINGSESSION_GETEDITORFORWINDOW :
GetEditorWinTest(2);
break;
case ID_INTERFACES_NSIEDITINGSESSION_SETUPEDITORONWINDOW :
SetEditorWinTest(2);
break;
case ID_INTERFACES_NSIEDITINGSESSION_TEARDOWNEDITORONWINDOW :
TearEditorWinTest(2);
break;
}
}
int main(int argc, char ** argv) {
++argv;
--argc;
if (argc > 0 && strcmp("--list", argv[0]) == 0) {
list = true;
++argv;
--argc;
}
return RunAllTests(argc, argv);
}
int main()
{
char string[10];
RunAllTests();
gets(string);
return 0;
}
int main(int argc, char ** argv) {
log_to_file(LOG_CPERROR, stderr);
++argv;
--argc;
if (argc > 0 && strcmp("--list", argv[0]) == 0) {
list = true;
++argv;
--argc;
}
return RunAllTests(argc, argv);
}
int
main (int argc, char **argv)
{
RunAllTests();
GtkWidget *window;
GtkWidget *da;
GdkGLConfig *glconfig;
gtk_init (&argc, &argv);
gtk_gl_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
da = gtk_drawing_area_new ();
gtk_container_add (GTK_CONTAINER (window), da);
g_signal_connect_swapped (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_set_events (da, GDK_EXPOSURE_MASK);
gtk_widget_show (window);
/* prepare GL */
glconfig = gdk_gl_config_new_by_mode ((GdkGLConfigMode)
(GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE));
if (!glconfig)
{
g_assert_not_reached ();
}
if (!gtk_widget_set_gl_capability (da, glconfig, NULL, TRUE,
GDK_GL_RGBA_TYPE))
{
g_assert_not_reached ();
}
g_signal_connect (da, "configure-event",
G_CALLBACK (configure), NULL);
g_signal_connect (da, "expose-event",
G_CALLBACK (expose), NULL);
gtk_widget_show_all (window);
g_timeout_add (1000 / 30, rotate, da);
t3dInit();
gtk_main ();
}
void CNsIFile::OnStartTests(UINT nMenuID)
{
// Calls all or indivdual test cases on the basis of the
// option selected from menu.
nsCOMPtr<nsILocalFile> theTestFile(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID));
nsCOMPtr<nsILocalFile> theFileOpDir(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID));
if (!theTestFile)
{
QAOutput("File object doesn't exist. No File tests performed.", 2);
return;
}
if (!theFileOpDir)
{
QAOutput("File object doesn't exist. No File tests performed.", 2);
return;
}
switch(nMenuID)
{
case ID_INTERFACES_NSIFILE_RUNALLTESTS :
QAOutput("Begin nsIFile tests.", 1);
RunAllTests(theTestFile,theFileOpDir);
QAOutput("End nsIFile tests.", 1);
break ;
case ID_INTERFACES_NSIFILE_INITWITHPATH :
InitWithPathTest(theTestFile, 2);
break ;
case ID_INTERFACES_NSIFILE_APPENDRELATICEPATH :
AppendRelativePathTest(theTestFile, 2);
break ;
case ID_INTERFACES_NSIFILE_EXISTS :
FileCreateTest(theTestFile, 2);
break ;
case ID_INTERFACES_NSIFILE_CREATE :
FileExistsTest(theTestFile, 2);
break ;
case ID_INTERFACES_NSIFILE_COPYTO :
FileCopyTest(theTestFile, theFileOpDir, 2);
break ;
case ID_INTERFACES_NSIFILE_MOVETO :
FileMoveTest(theTestFile, theFileOpDir, 2);
break ;
}
}
int main(int argc, char* argv[]) {
struct Options options;
struct TestInfo info;
int failed_count = 0;
SetDefaultOptions(&options, 1, MAX_FFT_ORDER);
ProcessCommandLine(&options,
argc,
argv,
UsageMessage());
verbose = options.verbose_;
info.real_only_ = options.real_only_;
info.min_fft_order_ = options.min_fft_order_;
info.max_fft_order_ = options.max_fft_order_;
info.do_forward_tests_ = options.do_forward_tests_;
info.do_inverse_tests_ = options.do_inverse_tests_;
/* No known failures */
info.known_failures_ = 0;
SetThresholds(&info);
if (verbose > 255)
DumpOptions(stderr, &options);
if (options.test_mode_) {
failed_count = RunAllTests(&info);
} else {
TestOneFFT(options.fft_log_size_,
options.signal_type_,
options.signal_value_,
&info,
"Float Real FFT");
}
FinishedMessage();
return failed_count > 0 ? 1 : 0;
}
void main(int argc, char* argv[]) {
struct Options options;
SetDefaultOptions(&options, 0, MAX_FFT_ORDER);
ProcessCommandLine(&options, argc, argv,
"Test forward and inverse 32-bit fixed-point FFT\n");
verbose = options.verbose_;
signal_value = options.signal_value_;
if (verbose > 255)
DumpOptions(stderr, &options);
if (options.test_mode_) {
struct TestInfo info;
info.real_only_ = options.real_only_;
info.max_fft_order_ = options.max_fft_order_;
info.min_fft_order_ = options.min_fft_order_;
info.do_forward_tests_ = options.do_forward_tests_;
info.do_inverse_tests_ = options.do_inverse_tests_;
info.known_failures_ = 0;
/*
* These threshold values assume that we're using the default
* signal_value set below.
*/
info.forward_threshold_ = 107.33;
info.inverse_threshold_ = 79.02;
if (!options.signal_value_given_) {
signal_value = 262144; /* 18 bits */
}
RunAllTests(&info);
} else {
TestFFT(options.fft_log_size_,
options.signal_type_,
options.scale_factor_);
}
}
void main(int argc, char* argv[]) {
struct Options options;
struct TestInfo info;
SetDefaultOptions(&options, 1, MAX_FFT_ORDER);
ProcessCommandLine(&options, argc, argv,
"Test forward and inverse real floating-point FFT\n");
verbose = options.verbose_;
if (verbose > 255)
DumpOptions(stderr, &options);
info.real_only_ = options.real_only_;
info.min_fft_order_ = options.min_fft_order_;
info.max_fft_order_ = options.max_fft_order_;
info.do_forward_tests_ = options.do_forward_tests_;
info.do_inverse_tests_ = options.do_inverse_tests_;
/* No known failures */
info.known_failures_ = 0;
#ifdef BIG_FFT_TABLE
info.forward_threshold_ = 136.07;
info.inverse_threshold_ = 140.76;
#else
info.forward_threshold_ = 136.07;
info.inverse_threshold_ = 142.41;
#endif
if (options.test_mode_) {
RunAllTests(&info);
} else {
TestOneFFT(options.fft_log_size_,
options.signal_type_,
options.signal_value_,
&info,
"Float Real FFT");
}
}
void CnsIObserServ::OnStartTests(UINT nMenuID)
{
// Calls all or indivdual test cases on the basis of the
// option selected from menu.
switch(nMenuID)
{
case ID_INTERFACES_NSIOBSERVERSERVICE_RUNALLTESTS :
RunAllTests();
break;
case ID_INTERFACES_NSIOBSERVERSERVICE_ADDOBSERVERS :
AddObserversTest(2);
break;
case ID_INTERFACES_NSIOBSERVERSERVICE_ENUMERATEOBSERVERS :
QAOutput("Adding observers first", 2);
AddObserversTest(1);
EnumerateObserversTest(1);
break;
case ID_INTERFACES_NSIOBSERVERSERVICE_NOTIFYOBSERVERS :
NotifyObserversTest(1);
break;
case ID_INTERFACES_NSIOBSERVERSERVICE_REMOVEOBSERVERS :
QAOutput("Adding observers first.", 2);
AddObserversTest(1);
RemoveObserversTest(1);
break;
default :
AfxMessageBox("Menu handler not added for this menu item");
break;
}
}
int main(void)
{
RunAllTests();
system("PAUSE");
}
int main(void)
{
RunAllTests();
}
int main()
{
RunAllTests();
return 0;
}
int main(void)
{
#ifndef TESTING
DateTime alarmTime;
alarmTime.year = 2000;
alarmTime.month = 4;
alarmTime.day = 29;
alarmTime.day_of_week = 6;
alarmTime.hour = 10;
alarmTime.minute = 30;
alarmTime.second = 30;
InitializeSystem();
RTCC_SetNextAlarm(&alarmTime, SPRINKLER_Initialize);
while(1)
{
/*if(mSwitch_Prog == SWITCH_PRESSED)
{
//WIFI_PerformGet((CHAR*)"waterworx.herokuapp.com", (CHAR*)"/", DisplayResponseBody);
//WIFI_PerformPost((CHAR*)"waterworx.herokuapp.com", (CHAR*)"/", json, DisplayResponseBody);
}
if(mSwitch_User == SWITCH_PRESSED)
{
}
*/
/*if(mRtccGetIntFlag())
{
//mLED_Red_Toggle();
mRtccClrIntFlag();
SPRINKLER_Initialize();
}*/
/*if(GetCurrentDateTimeAsDWORD() > GetDateTimeAsDWORD(&alarmTime))
{
SPRINKLER_Initialize();
}*/
SPRINKLER_ProcessTasks();
WIFI_PerformStackTasks();
SERIALUSB_ProcessTasks();
RTCC_ProcessTasks();
}
#else
// Testing mode
InitializeSystem();
while(1)
{
if(mSwitch_Prog == SWITCH_PRESSED)
{
Modules[0] = RTCC_GetTestModule();
RunAllTests();
DisplayTestResults();
}
SERIALUSB_ProcessTasks();
}
#endif
}
void task()
{
RunAllTests();
vTaskEndScheduler();
}
int CommandLineTestRunner::RunAllTests(int ac, char** av)
{
return RunAllTests(ac, const_cast<const char**> (av));
}
/*---------------------------------------------------------------------------*/
int
main(void)
{
int i;
uip_ipaddr_t ipaddr;
struct timer periodic_timer, arp_timer;
timer_set(&periodic_timer, CLOCK_SECOND / 2);
timer_set(&arp_timer, CLOCK_SECOND * 10);
tapdev_init();
uip_init();
uip_ipaddr(ipaddr, 192,168,0,2);
uip_sethostaddr(ipaddr);
uip_ipaddr(ipaddr, 192,168,0,1);
uip_setdraddr(ipaddr);
uip_ipaddr(ipaddr, 255,255,255,0);
uip_setnetmask(ipaddr);
//httpd_init();
/* telnetd_init();*/
hello_world_init();
/* {
u8_t mac[6] = {1,2,3,4,5,6};
dhcpc_init(&mac, 6);
}*/
/*uip_ipaddr(ipaddr, 127,0,0,1);
smtp_configure("localhost", ipaddr);
SMTP_SEND("*****@*****.**", NULL, "*****@*****.**",
"Testing SMTP from uIP",
"Test message sent by uIP\r\n");*/
/*
webclient_init();
resolv_init();
uip_ipaddr(ipaddr, 195,54,122,204);
resolv_conf(ipaddr);
resolv_query("www.sics.se");*/
#if CUTEST //cutest
RunAllTests();
exit(0);
#else //cutest
while(1) {
uip_len = tapdev_read();
if(uip_len > 0) {
if(BUF->type == htons(UIP_ETHTYPE_IP)) {
uip_arp_ipin();
uip_input();
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if(uip_len > 0) {
uip_arp_out();
tapdev_send();
}
} else if(BUF->type == htons(UIP_ETHTYPE_ARP)) {
uip_arp_arpin();
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if(uip_len > 0) {
tapdev_send();
}
}
} else if(timer_expired(&periodic_timer)) {
timer_reset(&periodic_timer);
for(i = 0; i < UIP_CONNS; i++) {
uip_periodic(i);
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if(uip_len > 0) {
uip_arp_out();
tapdev_send();
}
}
#if UIP_UDP
for(i = 0; i < UIP_UDP_CONNS; i++) {
uip_udp_periodic(i);
/* If the above function invocation resulted in data that
should be sent out on the network, the global variable
uip_len is set to a value > 0. */
if(uip_len > 0) {
uip_arp_out();
tapdev_send();
}
}
#endif /* UIP_UDP */
/* Call the ARP timer function every 10 seconds. */
if(timer_expired(&arp_timer)) {
timer_reset(&arp_timer);
uip_arp_timer();
}
}
}
return 0;
#endif //cutest
}
int main(void)
{
RunAllTests();
return EXIT_SUCCESS;
}
int RunAllTests()
{
TestReporterStdout reporter;
return RunAllTests(reporter, Test::GetTestList());
}