sergiotarxz/nuttx-apps
sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Update all unit tests to conform to recent naming convention changes in NuttX

Browse Source 
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@5151 42af7a65-404d-4744-a932-0658087f49c3
This commit is contained in:
patacongo 2012-09-14 15:23:54 +00:00
parent 8038b6c441
commit 66f26d33fc
53 changed files with 308 additions and 484 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ChangeLog.txt
View File

@ -159,3 +159,7 @@
recent check-ins. recent check-ins.
1.3 2012-xx-xx Gregory Nutt <gnutt@nuttx.org> 1.3 2012-xx-xx Gregory Nutt <gnutt@nuttx.org>
* UnitTests/*/main.cxx: Change entry point name to be consistent
with with entry point naming conventions introduced in NuttX
6.22.

2
UnitTests/CButton/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx cbuttontest.cxx CXXSRCS = cbutton_main.cxx cbuttontest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

28
UnitTests/CButton/main.cxx → UnitTests/CButton/cbutton_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CButton/main.cxx // NxWidgets/UnitTests/CButton/cbutton_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -68,7 +68,7 @@ static const char g_pushme[] = "Push Me";
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int cbutton_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Public Functions // Public Functions
@ -78,29 +78,29 @@ extern "C" int MAIN_NAME(int argc, char *argv[]);
// user_start/nxheaders_main // user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int cbutton_main(int argc, char *argv[])
{ {
// Create an instance of the font test // Create an instance of the font test
printf(MAIN_STRING "Create CButtonTest instance\n"); printf("cbutton_main: Create CButtonTest instance\n");
CButtonTest *test = new CButtonTest(); CButtonTest *test = new CButtonTest();
// Connect the NX server // Connect the NX server
printf(MAIN_STRING "Connect the CButtonTest instance to the NX server\n"); printf("cbutton_main: Connect the CButtonTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
printf(MAIN_STRING "Failed to connect the CButtonTest instance to the NX server\n"); printf("cbutton_main: Failed to connect the CButtonTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
// Create a window to draw into // Create a window to draw into
printf(MAIN_STRING "Create a Window\n"); printf("cbutton_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
printf(MAIN_STRING "Failed to create a window\n"); printf("cbutton_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
@ -110,26 +110,26 @@ int MAIN_NAME(int argc, char *argv[])
CButton *button = test->createButton(g_pushme); CButton *button = test->createButton(g_pushme);
if (!button) if (!button)
{ {
printf(MAIN_STRING "Failed to create a button\n"); printf("cbutton_main: Failed to create a button\n");
delete test; delete test;
return 1; return 1;
} }
// Show the button // Show the button
printf(MAIN_STRING "Show the button\n"); printf("cbutton_main: Show the button\n");
test->showButton(button); test->showButton(button);
// Wait two seconds, then perform a simulated mouse click on the button // Wait two seconds, then perform a simulated mouse click on the button
sleep(2); sleep(2);
printf(MAIN_STRING "Click the button\n"); printf("cbutton_main: Click the button\n");
test->click(); test->click();
// Poll for the mouse click event (of course this can hang if something fails) // Poll for the mouse click event (of course this can hang if something fails)
bool clicked = test->poll(button); bool clicked = test->poll(button);
printf(MAIN_STRING "Button is %s\n", clicked ? "clicked" : "released"); printf("cbutton_main: Button is %s\n", clicked ? "clicked" : "released");
// Wait a second, then release the mouse buttone // Wait a second, then release the mouse buttone
@ -139,7 +139,7 @@ int MAIN_NAME(int argc, char *argv[])
// Poll for the mouse release event (of course this can hang if something fails) // Poll for the mouse release event (of course this can hang if something fails)
clicked = test->poll(button); clicked = test->poll(button);
printf(MAIN_STRING "Button is %s\n", clicked ? "clicked" : "released"); printf("cbutton_main: Button is %s\n", clicked ? "clicked" : "released");
// Wait a few more seconds so that the tester can ponder the result // Wait a few more seconds so that the tester can ponder the result
@ -147,7 +147,7 @@ int MAIN_NAME(int argc, char *argv[])
// Clean up and exit // Clean up and exit
printf(MAIN_STRING "Clean-up and exit\n"); printf("cbutton_main: Clean-up and exit\n");
delete button; delete button;
delete test; delete test;
return 0; return 0;

10
UnitTests/CButton/cbuttontest.hxx
View File

@ -75,16 +75,6 @@
# define CONFIG_CBUTTONTEST_FONTCOLOR CONFIG_NXWIDGETS_DEFAULT_FONTCOLOR # define CONFIG_CBUTTONTEST_FONTCOLOR CONFIG_NXWIDGETS_DEFAULT_FONTCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME cbutton_main
# define MAIN_STRING "cbutton_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Public Classes // Public Classes
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////

2
UnitTests/CButtonArray/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx cbuttonarraytest.cxx CXXSRCS = cbuttonarray_main.cxx cbuttonarraytest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

32
UnitTests/CButtonArray/main.cxx → UnitTests/CButtonArray/cbuttonarray_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CButtonArray/main.cxx // NxWidgets/UnitTests/CButtonArray/cbuttonarray_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -82,7 +82,7 @@ static FAR const char *g_buttonLabels[BUTTONARRAY_NCOLUMNS*BUTTONARRAY_NROWS] =
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int cbuttonarray_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Private Functions // Private Functions
@ -196,7 +196,7 @@ static void checkHighlighting(CButtonArray *buttonArray)
// user_start/nxheaders_main // user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int cbuttonarray_main(int argc, char *argv[])
{ {
// Initialize memory monitor logic // Initialize memory monitor logic
@ -204,16 +204,16 @@ int MAIN_NAME(int argc, char *argv[])
// Create an instance of the button array test // Create an instance of the button array test
printf(MAIN_STRING "Create CButtonArrayTest instance\n"); printf("cbuttonarray_main: Create CButtonArrayTest instance\n");
CButtonArrayTest *test = new CButtonArrayTest(); CButtonArrayTest *test = new CButtonArrayTest();
updateMemoryUsage(g_mmPrevious, "After creating CButtonArrayTest"); updateMemoryUsage(g_mmPrevious, "After creating CButtonArrayTest");
// Connect the NX server // Connect the NX server
printf(MAIN_STRING "Connect the CButtonArrayTest instance to the NX server\n"); printf("cbuttonarray_main: Connect the CButtonArrayTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
printf(MAIN_STRING "Failed to connect the CButtonArrayTest instance to the NX server\n"); printf("cbuttonarray_main: Failed to connect the CButtonArrayTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
@ -221,10 +221,10 @@ int MAIN_NAME(int argc, char *argv[])
// Create a window to draw into // Create a window to draw into
printf(MAIN_STRING "Create a Window\n"); printf("cbuttonarray_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
printf(MAIN_STRING "Failed to create a window\n"); printf("cbuttonarray_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
@ -235,7 +235,7 @@ int MAIN_NAME(int argc, char *argv[])
CButtonArray *buttonArray = test->createButtonArray(); CButtonArray *buttonArray = test->createButtonArray();
if (!buttonArray) if (!buttonArray)
{ {
printf(MAIN_STRING "Failed to create a button array\n"); printf("cbuttonarray_main: Failed to create a button array\n");
delete test; delete test;
return 1; return 1;
} }
@ -248,7 +248,7 @@ int MAIN_NAME(int argc, char *argv[])
{ {
for (int i = 0; i < BUTTONARRAY_NCOLUMNS; i++) for (int i = 0; i < BUTTONARRAY_NCOLUMNS; i++)
{ {
printf(MAIN_STRING "Label (%d,%d): %s\n", i, j, *ptr); printf("cbuttonarray_main: Label (%d,%d): %s\n", i, j, *ptr);
CNxString string = *ptr++; CNxString string = *ptr++;
buttonArray->setText(i, j, string); buttonArray->setText(i, j, string);
} }
@ -257,7 +257,7 @@ int MAIN_NAME(int argc, char *argv[])
// Show the button array // Show the button array
printf(MAIN_STRING "Show the button array\n"); printf("cbuttonarray_main: Show the button array\n");
test->showButton(buttonArray); test->showButton(buttonArray);
sleep(1); sleep(1);
@ -272,7 +272,7 @@ int MAIN_NAME(int argc, char *argv[])
{ {
for (int i = 0; i < BUTTONARRAY_NCOLUMNS; i++) for (int i = 0; i < BUTTONARRAY_NCOLUMNS; i++)
{ {
printf(MAIN_STRING "Click the button (%d,%d)\n", i, j); printf("cbuttonarray_main: Click the button (%d,%d)\n", i, j);
test->click(buttonArray, i, j); test->click(buttonArray, i, j);
// Poll for the mouse click event // Poll for the mouse click event
@ -285,13 +285,13 @@ int MAIN_NAME(int argc, char *argv[])
int clickRow; int clickRow;
if (buttonArray->isButtonClicked(clickColumn, clickRow)) if (buttonArray->isButtonClicked(clickColumn, clickRow))
{ {
printf(MAIN_STRING "%s: Button (%d, %d) is clicked\n", printf("cbuttonarray_main: %s: Button (%d, %d) is clicked\n",
clickColumn == i && clickRow == j ? "OK" : "ERROR", clickColumn == i && clickRow == j ? "OK" : "ERROR",
clickColumn, clickRow); clickColumn, clickRow);
} }
else else
{ {
printf(MAIN_STRING "ERROR: No button is clicked\n"); printf("cbuttonarray_main: ERROR: No button is clicked\n");
} }
// Wait a bit, then release the mouse button // Wait a bit, then release the mouse button
@ -304,7 +304,7 @@ int MAIN_NAME(int argc, char *argv[])
test->poll(buttonArray); test->poll(buttonArray);
if (buttonArray->isButtonClicked(clickColumn, clickRow)) if (buttonArray->isButtonClicked(clickColumn, clickRow))
{ {
printf(MAIN_STRING "ERROR: Button (%d, %d) is clicked\n", printf("cbuttonarray_main: ERROR: Button (%d, %d) is clicked\n",
clickColumn, clickRow); clickColumn, clickRow);
} }
@ -315,7 +315,7 @@ int MAIN_NAME(int argc, char *argv[])
// Clean up and exit // Clean up and exit
printf(MAIN_STRING "Clean-up and exit\n"); printf("cbuttonarray_main: Clean-up and exit\n");
delete buttonArray; delete buttonArray;
updateMemoryUsage(g_mmPrevious, "After deleting the button array"); updateMemoryUsage(g_mmPrevious, "After deleting the button array");
delete test; delete test;

10
UnitTests/CButtonArray/cbuttonarraytest.hxx
View File

@ -75,16 +75,6 @@
# define CONFIG_CBUTTONARRAYTEST_FONTCOLOR CONFIG_NXWIDGETS_DEFAULT_FONTCOLOR # define CONFIG_CBUTTONARRAYTEST_FONTCOLOR CONFIG_NXWIDGETS_DEFAULT_FONTCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME cbuttonarray_main
# define MAIN_STRING "cbuttonarray_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
// If debug is enabled, use the debug function, lib_rawprintf() instead // If debug is enabled, use the debug function, lib_rawprintf() instead
// of printf() so that the output is synchronized. // of printf() so that the output is synchronized.

2
UnitTests/CCheckBox/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx ccheckboxtest.cxx CXXSRCS = ccheckbox_main.cxx ccheckboxtest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

28
UnitTests/CCheckBox/main.cxx → UnitTests/CCheckBox/ccheckbox_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CCheckBox/main.cxx // NxWidgets/UnitTests/CCheckBox/ccheckbox_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -73,7 +73,7 @@ static unsigned int g_mmprevious;
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int ccheckbox_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Private Functions // Private Functions
@ -135,7 +135,7 @@ static void initMemoryUsage(void)
// Name: user_start/nxheaders_main // Name: user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int ccheckbox_main(int argc, char *argv[])
{ {
// Initialize memory monitor logic // Initialize memory monitor logic
@ -143,31 +143,31 @@ int MAIN_NAME(int argc, char *argv[])
// Create an instance of the checkbox test // Create an instance of the checkbox test
message(MAIN_STRING "Create CCheckBoxTest instance\n"); message("ccheckbox_main: Create CCheckBoxTest instance\n");
CCheckBoxTest *test = new CCheckBoxTest(); CCheckBoxTest *test = new CCheckBoxTest();
updateMemoryUsage(g_mmprevious, "After creating CCheckBoxTest"); updateMemoryUsage(g_mmprevious, "After creating CCheckBoxTest");
// Connect the NX server // Connect the NX server
message(MAIN_STRING "Connect the CCheckBoxTest instance to the NX server\n"); message("ccheckbox_main: Connect the CCheckBoxTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
message(MAIN_STRING "Failed to connect the CCheckBoxTest instance to the NX server\n"); message("ccheckbox_main: Failed to connect the CCheckBoxTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After connecting to the server"); updateMemoryUsage(g_mmprevious, "ccheckbox_main: After connecting to the server");
// Create a window to draw into // Create a window to draw into
message(MAIN_STRING "Create a Window\n"); message("ccheckbox_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
message(MAIN_STRING "Failed to create a window\n"); message("ccheckbox_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After creating a window"); updateMemoryUsage(g_mmprevious, "ccheckbox_main: After creating a window");
// Show the initial state of the checkbox // Show the initial state of the checkbox
@ -177,21 +177,21 @@ int MAIN_NAME(int argc, char *argv[])
// Now click the checkbox // Now click the checkbox
message(MAIN_STRING "Click 1\n"); message("ccheckbox_main: Click 1\n");
test->clickCheckBox(); test->clickCheckBox();
usleep(500*1000); usleep(500*1000);
test->showCheckBoxState(); test->showCheckBoxState();
updateMemoryUsage(g_mmprevious, "After click 1"); updateMemoryUsage(g_mmprevious, "After click 1");
usleep(500*1000); usleep(500*1000);
message(MAIN_STRING "Click 2\n"); message("ccheckbox_main: Click 2\n");
test->clickCheckBox(); test->clickCheckBox();
usleep(500*1000); usleep(500*1000);
test->showCheckBoxState(); test->showCheckBoxState();
updateMemoryUsage(g_mmprevious, "After click 2"); updateMemoryUsage(g_mmprevious, "After click 2");
usleep(500*1000); usleep(500*1000);
message(MAIN_STRING "Click 3\n"); message("ccheckbox_main: Click 3\n");
test->clickCheckBox(); test->clickCheckBox();
usleep(500*1000); usleep(500*1000);
test->showCheckBoxState(); test->showCheckBoxState();
@ -200,7 +200,7 @@ int MAIN_NAME(int argc, char *argv[])
// Clean up and exit // Clean up and exit
message(MAIN_STRING "Clean-up and exit\n"); message("ccheckbox_main: Clean-up and exit\n");
delete test; delete test;
updateMemoryUsage(g_mmprevious, "After deleting the test"); updateMemoryUsage(g_mmprevious, "After deleting the test");
updateMemoryUsage(g_mmInitial, "Final memory usage"); updateMemoryUsage(g_mmInitial, "Final memory usage");

10
UnitTests/CCheckBox/ccheckboxtest.hxx
View File

@ -69,16 +69,6 @@
# define CONFIG_CCHECKBOXTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR # define CONFIG_CCHECKBOXTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME ccheckbox_main
# define MAIN_STRING "ccheckbox_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
// If debug is enabled, use the debug function, lib_rawprintf() instead // If debug is enabled, use the debug function, lib_rawprintf() instead
// of printf() so that the output is synchronized. // of printf() so that the output is synchronized.

2
UnitTests/CGlyphButton/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx cglyphbuttontest.cxx CXXSRCS = cglyphbutton_main.cxx cglyphbuttontest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

28
UnitTests/CGlyphButton/main.cxx → UnitTests/CGlyphButton/cglyphbutton_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CGlyphButton/main.cxx // NxWidgets/UnitTests/CGlyphButton/cglyphbutton_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -72,7 +72,7 @@ static unsigned int g_mmprevious;
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int cglyphbutton_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Private Functions // Private Functions
@ -134,7 +134,7 @@ static void initMemoryUsage(void)
// user_start/nxheaders_main // user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int cglyphbutton_main(int argc, char *argv[])
{ {
// Initialize memory monitor logic // Initialize memory monitor logic
@ -142,16 +142,16 @@ int MAIN_NAME(int argc, char *argv[])
// Create an instance of the font test // Create an instance of the font test
message(MAIN_STRING "Create CGlyphButtonTest instance\n"); message("cglyphbutton_main: Create CGlyphButtonTest instance\n");
CGlyphButtonTest *test = new CGlyphButtonTest(); CGlyphButtonTest *test = new CGlyphButtonTest();
updateMemoryUsage(g_mmprevious, "After creating CGlyphButtonTest"); updateMemoryUsage(g_mmprevious, "After creating CGlyphButtonTest");
// Connect the NX server // Connect the NX server
message(MAIN_STRING "Connect the CGlyphButtonTest instance to the NX server\n"); message("cglyphbutton_main: Connect the CGlyphButtonTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
message(MAIN_STRING "Failed to connect the CGlyphButtonTest instance to the NX server\n"); message("cglyphbutton_main: Failed to connect the CGlyphButtonTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
@ -159,10 +159,10 @@ int MAIN_NAME(int argc, char *argv[])
// Create a window to draw into // Create a window to draw into
message(MAIN_STRING "Create a Window\n"); message("cglyphbutton_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
message(MAIN_STRING "Failed to create a window\n"); message("cglyphbutton_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
@ -173,7 +173,7 @@ int MAIN_NAME(int argc, char *argv[])
CGlyphButton *button = test->createButton(&g_arrowDown, &g_arrowUp); CGlyphButton *button = test->createButton(&g_arrowDown, &g_arrowUp);
if (!button) if (!button)
{ {
message(MAIN_STRING "Failed to create a button\n"); message("cglyphbutton_main: Failed to create a button\n");
delete test; delete test;
return 1; return 1;
} }
@ -181,21 +181,21 @@ int MAIN_NAME(int argc, char *argv[])
// Show the button // Show the button
message(MAIN_STRING "Show the button\n"); message("cglyphbutton_main: Show the button\n");
test->showButton(button); test->showButton(button);
updateMemoryUsage(g_mmprevious, "After showing the glyph button"); updateMemoryUsage(g_mmprevious, "After showing the glyph button");
// Wait two seconds, then perform a simulated mouse click on the button // Wait two seconds, then perform a simulated mouse click on the button
sleep(2); sleep(2);
message(MAIN_STRING "Click the button\n"); message("cglyphbutton_main: Click the button\n");
test->click(); test->click();
updateMemoryUsage(g_mmprevious, "After clicking glyph button"); updateMemoryUsage(g_mmprevious, "After clicking glyph button");
// Poll for the mouse click event (of course this can hang if something fails) // Poll for the mouse click event (of course this can hang if something fails)
bool clicked = test->poll(button); bool clicked = test->poll(button);
message(MAIN_STRING "Button is %s\n", clicked ? "clicked" : "released"); message("cglyphbutton_main: Button is %s\n", clicked ? "clicked" : "released");
// Wait a second, then release the mouse buttone // Wait a second, then release the mouse buttone
@ -206,7 +206,7 @@ int MAIN_NAME(int argc, char *argv[])
// Poll for the mouse release event (of course this can hang if something fails) // Poll for the mouse release event (of course this can hang if something fails)
clicked = test->poll(button); clicked = test->poll(button);
message(MAIN_STRING "Button is %s\n", clicked ? "clicked" : "released"); message("cglyphbutton_main: Button is %s\n", clicked ? "clicked" : "released");
// Wait a few more seconds so that the tester can ponder the result // Wait a few more seconds so that the tester can ponder the result
@ -214,7 +214,7 @@ int MAIN_NAME(int argc, char *argv[])
// Clean up and exit // Clean up and exit
message(MAIN_STRING "Clean-up and exit\n"); message("cglyphbutton_main: Clean-up and exit\n");
delete button; delete button;
updateMemoryUsage(g_mmprevious, "After deleting the glyph button"); updateMemoryUsage(g_mmprevious, "After deleting the glyph button");
delete test; delete test;

10
UnitTests/CGlyphButton/cglyphbuttontest.hxx
View File

@ -76,16 +76,6 @@
# define CONFIG_CGLYPHBUTTONTEST_FONTCOLOR CONFIG_NXWIDGETS_DEFAULT_FONTCOLOR # define CONFIG_CGLYPHBUTTONTEST_FONTCOLOR CONFIG_NXWIDGETS_DEFAULT_FONTCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME cglyphbutton_main
# define MAIN_STRING "cglyphbutton_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
// If debug is enabled, use the debug function, lib_rawprintf() instead // If debug is enabled, use the debug function, lib_rawprintf() instead
// of printf() so that the output is synchronized. // of printf() so that the output is synchronized.

2
UnitTests/CImage/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx cimagetest.cxx CXXSRCS = cimage_main.cxx cimagetest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

20
UnitTests/CImage/main.cxx → UnitTests/CImage/cimage_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CImage/main.cxx // NxWidgets/UnitTests/CImage/cimage_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -73,7 +73,7 @@ static struct mallinfo g_mmprevious;
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int cimage_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Private Functions // Private Functions
@ -149,7 +149,7 @@ static void initMemoryUsage(void)
// Name: user_start/nxheaders_main // Name: user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int cimage_main(int argc, char *argv[])
{ {
// Initialize memory monitor logic // Initialize memory monitor logic
@ -157,16 +157,16 @@ int MAIN_NAME(int argc, char *argv[])
// Create an instance of the font test // Create an instance of the font test
message(MAIN_STRING "Create CImageTest instance\n"); message("cimage_main: Create CImageTest instance\n");
CImageTest *test = new CImageTest(); CImageTest *test = new CImageTest();
updateMemoryUsage(&g_mmprevious, "After creating CImageTest"); updateMemoryUsage(&g_mmprevious, "After creating CImageTest");
// Connect the NX server // Connect the NX server
message(MAIN_STRING "Connect the CImageTest instance to the NX server\n"); message("cimage_main: Connect the CImageTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
message(MAIN_STRING "Failed to connect the CImageTest instance to the NX server\n"); message("cimage_main: Failed to connect the CImageTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
@ -174,10 +174,10 @@ int MAIN_NAME(int argc, char *argv[])
// Create a window to draw into // Create a window to draw into
message(MAIN_STRING "Create a Window\n"); message("cimage_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
message(MAIN_STRING "Failed to create a window\n"); message("cimage_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
@ -193,7 +193,7 @@ int MAIN_NAME(int argc, char *argv[])
CImage *image = test->createImage(static_cast<IBitmap*>(nuttxBitmap)); CImage *image = test->createImage(static_cast<IBitmap*>(nuttxBitmap));
if (!image) if (!image)
{ {
message(MAIN_STRING "Failed to create a image\n"); message("cimage_main: Failed to create a image\n");
delete test; delete test;
return 1; return 1;
} }
@ -207,7 +207,7 @@ int MAIN_NAME(int argc, char *argv[])
// Clean up and exit // Clean up and exit
message(MAIN_STRING "Clean-up and exit\n"); message("cimage_main: Clean-up and exit\n");
delete image; delete image;
updateMemoryUsage(&g_mmprevious, "After deleting CImage"); updateMemoryUsage(&g_mmprevious, "After deleting CImage");

10
UnitTests/CImage/cimagetest.hxx
View File

@ -71,16 +71,6 @@
# define CONFIG_CIMAGETEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR # define CONFIG_CIMAGETEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME cimage_main
# define MAIN_STRING "cimage_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
// If debug is enabled, use the debug function, lib_rawprintf() instead // If debug is enabled, use the debug function, lib_rawprintf() instead
// of printf() so that the output is synchronized. // of printf() so that the output is synchronized.

2
UnitTests/CKeypad/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx ckeypadtest.cxx CXXSRCS = ckeypad_main.cxx ckeypadtest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

32
UnitTests/CKeypad/main.cxx → UnitTests/CKeypad/ckeypad_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CKeypad/main.cxx // NxWidgets/UnitTests/CKeypad/ckeypad_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -72,7 +72,7 @@ static unsigned int g_mmPeak;
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int ckeypad_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Private Functions // Private Functions
@ -142,7 +142,7 @@ static void clickButtons(CKeypadTest *test, CKeypad *keypad)
{ {
for (int i = 0; i < KEYPAD_NCOLUMNS; i++) for (int i = 0; i < KEYPAD_NCOLUMNS; i++)
{ {
printf(MAIN_STRING "Click the button (%d,%d)\n", i, j); printf("clickButtons: Click the button (%d,%d)\n", i, j);
test->click(keypad, i, j); test->click(keypad, i, j);
// Poll for the mouse click event // Poll for the mouse click event
@ -155,13 +155,13 @@ static void clickButtons(CKeypadTest *test, CKeypad *keypad)
int clickRow; int clickRow;
if (keypad->isButtonClicked(clickColumn, clickRow)) if (keypad->isButtonClicked(clickColumn, clickRow))
{ {
printf(MAIN_STRING "%s: Button (%d, %d) is clicked\n", printf("clickButtons: %s: Button (%d, %d) is clicked\n",
clickColumn == i && clickRow == j ? "OK" : "ERROR", clickColumn == i && clickRow == j ? "OK" : "ERROR",
clickColumn, clickRow); clickColumn, clickRow);
} }
else else
{ {
printf(MAIN_STRING "ERROR: No button is clicked\n"); printf("clickButtons: ERROR: No button is clicked\n");
} }
// Wait a bit, then release the mouse button // Wait a bit, then release the mouse button
@ -174,7 +174,7 @@ static void clickButtons(CKeypadTest *test, CKeypad *keypad)
test->poll(keypad); test->poll(keypad);
if (keypad->isButtonClicked(clickColumn, clickRow)) if (keypad->isButtonClicked(clickColumn, clickRow))
{ {
printf(MAIN_STRING "ERROR: Button (%d, %d) is clicked\n", printf("clickButtons: ERROR: Button (%d, %d) is clicked\n",
clickColumn, clickRow); clickColumn, clickRow);
} }
@ -192,7 +192,7 @@ static void clickButtons(CKeypadTest *test, CKeypad *keypad)
// user_start/nxheaders_main // user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int ckeypad_main(int argc, char *argv[])
{ {
// Initialize memory monitor logic // Initialize memory monitor logic
@ -200,16 +200,16 @@ int MAIN_NAME(int argc, char *argv[])
// Create an instance of the keypad test // Create an instance of the keypad test
printf(MAIN_STRING "Create CKeypadTest instance\n"); printf("ckeypad_main: Create CKeypadTest instance\n");
CKeypadTest *test = new CKeypadTest(); CKeypadTest *test = new CKeypadTest();
updateMemoryUsage(g_mmPrevious, "After creating CKeypadTest"); updateMemoryUsage(g_mmPrevious, "After creating CKeypadTest");
// Connect the NX server // Connect the NX server
printf(MAIN_STRING "Connect the CKeypadTest instance to the NX server\n"); printf("ckeypad_main: Connect the CKeypadTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
printf(MAIN_STRING "Failed to connect the CKeypadTest instance to the NX server\n"); printf("ckeypad_main: Failed to connect the CKeypadTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
@ -217,10 +217,10 @@ int MAIN_NAME(int argc, char *argv[])
// Create a window to draw into // Create a window to draw into
printf(MAIN_STRING "Create a Window\n"); printf("ckeypad_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
printf(MAIN_STRING "Failed to create a window\n"); printf("ckeypad_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
@ -231,7 +231,7 @@ int MAIN_NAME(int argc, char *argv[])
CKeypad *keypad = test->createKeypad(); CKeypad *keypad = test->createKeypad();
if (!keypad) if (!keypad)
{ {
printf(MAIN_STRING "Failed to create a keypad\n"); printf("ckeypad_main: Failed to create a keypad\n");
delete test; delete test;
return 1; return 1;
} }
@ -239,7 +239,7 @@ int MAIN_NAME(int argc, char *argv[])
// Show the keypad in alphabetic mode // Show the keypad in alphabetic mode
printf(MAIN_STRING "Show the keypad in alphabetic mode\n"); printf("ckeypad_main: Show the keypad in alphabetic mode\n");
keypad->setKeypadMode(false); keypad->setKeypadMode(false);
test->showKeypad(keypad); test->showKeypad(keypad);
sleep(1); sleep(1);
@ -251,7 +251,7 @@ int MAIN_NAME(int argc, char *argv[])
// Show the keypad in numeric mode // Show the keypad in numeric mode
printf(MAIN_STRING "Show the keypad in numeric mode\n"); printf("ckeypad_main: Show the keypad in numeric mode\n");
keypad->setKeypadMode(true); keypad->setKeypadMode(true);
sleep(1); sleep(1);
@ -262,7 +262,7 @@ int MAIN_NAME(int argc, char *argv[])
// Clean up and exit // Clean up and exit
printf(MAIN_STRING "Clean-up and exit\n"); printf("ckeypad_main: Clean-up and exit\n");
delete keypad; delete keypad;
updateMemoryUsage(g_mmPrevious, "After deleting the keypad"); updateMemoryUsage(g_mmPrevious, "After deleting the keypad");
delete test; delete test;

10
UnitTests/CKeypad/ckeypadtest.hxx
View File

@ -72,16 +72,6 @@
# define CONFIG_CKEYPADTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR # define CONFIG_CKEYPADTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME ckeypad_main
# define MAIN_STRING "ckeypad_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
// If debug is enabled, use the debug function, lib_rawprintf() instead // If debug is enabled, use the debug function, lib_rawprintf() instead
// of printf() so that the output is synchronized. // of printf() so that the output is synchronized.

2
UnitTests/CLabel/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx clabeltest.cxx CXXSRCS = clabel_main.cxx clabeltest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

20
UnitTests/CLabel/main.cxx → UnitTests/CLabel/clabel_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CLabel/main.cxx // NxWidgets/UnitTests/CLabel/clabel_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -68,7 +68,7 @@ static const char g_hello[] = "Hello, World!";
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int clabel_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Public Functions // Public Functions
@ -78,29 +78,29 @@ extern "C" int MAIN_NAME(int argc, char *argv[]);
// user_start/nxheaders_main // user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int clabel_main(int argc, char *argv[])
{ {
// Create an instance of the font test // Create an instance of the font test
printf(MAIN_STRING "Create CLabelTest instance\n"); printf("clabel_main: Create CLabelTest instance\n");
CLabelTest *test = new CLabelTest(); CLabelTest *test = new CLabelTest();
// Connect the NX server // Connect the NX server
printf(MAIN_STRING "Connect the CLabelTest instance to the NX server\n"); printf("clabel_main: Connect the CLabelTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
printf(MAIN_STRING "Failed to connect the CLabelTest instance to the NX server\n"); printf("clabel_main: Failed to connect the CLabelTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
// Create a window to draw into // Create a window to draw into
printf(MAIN_STRING "Create a Window\n"); printf("clabel_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
printf(MAIN_STRING "Failed to create a window\n"); printf("clabel_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
@ -110,7 +110,7 @@ int MAIN_NAME(int argc, char *argv[])
CLabel *label = test->createLabel(g_hello); CLabel *label = test->createLabel(g_hello);
if (!label) if (!label)
{ {
printf(MAIN_STRING "Failed to create a label\n"); printf("clabel_main: Failed to create a label\n");
delete test; delete test;
return 1; return 1;
} }
@ -122,7 +122,7 @@ int MAIN_NAME(int argc, char *argv[])
// Clean up and exit // Clean up and exit
printf(MAIN_STRING "Clean-up and exit\n"); printf("clabel_main: Clean-up and exit\n");
delete label; delete label;
delete test; delete test;
return 0; return 0;

10
UnitTests/CLabel/clabeltest.hxx
View File

@ -75,16 +75,6 @@
# define CONFIG_CLABELTEST_FONTCOLOR CONFIG_NXWIDGETS_DEFAULT_FONTCOLOR # define CONFIG_CLABELTEST_FONTCOLOR CONFIG_NXWIDGETS_DEFAULT_FONTCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME clabel_main
# define MAIN_STRING "clabel_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Public Classes // Public Classes
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////

2
UnitTests/CLatchButton/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx clatchbuttontest.cxx CXXSRCS = clatchbutton_main.cxx clatchbuttontest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

30
UnitTests/CLatchButton/main.cxx → UnitTests/CLatchButton/clatchbutton_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CLatchButton/main.cxx // NxWidgets/UnitTests/CLatchButton/clatchbutton_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -68,7 +68,7 @@ static const char g_pushme[] = "Push Me";
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int clatchbutton_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Private Functions // Private Functions
@ -83,13 +83,13 @@ static void showButtonState(CLatchButton *button, bool &clicked, bool &latched)
bool nowClicked = button->isClicked(); bool nowClicked = button->isClicked();
bool nowLatched = button->isLatched(); bool nowLatched = button->isLatched();
printf(MAIN_STRING "Button state: %s and %s\n", printf("showButtonState: Button state: %s and %s\n",
nowClicked ? "clicked" : "released", nowClicked ? "clicked" : "released",
nowLatched ? "latched" : "unlatched"); nowLatched ? "latched" : "unlatched");
if (clicked != nowClicked || latched != nowLatched) if (clicked != nowClicked || latched != nowLatched)
{ {
printf(MAIN_STRING "ERROR: Expected %s and %s\n", printf("showButtonState: ERROR: Expected %s and %s\n",
clicked ? "clicked" : "released", clicked ? "clicked" : "released",
latched ? "latched" : "unlatched"); latched ? "latched" : "unlatched");
@ -106,29 +106,29 @@ static void showButtonState(CLatchButton *button, bool &clicked, bool &latched)
// user_start/nxheaders_main // user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int clatchbutton_main(int argc, char *argv[])
{ {
// Create an instance of the font test // Create an instance of the font test
printf(MAIN_STRING "Create CLatchButtonTest instance\n"); printf("clatchbutton_main: Create CLatchButtonTest instance\n");
CLatchButtonTest *test = new CLatchButtonTest(); CLatchButtonTest *test = new CLatchButtonTest();
// Connect the NX server // Connect the NX server
printf(MAIN_STRING "Connect the CLatchButtonTest instance to the NX server\n"); printf("clatchbutton_main: Connect the CLatchButtonTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
printf(MAIN_STRING "Failed to connect the CLatchButtonTest instance to the NX server\n"); printf("clatchbutton_main: Failed to connect the CLatchButtonTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
// Create a window to draw into // Create a window to draw into
printf(MAIN_STRING "Create a Window\n"); printf("clatchbutton_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
printf(MAIN_STRING "Failed to create a window\n"); printf("clatchbutton_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
@ -138,14 +138,14 @@ int MAIN_NAME(int argc, char *argv[])
CLatchButton *button = test->createButton(g_pushme); CLatchButton *button = test->createButton(g_pushme);
if (!button) if (!button)
{ {
printf(MAIN_STRING "Failed to create a button\n"); printf("clatchbutton_main: Failed to create a button\n");
delete test; delete test;
return 1; return 1;
} }
// Show the button // Show the button
printf(MAIN_STRING "Show the button\n"); printf("clatchbutton_main: Show the button\n");
test->showButton(button); test->showButton(button);
bool clicked = false; bool clicked = false;
@ -159,7 +159,7 @@ int MAIN_NAME(int argc, char *argv[])
// Wait two seconds, then perform a simulated mouse click on the button // Wait two seconds, then perform a simulated mouse click on the button
sleep(2); sleep(2);
printf(MAIN_STRING "Click the button\n"); printf("clatchbutton_main: Click the button\n");
test->click(); test->click();
test->poll(button); test->poll(button);
@ -173,7 +173,7 @@ int MAIN_NAME(int argc, char *argv[])
// And release the button after 0.5 seconds // And release the button after 0.5 seconds
usleep(500 * 1000); usleep(500 * 1000);
printf(MAIN_STRING "Release the button\n"); printf("clatchbutton_main: Release the button\n");
test->release(); test->release();
test->poll(button); test->poll(button);
@ -191,7 +191,7 @@ int MAIN_NAME(int argc, char *argv[])
// Clean up and exit // Clean up and exit
printf(MAIN_STRING "Clean-up and exit\n"); printf("clatchbutton_main: Clean-up and exit\n");
delete button; delete button;
delete test; delete test;
return 0; return 0;

10
UnitTests/CLatchButton/clatchbuttontest.hxx
View File

@ -75,16 +75,6 @@
# define CONFIG_CLATCHBUTTONTEST_FONTCOLOR CONFIG_NXWIDGETS_DEFAULT_FONTCOLOR # define CONFIG_CLATCHBUTTONTEST_FONTCOLOR CONFIG_NXWIDGETS_DEFAULT_FONTCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME clatchbutton_main
# define MAIN_STRING "clatchbutton_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Public Classes // Public Classes
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////

2
UnitTests/CLatchButtonArray/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx clatchbuttonarraytest.cxx CXXSRCS = clatchbuttonarray_main.cxx clatchbuttonarraytest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

30
UnitTests/CLatchButtonArray/main.cxx → UnitTests/CLatchButtonArray/clatchbuttonarray_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CLatchButtonArray/main.cxx // NxWidgets/UnitTests/CLatchButtonArray/clatchbuttonarry_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -82,7 +82,7 @@ static FAR const char *g_buttonLabels[BUTTONARRAY_NCOLUMNS*BUTTONARRAY_NROWS] =
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int clatchbuttonarray_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Private Functions // Private Functions
@ -98,14 +98,14 @@ static void showButtonState(CLatchButtonArray *buttonArray, int i, int j,
bool nowClicked = buttonArray->isThisButtonClicked(i,j); bool nowClicked = buttonArray->isThisButtonClicked(i,j);
bool nowLatched = buttonArray->isThisButtonLatched(i,j); bool nowLatched = buttonArray->isThisButtonLatched(i,j);
printf(MAIN_STRING "Button(%d,%d) state: %s and %s\n", printf("showButtonState: Button(%d,%d) state: %s and %s\n",
i, j, i, j,
nowClicked ? "clicked" : "released", nowClicked ? "clicked" : "released",
nowLatched ? "latched" : "unlatched"); nowLatched ? "latched" : "unlatched");
if (clicked != nowClicked || latched != nowLatched) if (clicked != nowClicked || latched != nowLatched)
{ {
printf(MAIN_STRING "ERROR: Expected %s and %s\n", printf("showButtonState: ERROR: Expected %s and %s\n",
clicked ? "clicked" : "released", clicked ? "clicked" : "released",
latched ? "latched" : "unlatched"); latched ? "latched" : "unlatched");
@ -174,7 +174,7 @@ static void initMemoryUsage(void)
// user_start/nxheaders_main // user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int clatchbuttonarray_main(int argc, char *argv[])
{ {
// Initialize memory monitor logic // Initialize memory monitor logic
@ -182,16 +182,16 @@ int MAIN_NAME(int argc, char *argv[])
// Create an instance of the button array test // Create an instance of the button array test
printf(MAIN_STRING "Create CLatchButtonArrayTest instance\n"); printf("clatchbuttonarray_main: Create CLatchButtonArrayTest instance\n");
CLatchButtonArrayTest *test = new CLatchButtonArrayTest(); CLatchButtonArrayTest *test = new CLatchButtonArrayTest();
updateMemoryUsage(g_mmPrevious, "After creating CLatchButtonArrayTest"); updateMemoryUsage(g_mmPrevious, "After creating CLatchButtonArrayTest");
// Connect the NX server // Connect the NX server
printf(MAIN_STRING "Connect the CLatchButtonArrayTest instance to the NX server\n"); printf("clatchbuttonarray_main: Connect the CLatchButtonArrayTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
printf(MAIN_STRING "Failed to connect the CLatchButtonArrayTest instance to the NX server\n"); printf("clatchbuttonarray_main: Failed to connect the CLatchButtonArrayTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
@ -199,10 +199,10 @@ int MAIN_NAME(int argc, char *argv[])
// Create a window to draw into // Create a window to draw into
printf(MAIN_STRING "Create a Window\n"); printf("clatchbuttonarray_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
printf(MAIN_STRING "Failed to create a window\n"); printf("clatchbuttonarray_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
@ -213,7 +213,7 @@ int MAIN_NAME(int argc, char *argv[])
CLatchButtonArray *buttonArray = test->createButtonArray(); CLatchButtonArray *buttonArray = test->createButtonArray();
if (!buttonArray) if (!buttonArray)
{ {
printf(MAIN_STRING "Failed to create a button array\n"); printf("clatchbuttonarray_main: Failed to create a button array\n");
delete test; delete test;
return 1; return 1;
} }
@ -226,7 +226,7 @@ int MAIN_NAME(int argc, char *argv[])
{ {
for (int i = 0; i < BUTTONARRAY_NCOLUMNS; i++) for (int i = 0; i < BUTTONARRAY_NCOLUMNS; i++)
{ {
printf(MAIN_STRING "Label (%d,%d): %s\n", i, j, *ptr); printf("clatchbuttonarray_main: Label (%d,%d): %s\n", i, j, *ptr);
CNxString string = *ptr++; CNxString string = *ptr++;
buttonArray->setText(i, j, string); buttonArray->setText(i, j, string);
} }
@ -235,7 +235,7 @@ int MAIN_NAME(int argc, char *argv[])
// Show the button array // Show the button array
printf(MAIN_STRING "Show the button array\n"); printf("clatchbuttonarray_main: Show the button array\n");
test->showButton(buttonArray); test->showButton(buttonArray);
sleep(1); sleep(1);
@ -254,7 +254,7 @@ int MAIN_NAME(int argc, char *argv[])
latched = false; latched = false;
showButtonState(buttonArray, i, j, clicked, latched); showButtonState(buttonArray, i, j, clicked, latched);
printf(MAIN_STRING "Click the button (%d,%d)\n", i, j); printf("clatchbuttonarray_main: Click the button (%d,%d)\n", i, j);
test->click(buttonArray, i, j); test->click(buttonArray, i, j);
// Poll for the mouse click event // Poll for the mouse click event
@ -289,7 +289,7 @@ int MAIN_NAME(int argc, char *argv[])
// Clean up and exit // Clean up and exit
printf(MAIN_STRING "Clean-up and exit\n"); printf("clatchbuttonarray_main: Clean-up and exit\n");
delete buttonArray; delete buttonArray;
updateMemoryUsage(g_mmPrevious, "After deleting the button array"); updateMemoryUsage(g_mmPrevious, "After deleting the button array");
delete test; delete test;

10
UnitTests/CLatchButtonArray/clatchbuttonarraytest.hxx
View File

@ -75,16 +75,6 @@
# define CONFIG_CLATCHBUTTONARRAYTEST_FONTCOLOR CONFIG_NXWIDGETS_DEFAULT_FONTCOLOR # define CONFIG_CLATCHBUTTONARRAYTEST_FONTCOLOR CONFIG_NXWIDGETS_DEFAULT_FONTCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME clatchbuttonarray_main
# define MAIN_STRING "clatchbuttonarray_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
// If debug is enabled, use the debug function, lib_rawprintf() instead // If debug is enabled, use the debug function, lib_rawprintf() instead
// of printf() so that the output is synchronized. // of printf() so that the output is synchronized.

2
UnitTests/CListBox/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx clistboxtest.cxx CXXSRCS = clistbox_main.cxx clistboxtest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

70
UnitTests/CListBox/main.cxx → UnitTests/CListBox/clistbox_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CListBox/main.cxx // NxWidgets/UnitTests/CListBox/clistbox_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -108,7 +108,7 @@ static FAR const char *g_options[] =
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int clistbox_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Private Functions // Private Functions
@ -174,7 +174,7 @@ static void initMemoryUsage(void)
// Name: user_start/nxheaders_main // Name: user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int clistbox_main(int argc, char *argv[])
{ {
// Initialize memory monitor logic // Initialize memory monitor logic
@ -182,43 +182,43 @@ int MAIN_NAME(int argc, char *argv[])
// Create an instance of the listbox test // Create an instance of the listbox test
message(MAIN_STRING "Create CListBoxTest instance\n"); message("clistbox_main: Create CListBoxTest instance\n");
CListBoxTest *test = new CListBoxTest(); CListBoxTest *test = new CListBoxTest();
updateMemoryUsage(g_mmPrevious, "After creating CListBoxTest"); updateMemoryUsage(g_mmPrevious, "After creating CListBoxTest");
// Connect the NX server // Connect the NX server
message(MAIN_STRING "Connect the CListBoxTest instance to the NX server\n"); message("clistbox_main: Connect the CListBoxTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
message(MAIN_STRING "Failed to connect the CListBoxTest instance to the NX server\n"); message("clistbox_main: Failed to connect the CListBoxTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmPrevious, MAIN_STRING "After connecting to the server"); updateMemoryUsage(g_mmPrevious, "clistbox_main: After connecting to the server");
// Create a window to draw into // Create a window to draw into
message(MAIN_STRING "Create a Window\n"); message("clistbox_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
message(MAIN_STRING "Failed to create a window\n"); message("clistbox_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmPrevious, MAIN_STRING "After creating a window"); updateMemoryUsage(g_mmPrevious, "clistbox_main: After creating a window");
// Create a listbox // Create a listbox
message(MAIN_STRING "Create a ListBox\n"); message("clistbox_main: Create a ListBox\n");
CListBox *listbox = test->createListBox(); CListBox *listbox = test->createListBox();
if (!listbox) if (!listbox)
{ {
message(MAIN_STRING "Failed to create a listbox\n"); message("clistbox_main: Failed to create a listbox\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmPrevious, MAIN_STRING "After creating a listbox"); updateMemoryUsage(g_mmPrevious, "clistbox_main: After creating a listbox");
// Show the initial state of the listbox // Show the initial state of the listbox
@ -228,23 +228,23 @@ int MAIN_NAME(int argc, char *argv[])
// Now add items to the list box (in reverse alphabetical order) // Now add items to the list box (in reverse alphabetical order)
message(MAIN_STRING "Add options to the ListBox\n"); message("clistbox_main: Add options to the ListBox\n");
for (int i = NOPTIONS - 1; i >= 0; i--) for (int i = NOPTIONS - 1; i >= 0; i--)
{ {
listbox->addOption(g_options[i],i); listbox->addOption(g_options[i],i);
test->showListBox(listbox); test->showListBox(listbox);
message(MAIN_STRING "%d. New option %s\n", i, g_options[i]); message("clistbox_main: %d. New option %s\n", i, g_options[i]);
usleep(500000); // The simulation needs this to let the X11 event loop run usleep(500000); // The simulation needs this to let the X11 event loop run
} }
updateMemoryUsage(g_mmPrevious, MAIN_STRING "After adding the listbox items"); updateMemoryUsage(g_mmPrevious, "clistbox_main: After adding the listbox items");
sleep(1); sleep(1);
// Sort the list box // Sort the list box
message(MAIN_STRING "Sort the ListBox\n"); message("clistbox_main: Sort the ListBox\n");
listbox->sort(); listbox->sort();
test->showListBox(listbox); test->showListBox(listbox);
updateMemoryUsage(g_mmPrevious, MAIN_STRING "After sorting the listbox"); updateMemoryUsage(g_mmPrevious, "clistbox_main: After sorting the listbox");
sleep(1); sleep(1);
// Select and remove items from the listbox // Select and remove items from the listbox
@ -253,69 +253,69 @@ int MAIN_NAME(int argc, char *argv[])
int nOptions; int nOptions;
while ((nOptions = listbox->getOptionCount()) > 0) while ((nOptions = listbox->getOptionCount()) > 0)
{ {
message(MAIN_STRING "Option count: %d\n", nOptions); message("clistbox_main: Option count: %d\n", nOptions);
if (nOptions <= 5) if (nOptions <= 5)
{ {
message(MAIN_STRING "Selecting all remaining options\n"); message("clistbox_main: Selecting all remaining options\n");
listbox->selectAllOptions(); listbox->selectAllOptions();
test->showListBox(listbox); test->showListBox(listbox);
updateMemoryUsage(g_mmPrevious, MAIN_STRING "After selecting all options"); updateMemoryUsage(g_mmPrevious, "clistbox_main: After selecting all options");
sleep(1); sleep(1);
message(MAIN_STRING "Removing all remaining options\n"); message("clistbox_main: Removing all remaining options\n");
listbox->removeAllOptions(); listbox->removeAllOptions();
updateMemoryUsage(g_mmPrevious, MAIN_STRING "After removing all options"); updateMemoryUsage(g_mmPrevious, "clistbox_main: After removing all options");
test->showListBox(listbox); test->showListBox(listbox);
} }
else else
{ {
int selected[5]; int selected[5];
message(MAIN_STRING "Selecting five options\n"); message("clistbox_main: Selecting five options\n");
for (int i = 0; i < 5; i++) for (int i = 0; i < 5; i++)
{ {
selected[i] = ((nOptions - 1) * rand()) / MAX_RAND; selected[i] = ((nOptions - 1) * rand()) / MAX_RAND;
message(MAIN_STRING "Selecting option %d\n", selected[i]); message("clistbox_main: Selecting option %d\n", selected[i]);
listbox->removeOption(selected[i]); listbox->removeOption(selected[i]);
test->showListBox(listbox); test->showListBox(listbox);
usleep(500000); usleep(500000);
} }
updateMemoryUsage(g_mmPrevious, MAIN_STRING "After selecting five options"); updateMemoryUsage(g_mmPrevious, "clistbox_main: After selecting five options");
message(MAIN_STRING "De-selecting options\n"); message("clistbox_main: De-selecting options\n");
int index; int index;
int count = 0; int count = 0;
while ((index = listbox->getSelectedIndex()) >= 0) while ((index = listbox->getSelectedIndex()) >= 0)
{ {
message(MAIN_STRING "De-selecting option %d\n", index); message("clistbox_main: De-selecting option %d\n", index);
listbox->deselectOption(index); listbox->deselectOption(index);
test->showListBox(listbox); test->showListBox(listbox);
count++; count++;
usleep(500000); usleep(500000);
} }
message(MAIN_STRING "%s: %d options de-selected\n", message("clistbox_main: %s: %d options de-selected\n",
count == 5 ? "OK" : "ERROR", count); count == 5 ? "OK" : "ERROR", count);
updateMemoryUsage(g_mmPrevious, MAIN_STRING "After de-selecting options"); updateMemoryUsage(g_mmPrevious, "clistbox_main: After de-selecting options");
message(MAIN_STRING "Removing the selected options\n"); message("clistbox_main: Removing the selected options\n");
for (int i = 0; i < 5; i++) for (int i = 0; i < 5; i++)
{ {
message(MAIN_STRING "Removing option %d\n", selected[i]); message("clistbox_main: Removing option %d\n", selected[i]);
listbox->removeOption(selected[i]); listbox->removeOption(selected[i]);
test->showListBox(listbox); test->showListBox(listbox);
usleep(500000); usleep(500000);
} }
updateMemoryUsage(g_mmPrevious, MAIN_STRING "After removing five options"); updateMemoryUsage(g_mmPrevious, "clistbox_main: After removing five options");
} }
sleep(1); sleep(1);
} }
updateMemoryUsage(g_mmPrevious, MAIN_STRING "After the listbox is empty again"); updateMemoryUsage(g_mmPrevious, "clistbox_main: After the listbox is empty again");
sleep(1); sleep(1);
// Clean up and exit // Clean up and exit
message(MAIN_STRING "Clean-up and exit\n"); message("clistbox_main: Clean-up and exit\n");
delete listbox; delete listbox;
updateMemoryUsage(g_mmPrevious, "After deleting the listbox"); updateMemoryUsage(g_mmPrevious, "After deleting the listbox");
delete test; delete test;

10
UnitTests/CListBox/clistboxtest.hxx
View File

@ -69,16 +69,6 @@
# define CONFIG_CLISTBOXTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR # define CONFIG_CLISTBOXTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME clistbox_main
# define MAIN_STRING "clistbox_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
// If debug is enabled, use the debug function, lib_rawprintf() instead // If debug is enabled, use the debug function, lib_rawprintf() instead
// of printf() so that the output is synchronized. // of printf() so that the output is synchronized.

2
UnitTests/CProgressBar/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx cprogressbartest.cxx CXXSRCS = cprogressbar_main.cxx cprogressbartest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

38
UnitTests/CProgressBar/main.cxx → UnitTests/CProgressBar/cprogressbar_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CProgressBar/main.cxx // NxWidgets/UnitTests/CProgressBar/cprogressbar_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -73,7 +73,7 @@ static unsigned int g_mmprevious;
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int cprogressbar_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Private Functions // Private Functions
@ -135,7 +135,7 @@ static void initMemoryUsage(void)
// Name: user_start/nxheaders_main // Name: user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int cprogressbar_main(int argc, char *argv[])
{ {
// Initialize memory monitor logic // Initialize memory monitor logic
@ -143,43 +143,43 @@ int MAIN_NAME(int argc, char *argv[])
// Create an instance of the checkbox test // Create an instance of the checkbox test
message(MAIN_STRING "Create CProgressBarTest instance\n"); message("cprogressbar_main: Create CProgressBarTest instance\n");
CProgressBarTest *test = new CProgressBarTest(); CProgressBarTest *test = new CProgressBarTest();
updateMemoryUsage(g_mmprevious, "After creating CProgressBarTest"); updateMemoryUsage(g_mmprevious, "After creating CProgressBarTest");
// Connect the NX server // Connect the NX server
message(MAIN_STRING "Connect the CProgressBarTest instance to the NX server\n"); message("cprogressbar_main: Connect the CProgressBarTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
message(MAIN_STRING "Failed to connect the CProgressBarTest instance to the NX server\n"); message("cprogressbar_main: Failed to connect the CProgressBarTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After connecting to the server"); updateMemoryUsage(g_mmprevious, "cprogressbar_main: After connecting to the server");
// Create a window to draw into // Create a window to draw into
message(MAIN_STRING "Create a Window\n"); message("cprogressbar_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
message(MAIN_STRING "Failed to create a window\n"); message("cprogressbar_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After creating a window"); updateMemoryUsage(g_mmprevious, "cprogressbar_main: After creating a window");
// Create a progress bar // Create a progress bar
message(MAIN_STRING "Create a ProgressBar\n"); message("cprogressbar_main: Create a ProgressBar\n");
CProgressBar *bar = test->createProgressBar(); CProgressBar *bar = test->createProgressBar();
if (!bar) if (!bar)
{ {
message(MAIN_STRING "Failed to create a progress bar\n"); message("cprogressbar_main: Failed to create a progress bar\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After creating a progress bar"); updateMemoryUsage(g_mmprevious, "cprogressbar_main: After creating a progress bar");
// Set the progress bar minimum and maximum values // Set the progress bar minimum and maximum values
@ -187,7 +187,7 @@ int MAIN_NAME(int argc, char *argv[])
bar->setMaximumValue(MAX_PROGRESSBAR); bar->setMaximumValue(MAX_PROGRESSBAR);
bar->setValue(0); bar->setValue(0);
bar->hidePercentageText(); bar->hidePercentageText();
message(MAIN_STRING "ProgressBar range %d->%d Initial value %d\n", message("cprogressbar_main: ProgressBar range %d->%d Initial value %d\n",
bar->getMinimumValue(), bar->getMaximumValue(), bar->getMinimumValue(), bar->getMaximumValue(),
bar->getValue()); bar->getValue());
@ -202,10 +202,10 @@ int MAIN_NAME(int argc, char *argv[])
{ {
bar->setValue(i); bar->setValue(i);
test->showProgressBar(bar); test->showProgressBar(bar);
message(MAIN_STRING "%d. New value %d\n", i, bar->getValue()); message("cprogressbar_main: %d. New value %d\n", i, bar->getValue());
usleep(1000); // The simulation needs this to let the X11 event loop run usleep(1000); // The simulation needs this to let the X11 event loop run
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After moving the progress bar up #1"); updateMemoryUsage(g_mmprevious, "cprogressbar_main: After moving the progress bar up #1");
usleep(500*1000); usleep(500*1000);
// Now move the progress bar up from 0 to 100% (with percentages off) // Now move the progress bar up from 0 to 100% (with percentages off)
@ -219,15 +219,15 @@ int MAIN_NAME(int argc, char *argv[])
{ {
bar->setValue(i); bar->setValue(i);
test->showProgressBar(bar); test->showProgressBar(bar);
message(MAIN_STRING "%d. New value %d\n", i, bar->getValue()); message("cprogressbar_main: %d. New value %d\n", i, bar->getValue());
usleep(1000); // The simulation needs this to let the X11 event loop run usleep(1000); // The simulation needs this to let the X11 event loop run
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After moving the progress bar up #2"); updateMemoryUsage(g_mmprevious, "cprogressbar_main: After moving the progress bar up #2");
sleep(1); sleep(1);
// Clean up and exit // Clean up and exit
message(MAIN_STRING "Clean-up and exit\n"); message("cprogressbar_main: Clean-up and exit\n");
delete bar; delete bar;
updateMemoryUsage(g_mmprevious, "After deleting the progress bar"); updateMemoryUsage(g_mmprevious, "After deleting the progress bar");
delete test; delete test;

10
UnitTests/CProgressBar/cprogressbartest.hxx
View File

@ -69,16 +69,6 @@
# define CONFIG_CPROGRESSBARTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR # define CONFIG_CPROGRESSBARTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME cprogressbar_main
# define MAIN_STRING "cprogressbar_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
// If debug is enabled, use the debug function, lib_rawprintf() instead // If debug is enabled, use the debug function, lib_rawprintf() instead
// of printf() so that the output is synchronized. // of printf() so that the output is synchronized.

2
UnitTests/CRadioButton/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx cradiobuttontest.cxx CXXSRCS = cradiobutton_main.cxx cradiobuttontest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

40
UnitTests/CRadioButton/main.cxx → UnitTests/CRadioButton/cradiobutton_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CRadioButton/main.cxx // NxWidgets/UnitTests/CRadioButton/cradiobutton_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -73,7 +73,7 @@ static unsigned int g_mmprevious;
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int cradiobutton_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Private Functions // Private Functions
@ -135,7 +135,7 @@ static void initMemoryUsage(void)
// Name: user_start/nxheaders_main // Name: user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int cradiobutton_main(int argc, char *argv[])
{ {
// Initialize memory monitor logic // Initialize memory monitor logic
@ -143,60 +143,60 @@ int MAIN_NAME(int argc, char *argv[])
// Create an instance of the radio button test // Create an instance of the radio button test
message(MAIN_STRING "Create CRadioButtonTest instance\n"); message("cradiobutton_main: Create CRadioButtonTest instance\n");
CRadioButtonTest *test = new CRadioButtonTest(); CRadioButtonTest *test = new CRadioButtonTest();
updateMemoryUsage(g_mmprevious, "After creating CRadioButtonTest"); updateMemoryUsage(g_mmprevious, "After creating CRadioButtonTest");
// Connect the NX server // Connect the NX server
message(MAIN_STRING "Connect the CRadioButtonTest instance to the NX server\n"); message("cradiobutton_main: Connect the CRadioButtonTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
message(MAIN_STRING "Failed to connect the CRadioButtonTest instance to the NX server\n"); message("cradiobutton_main: Failed to connect the CRadioButtonTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After connecting to the server"); updateMemoryUsage(g_mmprevious, "cradiobutton_main: After connecting to the server");
// Create a window to draw into // Create a window to draw into
message(MAIN_STRING "Create a Window\n"); message("cradiobutton_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
message(MAIN_STRING "Failed to create a window\n"); message("cradiobutton_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After creating a window"); updateMemoryUsage(g_mmprevious, "cradiobutton_main: After creating a window");
// Create three radio buttons // Create three radio buttons
CRadioButton *button1 = test->newRadioButton(); CRadioButton *button1 = test->newRadioButton();
if (!button1) if (!button1)
{ {
message(MAIN_STRING "Failed to create radio button 1\n"); message("cradiobutton_main: Failed to create radio button 1\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After creating radio button 1"); updateMemoryUsage(g_mmprevious, "cradiobutton_main: After creating radio button 1");
CRadioButton *button2 = test->newRadioButton(); CRadioButton *button2 = test->newRadioButton();
if (!button2) if (!button2)
{ {
message(MAIN_STRING "Failed to create radio button 2\n"); message("cradiobutton_main: Failed to create radio button 2\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After creating radio button 2"); updateMemoryUsage(g_mmprevious, "cradiobutton_main: After creating radio button 2");
CRadioButton *button3 = test->newRadioButton(); CRadioButton *button3 = test->newRadioButton();
if (!button3) if (!button3)
{ {
message(MAIN_STRING "Failed to create radio button 3\n"); message("cradiobutton_main: Failed to create radio button 3\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After creating radio button 3"); updateMemoryUsage(g_mmprevious, "cradiobutton_main: After creating radio button 3");
// Show the initial state of the buttons // Show the initial state of the buttons
@ -206,21 +206,21 @@ int MAIN_NAME(int argc, char *argv[])
// Now push some buttons // Now push some buttons
message(MAIN_STRING "Pushing button 1\n"); message("cradiobutton_main: Pushing button 1\n");
test->pushButton(button1); test->pushButton(button1);
usleep(500*1000); usleep(500*1000);
test->showButtonState(); test->showButtonState();
updateMemoryUsage(g_mmprevious, "After pushing button 1"); updateMemoryUsage(g_mmprevious, "After pushing button 1");
usleep(500*1000); usleep(500*1000);
message(MAIN_STRING "Pushing button 2\n"); message("cradiobutton_main: Pushing button 2\n");
test->pushButton(button2); test->pushButton(button2);
usleep(500*1000); usleep(500*1000);
test->showButtonState(); test->showButtonState();
updateMemoryUsage(g_mmprevious, "After pushing button 2"); updateMemoryUsage(g_mmprevious, "After pushing button 2");
usleep(500*1000); usleep(500*1000);
message(MAIN_STRING "Pushing button 3\n"); message("cradiobutton_main: Pushing button 3\n");
test->pushButton(button3); test->pushButton(button3);
usleep(500*1000); usleep(500*1000);
test->showButtonState(); test->showButtonState();
@ -229,7 +229,7 @@ int MAIN_NAME(int argc, char *argv[])
// Clean up and exit // Clean up and exit
message(MAIN_STRING "Clean-up and exit\n"); message("cradiobutton_main: Clean-up and exit\n");
delete test; delete test;
updateMemoryUsage(g_mmprevious, "After deleting the test"); updateMemoryUsage(g_mmprevious, "After deleting the test");
updateMemoryUsage(g_mmInitial, "Final memory usage"); updateMemoryUsage(g_mmInitial, "Final memory usage");

10
UnitTests/CRadioButton/cradiobuttontest.hxx
View File

@ -70,16 +70,6 @@
# define CONFIG_CRADIOBUTTONTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR # define CONFIG_CRADIOBUTTONTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME cradiobutton_main
# define MAIN_STRING "cradiobutton_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
// If debug is enabled, use the debug function, lib_rawprintf() instead // If debug is enabled, use the debug function, lib_rawprintf() instead
// of printf() so that the output is synchronized. // of printf() so that the output is synchronized.

2
UnitTests/CScrollbarHorizontal/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx cscrollbarhorizontaltest.cxx CXXSRCS = cscrollbarhorizontal_main.cxx cscrollbarhorizontaltest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

10
UnitTests/CScrollbarHorizontal/cscrollbarhorizontaltest.hxx
View File

@ -69,16 +69,6 @@
# define CONFIG_CSCROLLBARHORIZONTALTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR # define CONFIG_CSCROLLBARHORIZONTALTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME cscrollbarhorizontal_main
# define MAIN_STRING "cscrollbarhorizontal_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
// If debug is enabled, use the debug function, lib_rawprintf() instead // If debug is enabled, use the debug function, lib_rawprintf() instead
// of printf() so that the output is synchronized. // of printf() so that the output is synchronized.

2
UnitTests/CScrollbarVertical/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx cscrollbarverticaltest.cxx CXXSRCS = cscrollbarvertical_main.cxx cscrollbarverticaltest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

38
UnitTests/CScrollbarVertical/main.cxx → UnitTests/CScrollbarVertical/cscrollbarvertical_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CScrollbarVertical/main.cxx // NxWidgets/UnitTests/CScrollbarVertical/cscrollbarvertical_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -73,7 +73,7 @@ static unsigned int g_mmprevious;
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int cscrollbarvertical_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Private Functions // Private Functions
@ -135,7 +135,7 @@ static void initMemoryUsage(void)
// Name: user_start/nxheaders_main // Name: user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int cscrollbarvertical_main(int argc, char *argv[])
{ {
// Initialize memory monitor logic // Initialize memory monitor logic
@ -143,50 +143,50 @@ int MAIN_NAME(int argc, char *argv[])
// Create an instance of the checkbox test // Create an instance of the checkbox test
message(MAIN_STRING "Create CScrollbarVerticalTest instance\n"); message("cscrollbarvertical_main: Create CScrollbarVerticalTest instance\n");
CScrollbarVerticalTest *test = new CScrollbarVerticalTest(); CScrollbarVerticalTest *test = new CScrollbarVerticalTest();
updateMemoryUsage(g_mmprevious, "After creating CScrollbarVerticalTest"); updateMemoryUsage(g_mmprevious, "After creating CScrollbarVerticalTest");
// Connect the NX server // Connect the NX server
message(MAIN_STRING "Connect the CScrollbarVerticalTest instance to the NX server\n"); message("cscrollbarvertical_main: Connect the CScrollbarVerticalTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
message(MAIN_STRING "Failed to connect the CScrollbarVerticalTest instance to the NX server\n"); message("cscrollbarvertical_main: Failed to connect the CScrollbarVerticalTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After connecting to the server"); updateMemoryUsage(g_mmprevious, "cscrollbarvertical_main: After connecting to the server");
// Create a window to draw into // Create a window to draw into
message(MAIN_STRING "Create a Window\n"); message("cscrollbarvertical_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
message(MAIN_STRING "Failed to create a window\n"); message("cscrollbarvertical_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After creating a window"); updateMemoryUsage(g_mmprevious, "cscrollbarvertical_main: After creating a window");
// Create a scrollbar // Create a scrollbar
message(MAIN_STRING "Create a Scrollbar\n"); message("cscrollbarvertical_main: Create a Scrollbar\n");
CScrollbarVertical *scrollbar = test->createScrollbar(); CScrollbarVertical *scrollbar = test->createScrollbar();
if (!scrollbar) if (!scrollbar)
{ {
message(MAIN_STRING "Failed to create a scrollbar\n"); message("cscrollbarvertical_main: Failed to create a scrollbar\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After creating a scrollbar"); updateMemoryUsage(g_mmprevious, "cscrollbarvertical_main: After creating a scrollbar");
// Set the scrollbar minimum and maximum values // Set the scrollbar minimum and maximum values
scrollbar->setMinimumValue(0); scrollbar->setMinimumValue(0);
scrollbar->setMaximumValue(MAX_SCROLLBAR); scrollbar->setMaximumValue(MAX_SCROLLBAR);
scrollbar->setValue(0); scrollbar->setValue(0);
message(MAIN_STRING "Scrollbar range %d->%d Initial value %d\n", message("cscrollbarvertical_main: Scrollbar range %d->%d Initial value %d\n",
scrollbar->getMinimumValue(), scrollbar->getMaximumValue(), scrollbar->getMinimumValue(), scrollbar->getMaximumValue(),
scrollbar->getValue()); scrollbar->getValue());
@ -201,10 +201,10 @@ int MAIN_NAME(int argc, char *argv[])
{ {
scrollbar->setValue(i); scrollbar->setValue(i);
test->showScrollbar(scrollbar); test->showScrollbar(scrollbar);
message(MAIN_STRING "%d. New value %d\n", i, scrollbar->getValue()); message("cscrollbarvertical_main: %d. New value %d\n", i, scrollbar->getValue());
usleep(1000); // The simulation needs this to let the X11 event loop run usleep(1000); // The simulation needs this to let the X11 event loop run
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After moving the scrollbar up"); updateMemoryUsage(g_mmprevious, "cscrollbarvertical_main: After moving the scrollbar up");
// And move the scrollbar down // And move the scrollbar down
@ -212,15 +212,15 @@ int MAIN_NAME(int argc, char *argv[])
{ {
scrollbar->setValue(i); scrollbar->setValue(i);
test->showScrollbar(scrollbar); test->showScrollbar(scrollbar);
message(MAIN_STRING "%d. New value %d\n", i, scrollbar->getValue()); message("cscrollbarvertical_main: %d. New value %d\n", i, scrollbar->getValue());
usleep(5000); // The simulation needs this to let the X11 event loop run usleep(5000); // The simulation needs this to let the X11 event loop run
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After moving the scrollbar down"); updateMemoryUsage(g_mmprevious, "cscrollbarvertical_main: After moving the scrollbar down");
sleep(1); sleep(1);
// Clean up and exit // Clean up and exit
message(MAIN_STRING "Clean-up and exit\n"); message("cscrollbarvertical_main: Clean-up and exit\n");
delete scrollbar; delete scrollbar;
updateMemoryUsage(g_mmprevious, "After deleting the scrollbar"); updateMemoryUsage(g_mmprevious, "After deleting the scrollbar");
delete test; delete test;

10
UnitTests/CScrollbarVertical/cscrollbarverticaltest.hxx
View File

@ -69,16 +69,6 @@
# define CONFIG_CSCROLLBARVERTICALTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR # define CONFIG_CSCROLLBARVERTICALTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME cscrollbarvertical_main
# define MAIN_STRING "cscrollbarvertical_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
// If debug is enabled, use the debug function, lib_rawprintf() instead // If debug is enabled, use the debug function, lib_rawprintf() instead
// of printf() so that the output is synchronized. // of printf() so that the output is synchronized.

2
UnitTests/CSliderHorizonal/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx csliderhorizontaltest.cxx CXXSRCS = csliderhorizontal_main.cxx csliderhorizontaltest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

38
UnitTests/CSliderHorizonal/main.cxx → UnitTests/CSliderHorizonal/csliderhorizontal_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CSliderHorizontal/main.cxx // NxWidgets/UnitTests/CSliderHorizontal/csliderhorizontal_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -73,7 +73,7 @@ static unsigned int g_mmprevious;
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int csliderhorizontal_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Private Functions // Private Functions
@ -135,7 +135,7 @@ static void initMemoryUsage(void)
// Name: user_start/nxheaders_main // Name: user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int csliderhorizontal_main(int argc, char *argv[])
{ {
// Initialize memory monitor logic // Initialize memory monitor logic
@ -143,50 +143,50 @@ int MAIN_NAME(int argc, char *argv[])
// Create an instance of the checkbox test // Create an instance of the checkbox test
message(MAIN_STRING "Create CSliderHorizontalTest instance\n"); message("csliderhorizontal_main: Create CSliderHorizontalTest instance\n");
CSliderHorizontalTest *test = new CSliderHorizontalTest(); CSliderHorizontalTest *test = new CSliderHorizontalTest();
updateMemoryUsage(g_mmprevious, "After creating CSliderHorizontalTest"); updateMemoryUsage(g_mmprevious, "After creating CSliderHorizontalTest");
// Connect the NX server // Connect the NX server
message(MAIN_STRING "Connect the CSliderHorizontalTest instance to the NX server\n"); message("csliderhorizontal_main: Connect the CSliderHorizontalTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
message(MAIN_STRING "Failed to connect the CSliderHorizontalTest instance to the NX server\n"); message("csliderhorizontal_main: Failed to connect the CSliderHorizontalTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After connecting to the server"); updateMemoryUsage(g_mmprevious, "csliderhorizontal_main: After connecting to the server");
// Create a window to draw into // Create a window to draw into
message(MAIN_STRING "Create a Window\n"); message("csliderhorizontal_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
message(MAIN_STRING "Failed to create a window\n"); message("csliderhorizontal_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After creating a window"); updateMemoryUsage(g_mmprevious, "csliderhorizontal_main: After creating a window");
// Create a slider // Create a slider
message(MAIN_STRING "Create a Slider\n"); message("csliderhorizontal_main: Create a Slider\n");
CSliderHorizontal *slider = test->createSlider(); CSliderHorizontal *slider = test->createSlider();
if (!slider) if (!slider)
{ {
message(MAIN_STRING "Failed to create a slider\n"); message("csliderhorizontal_main: Failed to create a slider\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After creating a slider"); updateMemoryUsage(g_mmprevious, "csliderhorizontal_main: After creating a slider");
// Set the slider minimum and maximum values // Set the slider minimum and maximum values
slider->setMinimumValue(0); slider->setMinimumValue(0);
slider->setMaximumValue(MAX_SLIDER); slider->setMaximumValue(MAX_SLIDER);
slider->setValue(0); slider->setValue(0);
message(MAIN_STRING "Slider range %d->%d Initial value %d\n", message("csliderhorizontal_main: Slider range %d->%d Initial value %d\n",
slider->getMinimumValue(), slider->getMaximumValue(), slider->getMinimumValue(), slider->getMaximumValue(),
slider->getValue()); slider->getValue());
@ -201,10 +201,10 @@ int MAIN_NAME(int argc, char *argv[])
{ {
slider->setValue(i); slider->setValue(i);
test->showSlider(slider); test->showSlider(slider);
message(MAIN_STRING "%d. New value %d\n", i, slider->getValue()); message("csliderhorizontal_main: %d. New value %d\n", i, slider->getValue());
usleep(1000); // The simulation needs this to let the X11 event loop run usleep(1000); // The simulation needs this to let the X11 event loop run
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After moving the slider up"); updateMemoryUsage(g_mmprevious, "csliderhorizontal_main: After moving the slider up");
// And move the slider down // And move the slider down
@ -212,15 +212,15 @@ int MAIN_NAME(int argc, char *argv[])
{ {
slider->setValue(i); slider->setValue(i);
test->showSlider(slider); test->showSlider(slider);
message(MAIN_STRING "%d. New value %d\n", i, slider->getValue()); message("csliderhorizontal_main: %d. New value %d\n", i, slider->getValue());
usleep(1000); // The simulation needs this to let the X11 event loop run usleep(1000); // The simulation needs this to let the X11 event loop run
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After moving the slider down"); updateMemoryUsage(g_mmprevious, "csliderhorizontal_main: After moving the slider down");
sleep(1); sleep(1);
// Clean up and exit // Clean up and exit
message(MAIN_STRING "Clean-up and exit\n"); message("csliderhorizontal_main: Clean-up and exit\n");
delete slider; delete slider;
updateMemoryUsage(g_mmprevious, "After deleting the slider"); updateMemoryUsage(g_mmprevious, "After deleting the slider");
delete test; delete test;

10
UnitTests/CSliderHorizonal/csliderhorizontaltest.hxx
View File

@ -69,16 +69,6 @@
# define CONFIG_CSLIDERHORIZONTALTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR # define CONFIG_CSLIDERHORIZONTALTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME csliderhorizontal_main
# define MAIN_STRING "csliderhorizontal_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
// If debug is enabled, use the debug function, lib_rawprintf() instead // If debug is enabled, use the debug function, lib_rawprintf() instead
// of printf() so that the output is synchronized. // of printf() so that the output is synchronized.

2
UnitTests/CSliderVertical/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx csliderverticaltest.cxx CXXSRCS = cslidervertical_main.cxx csliderverticaltest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

38
UnitTests/CSliderVertical/main.cxx → UnitTests/CSliderVertical/cslidervertical_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CSliderVertical/main.cxx // NxWidgets/UnitTests/CSliderVertical/cslidervertical_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -73,7 +73,7 @@ static unsigned int g_mmprevious;
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int cslidervertical_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Private Functions // Private Functions
@ -135,7 +135,7 @@ static void initMemoryUsage(void)
// Name: user_start/nxheaders_main // Name: user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int cslidervertical_main(int argc, char *argv[])
{ {
// Initialize memory monitor logic // Initialize memory monitor logic
@ -143,50 +143,50 @@ int MAIN_NAME(int argc, char *argv[])
// Create an instance of the checkbox test // Create an instance of the checkbox test
message(MAIN_STRING "Create CSliderVerticalTest instance\n"); message("cslidervertical_main: Create CSliderVerticalTest instance\n");
CSliderVerticalTest *test = new CSliderVerticalTest(); CSliderVerticalTest *test = new CSliderVerticalTest();
updateMemoryUsage(g_mmprevious, "After creating CSliderVerticalTest"); updateMemoryUsage(g_mmprevious, "After creating CSliderVerticalTest");
// Connect the NX server // Connect the NX server
message(MAIN_STRING "Connect the CSliderVerticalTest instance to the NX server\n"); message("cslidervertical_main: Connect the CSliderVerticalTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
message(MAIN_STRING "Failed to connect the CSliderVerticalTest instance to the NX server\n"); message("cslidervertical_main: Failed to connect the CSliderVerticalTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After connecting to the server"); updateMemoryUsage(g_mmprevious, "cslidervertical_main: After connecting to the server");
// Create a window to draw into // Create a window to draw into
message(MAIN_STRING "Create a Window\n"); message("cslidervertical_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
message(MAIN_STRING "Failed to create a window\n"); message("cslidervertical_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After creating a window"); updateMemoryUsage(g_mmprevious, "cslidervertical_main: After creating a window");
// Create a slider // Create a slider
message(MAIN_STRING "Create a Slider\n"); message("cslidervertical_main: Create a Slider\n");
CSliderVertical *slider = test->createSlider(); CSliderVertical *slider = test->createSlider();
if (!slider) if (!slider)
{ {
message(MAIN_STRING "Failed to create a slider\n"); message("cslidervertical_main: Failed to create a slider\n");
delete test; delete test;
return 1; return 1;
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After creating a slider"); updateMemoryUsage(g_mmprevious, "cslidervertical_main: After creating a slider");
// Set the slider minimum and maximum values // Set the slider minimum and maximum values
slider->setMinimumValue(0); slider->setMinimumValue(0);
slider->setMaximumValue(MAX_SLIDER); slider->setMaximumValue(MAX_SLIDER);
slider->setValue(0); slider->setValue(0);
message(MAIN_STRING "Slider range %d->%d Initial value %d\n", message("cslidervertical_main: Slider range %d->%d Initial value %d\n",
slider->getMinimumValue(), slider->getMaximumValue(), slider->getMinimumValue(), slider->getMaximumValue(),
slider->getValue()); slider->getValue());
@ -201,10 +201,10 @@ int MAIN_NAME(int argc, char *argv[])
{ {
slider->setValue(i); slider->setValue(i);
test->showSlider(slider); test->showSlider(slider);
message(MAIN_STRING "%d. New value %d\n", i, slider->getValue()); message("cslidervertical_main: %d. New value %d\n", i, slider->getValue());
usleep(1000); // The simulation needs this to let the X11 event loop run usleep(1000); // The simulation needs this to let the X11 event loop run
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After moving the slider up"); updateMemoryUsage(g_mmprevious, "cslidervertical_main: After moving the slider up");
// And move the slider down // And move the slider down
@ -212,15 +212,15 @@ int MAIN_NAME(int argc, char *argv[])
{ {
slider->setValue(i); slider->setValue(i);
test->showSlider(slider); test->showSlider(slider);
message(MAIN_STRING "%d. New value %d\n", i, slider->getValue()); message("cslidervertical_main: %d. New value %d\n", i, slider->getValue());
usleep(1000); // The simulation needs this to let the X11 event loop run usleep(1000); // The simulation needs this to let the X11 event loop run
} }
updateMemoryUsage(g_mmprevious, MAIN_STRING "After moving the slider down"); updateMemoryUsage(g_mmprevious, "cslidervertical_main: After moving the slider down");
sleep(1); sleep(1);
// Clean up and exit // Clean up and exit
message(MAIN_STRING "Clean-up and exit\n"); message("cslidervertical_main: Clean-up and exit\n");
delete slider; delete slider;
updateMemoryUsage(g_mmprevious, "After deleting the slider"); updateMemoryUsage(g_mmprevious, "After deleting the slider");
delete test; delete test;

10
UnitTests/CSliderVertical/csliderverticaltest.hxx
View File

@ -69,16 +69,6 @@
# define CONFIG_CSLIDERVERTICALTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR # define CONFIG_CSLIDERVERTICALTEST_BGCOLOR CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME cslidervertical_main
# define MAIN_STRING "cslidervertical_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
// If debug is enabled, use the debug function, lib_rawprintf() instead // If debug is enabled, use the debug function, lib_rawprintf() instead
// of printf() so that the output is synchronized. // of printf() so that the output is synchronized.

2
UnitTests/CTextBox/Makefile
View File

@ -63,7 +63,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx ctextboxtest.cxx CXXSRCS = ctextbox_main.cxx ctextboxtest.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

20
UnitTests/CTextBox/main.cxx → UnitTests/CTextBox/ctextbox_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/CTextBox/main.cxx // NxWidgets/UnitTests/CTextBox/ctextbox_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -69,7 +69,7 @@ static const char string2[] = "\b\b\bn Doe\r";
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int ctextbox_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Public Functions // Public Functions
@ -79,29 +79,29 @@ extern "C" int MAIN_NAME(int argc, char *argv[]);
// user_start/nxheaders_main // user_start/nxheaders_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int ctextbox_main(int argc, char *argv[])
{ {
// Create an instance of the font test // Create an instance of the font test
printf(MAIN_STRING "Create CTextBoxTest instance\n"); printf("ctextbox_main: Create CTextBoxTest instance\n");
CTextBoxTest *test = new CTextBoxTest(); CTextBoxTest *test = new CTextBoxTest();
// Connect the NX server // Connect the NX server
printf(MAIN_STRING "Connect the CTextBoxTest instance to the NX server\n"); printf("ctextbox_main: Connect the CTextBoxTest instance to the NX server\n");
if (!test->connect()) if (!test->connect())
{ {
printf(MAIN_STRING "Failed to connect the CTextBoxTest instance to the NX server\n"); printf("ctextbox_main: Failed to connect the CTextBoxTest instance to the NX server\n");
delete test; delete test;
return 1; return 1;
} }
// Create a window to draw into // Create a window to draw into
printf(MAIN_STRING "Create a Window\n"); printf("ctextbox_main: Create a Window\n");
if (!test->createWindow()) if (!test->createWindow())
{ {
printf(MAIN_STRING "Failed to create a window\n"); printf("ctextbox_main: Failed to create a window\n");
delete test; delete test;
return 1; return 1;
} }
@ -111,7 +111,7 @@ int MAIN_NAME(int argc, char *argv[])
CTextBox *textbox = test->createTextBox(); CTextBox *textbox = test->createTextBox();
if (!textbox) if (!textbox)
{ {
printf(MAIN_STRING "Failed to create a text box\n"); printf("ctextbox_main: Failed to create a text box\n");
delete test; delete test;
return 1; return 1;
} }
@ -133,7 +133,7 @@ int MAIN_NAME(int argc, char *argv[])
// Clean up and exit // Clean up and exit
sleep(2); sleep(2);
printf(MAIN_STRING "Clean-up and exit\n"); printf("ctextbox_main: Clean-up and exit\n");
delete textbox; delete textbox;
delete test; delete test;
return 0; return 0;

10
UnitTests/CTextBox/ctextboxtest.hxx
View File

@ -75,16 +75,6 @@
# define CONFIG_CTEXTBOXTEST_FONTCOLOR CONFIG_NXWIDGETS_DEFAULT_FONTCOLOR # define CONFIG_CTEXTBOXTEST_FONTCOLOR CONFIG_NXWIDGETS_DEFAULT_FONTCOLOR
#endif #endif
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME ctextbox_main
# define MAIN_STRING "ctextbox_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Public Classes // Public Classes
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////

2
UnitTests/nxwm/Makefile
View File

@ -77,7 +77,7 @@ ARCHIVER=$(TESTTOOL_DIR)/addobjs.sh
ASRCS = ASRCS =
CSRCS = CSRCS =
CXXSRCS = main.cxx CXXSRCS = nxwm_main.cxx
AOBJS = $(ASRCS:.S=$(OBJEXT)) AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT)) COBJS = $(CSRCS:.c=$(OBJEXT))

52
UnitTests/nxwm/main.cxx → UnitTests/nxwm/nxwm_main.cxx
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// NxWidgets/UnitTests/nxwm/main.cxx // NxWidgets/UnitTests/nxwm/nxwm_main.cxx
// //
// Copyright (C) 2012 Gregory Nutt. All rights reserved. // Copyright (C) 2012 Gregory Nutt. All rights reserved.
// Author: Gregory Nutt <gnutt@nuttx.org> // Author: Gregory Nutt <gnutt@nuttx.org>
@ -62,16 +62,6 @@
// Pre-processor Definitions // Pre-processor Definitions
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// What is the entry point called?
#ifdef CONFIG_NSH_BUILTIN_APPS
# define MAIN_NAME nxwm_main
# define MAIN_STRING "nxwm_main: "
#else
# define MAIN_NAME user_start
# define MAIN_STRING "user_start: "
#endif
#ifdef CONFIG_HAVE_FILENAME #ifdef CONFIG_HAVE_FILENAME
# define showTestStepMemory(msg) \ # define showTestStepMemory(msg) \
_showTestStepMemory((FAR const char*)__FILE__, (int)__LINE__, msg) _showTestStepMemory((FAR const char*)__FILE__, (int)__LINE__, msg)
@ -121,7 +111,7 @@ static struct SNxWmTest g_nxwmtest;
// Suppress name-mangling // Suppress name-mangling
extern "C" int MAIN_NAME(int argc, char *argv[]); extern "C" int nxwm_main(int argc, char *argv[]);
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Public Functions // Public Functions
@ -503,7 +493,7 @@ static bool createCalibration(void)
printf("createCalibration: Start the calibration application\n"); printf("createCalibration: Start the calibration application\n");
if (!g_nxwmtest.taskbar->startApplication(calibration, false)) if (!g_nxwmtest.taskbar->startApplication(calibration, false))
{ {
printf(MAIN_STRING "ERROR: Failed to start the calibration application\n"); printf("createCalibration ERROR: Failed to start the calibration application\n");
delete calibration; delete calibration;
return false; return false;
} }
@ -599,7 +589,7 @@ void showTestStepMemory(FAR const char *msg)
// user_start/nxwm_main // user_start/nxwm_main
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int MAIN_NAME(int argc, char *argv[]) int nxwm_main(int argc, char *argv[])
{ {
// Call all C++ static constructors // Call all C++ static constructors
@ -613,19 +603,19 @@ int MAIN_NAME(int argc, char *argv[])
// Initialize the NSH library // Initialize the NSH library
printf(MAIN_STRING "Initialize the NSH library\n"); printf("nxwm_main: Initialize the NSH library\n");
if (!NxWM::nshlibInitialize()) if (!NxWM::nshlibInitialize())
{ {
printf(MAIN_STRING "ERROR: Failed to initialize the NSH library\n"); printf("nxwm_main: ERROR: Failed to initialize the NSH library\n");
return EXIT_FAILURE; return EXIT_FAILURE;
} }
showTestCaseMemory(MAIN_STRING "After initializing the NSH library"); showTestCaseMemory("nxwm_main: After initializing the NSH library");
// Create the task bar. // Create the task bar.
if (!createTaskbar()) if (!createTaskbar())
{ {
printf(MAIN_STRING "ERROR: Failed to create the task bar\n"); printf("nxwm_main: ERROR: Failed to create the task bar\n");
testCleanUpAndExit(EXIT_FAILURE); testCleanUpAndExit(EXIT_FAILURE);
} }
@ -633,7 +623,7 @@ int MAIN_NAME(int argc, char *argv[])
if (!createStartWindow()) if (!createStartWindow())
{ {
printf(MAIN_STRING "ERROR: Failed to create the start window\n"); printf("nxwm_main: ERROR: Failed to create the start window\n");
testCleanUpAndExit(EXIT_FAILURE); testCleanUpAndExit(EXIT_FAILURE);
} }
@ -642,7 +632,7 @@ int MAIN_NAME(int argc, char *argv[])
#ifdef CONFIG_NXWM_KEYBOARD #ifdef CONFIG_NXWM_KEYBOARD
if (!createKeyboard()) if (!createKeyboard())
{ {
printf(MAIN_STRING "ERROR: Failed to create the keyboard\n"); printf("nxwm_main: ERROR: Failed to create the keyboard\n");
testCleanUpAndExit(EXIT_FAILURE); testCleanUpAndExit(EXIT_FAILURE);
} }
#endif #endif
@ -652,7 +642,7 @@ int MAIN_NAME(int argc, char *argv[])
#ifdef CONFIG_NXWM_TOUCHSCREEN #ifdef CONFIG_NXWM_TOUCHSCREEN
if (!createTouchScreen()) if (!createTouchScreen())
{ {
printf(MAIN_STRING "ERROR: Failed to create the touchscreen\n"); printf("nxwm_main ERROR: Failed to create the touchscreen\n");
testCleanUpAndExit(EXIT_FAILURE); testCleanUpAndExit(EXIT_FAILURE);
} }
#endif #endif
@ -662,7 +652,7 @@ int MAIN_NAME(int argc, char *argv[])
#ifdef CONFIG_NXWM_TOUCHSCREEN #ifdef CONFIG_NXWM_TOUCHSCREEN
if (!createCalibration()) if (!createCalibration())
{ {
printf(MAIN_STRING "ERROR: Failed to create the calibration application\n"); printf("nxwm_main ERROR: Failed to create the calibration application\n");
testCleanUpAndExit(EXIT_FAILURE); testCleanUpAndExit(EXIT_FAILURE);
} }
#endif #endif
@ -671,7 +661,7 @@ int MAIN_NAME(int argc, char *argv[])
if (!createNxConsole()) if (!createNxConsole())
{ {
printf(MAIN_STRING "ERROR: Failed to create the NxConsole application\n"); printf("nxwm_main: ERROR: Failed to create the NxConsole application\n");
testCleanUpAndExit(EXIT_FAILURE); testCleanUpAndExit(EXIT_FAILURE);
} }
@ -679,7 +669,7 @@ int MAIN_NAME(int argc, char *argv[])
if (!createHexCalculator()) if (!createHexCalculator())
{ {
printf(MAIN_STRING "ERROR: Failed to create the hex calculator application\n"); printf("nxwm_main: ERROR: Failed to create the hex calculator application\n");
testCleanUpAndExit(EXIT_FAILURE); testCleanUpAndExit(EXIT_FAILURE);
} }
@ -687,7 +677,7 @@ int MAIN_NAME(int argc, char *argv[])
if (!startWindowManager()) if (!startWindowManager())
{ {
printf(MAIN_STRING "ERROR: Failed to start the window manager\n"); printf("nxwm_main: ERROR: Failed to start the window manager\n");
testCleanUpAndExit(EXIT_FAILURE); testCleanUpAndExit(EXIT_FAILURE);
} }
@ -697,7 +687,7 @@ int MAIN_NAME(int argc, char *argv[])
// to know whenthe touchscreen has been calibrated. If we really want to know, // to know whenthe touchscreen has been calibrated. If we really want to know,
// we have to poll // we have to poll
printf(MAIN_STRING "Waiting for touchscreen calibration\n"); printf("nxwm_main: Waiting for touchscreen calibration\n");
while (!g_nxwmtest.touchscreen->isCalibrated()) while (!g_nxwmtest.touchscreen->isCalibrated())
{ {
std::sleep(2); std::sleep(2);
@ -708,10 +698,10 @@ int MAIN_NAME(int argc, char *argv[])
// After the touchscreen driver gets it, it will report isCalibrated() == true // After the touchscreen driver gets it, it will report isCalibrated() == true
// and then we can read the calibration data from the touchscreen driver. // and then we can read the calibration data from the touchscreen driver.
printf(MAIN_STRING "Getting calibration data from the touchscreen\n"); printf("nxwm_main: Getting calibration data from the touchscreen\n");
if (!g_nxwmtest.touchscreen->getCalibrationData(g_nxwmtest.calibData)) if (!g_nxwmtest.touchscreen->getCalibrationData(g_nxwmtest.calibData))
{ {
printf(MAIN_STRING "ERROR: Failed to get calibration data from the touchscreen\n"); printf("nxwm_main: ERROR: Failed to get calibration data from the touchscreen\n");
} }
#endif #endif
@ -723,7 +713,7 @@ int MAIN_NAME(int argc, char *argv[])
g_nxwmtest.taskbar->clickIcon(0, true); g_nxwmtest.taskbar->clickIcon(0, true);
usleep(500*1000); usleep(500*1000);
g_nxwmtest.taskbar->clickIcon(0, false); g_nxwmtest.taskbar->clickIcon(0, false);
showTestCaseMemory(MAIN_STRING "After clicking the start window icon"); showTestCaseMemory("nxwm_main: After clicking the start window icon");
// Wait bit to see the result of the button press. Then press the first icon // Wait bit to see the result of the button press. Then press the first icon
// in the start menu. That should be the NxConsole icon. // in the start menu. That should be the NxConsole icon.
@ -732,13 +722,13 @@ int MAIN_NAME(int argc, char *argv[])
g_nxwmtest.startwindow->clickIcon(0, true); g_nxwmtest.startwindow->clickIcon(0, true);
usleep(500*1000); usleep(500*1000);
g_nxwmtest.startwindow->clickIcon(0, false); g_nxwmtest.startwindow->clickIcon(0, false);
showTestCaseMemory(MAIN_STRING "After clicking the NxConsole icon"); showTestCaseMemory("nxwm_main: After clicking the NxConsole icon");
#endif #endif
// Wait bit to see the result of the button press. // Wait bit to see the result of the button press.
sleep(2); sleep(2);
showTestMemory(MAIN_STRING "Final memory usage"); showTestMemory("nxwm_main: Final memory usage");
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }