1 files changed, 229 insertions, 0 deletions
diff --git a/trunk/TAO/orbsvcs/tests/Event/ThreadFlags/testflags.cpp b/trunk/TAO/orbsvcs/tests/Event/ThreadFlags/testflags.cpp
new file mode 100644
index 00000000000..f4fde487940
--- /dev/null
+++ b/trunk/TAO/orbsvcs/tests/Event/ThreadFlags/testflags.cpp
@@ -0,0 +1,229 @@
+// $Id$
+
+/*
+ * Test TAO_EC_Thread_Flags encapsulation.
+ */
+
+#include "orbsvcs/Event/EC_Thread_Flags.h"
+#include "ace/Log_Msg.h"
+#include "ace/OS_NS_Thread.h"
+#include "ace/OS_NS_strings.h"
+
+ACE_RCSID(EC_Tests, testflags, "$Id$")
+
+/*
+  Here are the scenarios we need to test:
+
+  1. Initialize/assign empty instance and validate defaults, priority, etc.
+  2. Initialize/assign with each flag and validate value of flags.
+  3. Initialize/assign with each scope and validate scope and flags.
+  4. Initialize/assign with each sched and validate sched and flags.
+  5. Initialize/assign with single numeric value and validate flags, sched, and scope values.
+  6. Initialize/assign with bogus symbols and validate scope/flags + error.
+  7. Initialize/assign with multiple flags and validate flags, scope, sched.
+
+ */
+struct ExpectedValues
+{
+  long flags;
+  long scope;
+  long sched;
+
+  ExpectedValues(long f = 0, long sco = 0, long sch = 0)
+    : flags(f)
+    , scope(sco)
+    , sched(sch)
+    {
+    }
+};
+
+struct ThreadFlagsTest
+{
+  enum How {
+    INIT = 0x1, // use constructor initialization
+    ASSIGN = 0x2, // use assignment operator
+    BOTH = 0x3
+  };
+
+  ThreadFlagsTest (const char* sym, How assign, ExpectedValues ev, ExpectedValues which_check);
+
+  // Execute the test and pass back an ExpectedValues struct where the
+  // values are zero if the values were not as expected or non-zero if
+  // they were as expected.  Return value is zero for success, or
+  // the bitmask of the "How" version of the test that failed.
+  int runtest(ExpectedValues& results);
+
+  const char* sym_;
+  How assign_;
+  ExpectedValues expected_values_;
+  ExpectedValues which_results_to_check_;
+
+};
+
+ThreadFlagsTest::ThreadFlagsTest (const char* sym,
+                                  How assign,
+                                  ExpectedValues ev,
+                                  ExpectedValues which_check)
+  : sym_(sym)
+  , assign_(assign)
+  , expected_values_(ev)
+  , which_results_to_check_(which_check)
+{
+}
+
+int
+ThreadFlagsTest::runtest (ExpectedValues& results)
+{
+  int r = 0;
+  if (assign_ & INIT)
+    {
+      TAO_EC_Thread_Flags f(sym_);
+      if ( ((results.flags = f.flags()) == expected_values_.flags) &&
+           ((results.scope = f.scope()) == expected_values_.scope) &&
+           ((results.sched = f.sched()) == expected_values_.sched) )
+        ; // we succeeded, do nothing
+      else
+        r |= INIT;
+    }
+  if (assign_ & ASSIGN)
+    {
+      TAO_EC_Thread_Flags f;
+      f = sym_;
+      if ( ((results.flags = f.flags()) == expected_values_.flags) &&
+           ((results.scope = f.scope()) == expected_values_.scope) &&
+           ((results.sched = f.sched()) == expected_values_.sched) )
+        ; // we succeeded, do nothing
+      else
+        r |= ASSIGN;
+    }
+
+  return r;
+}
+
+// Common things to pass for 'which_check'
+static const ExpectedValues CHECK_ALL(1, 1, 1);
+static const ExpectedValues ONLY_FLAGS(1, 0, 0);
+// ExpectedValues set indicating the default values
+static const ExpectedValues DEFAULTS(0, 0, 0);
+
+void
+print_results (int how, ExpectedValues expected, ExpectedValues actuals)
+{
+  const char* op =
+    (how == ThreadFlagsTest::INIT) ? "INIT" : 
+    (how == ThreadFlagsTest::ASSIGN) ? "ASSIGN" :
+    (how == ThreadFlagsTest::BOTH) ? "BOTH" :
+    "unk?";
+
+  ACE_DEBUG ((LM_DEBUG, "  %s: expected {%x,%x,%x} got {%x,%x,%x}",
+              op,
+              expected.flags, expected.scope, expected.sched,
+              actuals.flags, actuals.scope, actuals.sched));
+}
+
+int
+main (int argc, char* argv[])
+{
+  ThreadFlagsTest static_tests[] = {
+    // Test 1
+    ThreadFlagsTest(0, ThreadFlagsTest::BOTH, DEFAULTS, CHECK_ALL), 
+    // Test 2
+    ThreadFlagsTest("THR_CANCEL_DISABLE", ThreadFlagsTest::BOTH, ExpectedValues(THR_CANCEL_DISABLE), CHECK_ALL),
+    ThreadFlagsTest("THR_CANCEL_ENABLE", ThreadFlagsTest::BOTH, ExpectedValues(THR_CANCEL_ENABLE), CHECK_ALL),
+    ThreadFlagsTest("THR_CANCEL_DEFERRED", ThreadFlagsTest::BOTH, ExpectedValues(THR_CANCEL_DEFERRED), CHECK_ALL),
+    ThreadFlagsTest("THR_CANCEL_ASYNCHRONOUS", ThreadFlagsTest::BOTH, ExpectedValues(THR_CANCEL_ASYNCHRONOUS), CHECK_ALL),
+    ThreadFlagsTest("THR_BOUND", ThreadFlagsTest::BOTH, ExpectedValues(THR_BOUND), CHECK_ALL),
+    ThreadFlagsTest("THR_NEW_LWP", ThreadFlagsTest::BOTH, ExpectedValues(THR_NEW_LWP), CHECK_ALL),
+    ThreadFlagsTest("THR_DETACHED", ThreadFlagsTest::BOTH, ExpectedValues(THR_DETACHED), CHECK_ALL),
+    ThreadFlagsTest("THR_SUSPENDED", ThreadFlagsTest::BOTH, ExpectedValues(THR_SUSPENDED), CHECK_ALL),
+    ThreadFlagsTest("THR_DAEMON", ThreadFlagsTest::BOTH, ExpectedValues(THR_DAEMON), CHECK_ALL),
+    ThreadFlagsTest("THR_JOINABLE", ThreadFlagsTest::BOTH, ExpectedValues(THR_JOINABLE), CHECK_ALL),
+    // Test 3
+    ThreadFlagsTest("THR_SCHED_FIFO", ThreadFlagsTest::BOTH, ExpectedValues(THR_SCHED_FIFO, 0, THR_SCHED_FIFO), CHECK_ALL),
+    ThreadFlagsTest("THR_SCHED_RR", ThreadFlagsTest::BOTH, ExpectedValues(THR_SCHED_RR, 0, THR_SCHED_RR), CHECK_ALL),
+    ThreadFlagsTest("THR_SCHED_DEFAULT", ThreadFlagsTest::BOTH, ExpectedValues(THR_SCHED_DEFAULT, 0, THR_SCHED_DEFAULT), CHECK_ALL),
+    // Test 4
+    ThreadFlagsTest("THR_SCOPE_SYSTEM", ThreadFlagsTest::BOTH, ExpectedValues(THR_SCOPE_SYSTEM, THR_SCOPE_SYSTEM, 0), CHECK_ALL),
+    ThreadFlagsTest("THR_SCOPE_PROCESS", ThreadFlagsTest::BOTH, ExpectedValues(THR_SCOPE_PROCESS, THR_SCOPE_PROCESS, 0), CHECK_ALL),
+    // Test 5
+    ThreadFlagsTest("0x0001", ThreadFlagsTest::BOTH, ExpectedValues(1, 0, 0), CHECK_ALL),
+    // Test 6
+    ThreadFlagsTest("Zaphod|Beeblebrox|THR_BOGUS", ThreadFlagsTest::BOTH, DEFAULTS, CHECK_ALL),
+    // Test 7
+    ThreadFlagsTest("THR_BOUND|THR_JOINABLE", ThreadFlagsTest::BOTH, ExpectedValues(THR_BOUND|THR_JOINABLE), CHECK_ALL),
+    ThreadFlagsTest("THR_SCHED_FIFO|THR_DAEMON|THR_SCOPE_PROCESS", ThreadFlagsTest::BOTH, ExpectedValues(THR_SCHED_FIFO|THR_DAEMON|THR_SCOPE_PROCESS, THR_SCOPE_PROCESS, THR_SCHED_FIFO), CHECK_ALL),
+    ThreadFlagsTest("THR_SCHED_DEFAULT|THR_SCOPE_SYSTEM|THR_NEW_LWP", ThreadFlagsTest::BOTH, ExpectedValues(THR_SCHED_DEFAULT|THR_SCOPE_SYSTEM|THR_NEW_LWP, THR_SCOPE_SYSTEM, THR_SCHED_DEFAULT), CHECK_ALL),
+    ThreadFlagsTest("THR_NEW_LWP|THR_SCOPE_SYSTEM|THR_JOINABLE|THR_SCHED_FIFO",
+                    ThreadFlagsTest::BOTH,
+                    ExpectedValues(THR_NEW_LWP|THR_SCHED_FIFO|THR_SCOPE_SYSTEM|THR_JOINABLE, THR_SCOPE_SYSTEM, THR_SCHED_FIFO),
+                    CHECK_ALL)
+  };
+  
+  int returnval = 0;
+  const size_t numtests = sizeof(static_tests)/sizeof(static_tests[0]);
+  if (argc > 1)
+    {
+      char* which_test;
+      while ((which_test = *++argv))
+        {
+          size_t testnum = ACE_OS_String::strtol (which_test, 0, 0);
+          if (testnum < numtests)
+            {
+              ExpectedValues results;
+              ThreadFlagsTest& t = static_tests[testnum];
+              ACE_DEBUG ((LM_DEBUG, "Test #%d for %s...", testnum, t.sym_));
+              int r = t.runtest (results);
+              if (r != 0)
+                {
+                  returnval = 1;
+                  ACE_DEBUG ((LM_DEBUG, "FAILED -- details: "));
+                  if (r & ThreadFlagsTest::INIT)
+                    print_results (ThreadFlagsTest::INIT, t.expected_values_, results);
+              
+                  if (r & ThreadFlagsTest::ASSIGN)
+                    print_results (ThreadFlagsTest::ASSIGN, t.expected_values_, results);
+          
+                  ACE_DEBUG ((LM_DEBUG, "\n"));
+                }
+              else
+                {
+                  ACE_DEBUG ((LM_DEBUG, "ok.\n"));
+                }
+            }
+          else
+            {
+              ACE_DEBUG ((LM_DEBUG,
+                          "%d is not a valid test number\n", testnum));
+            }
+        }
+    }
+  else
+    {
+      for(size_t i = 0; i < numtests; ++i)
+        {
+          ExpectedValues results;
+          ThreadFlagsTest& t = static_tests[i];
+          ACE_DEBUG ((LM_DEBUG, "Test #%d for %s...", i, t.sym_));
+          int r = t.runtest (results);
+          if (r != 0)
+            {
+              returnval = 1;
+              ACE_DEBUG ((LM_DEBUG, "FAILED -- details: "));
+              if (r & ThreadFlagsTest::INIT)
+                print_results (ThreadFlagsTest::INIT, t.expected_values_, results);
+              
+              if (r & ThreadFlagsTest::ASSIGN)
+                print_results (ThreadFlagsTest::ASSIGN, t.expected_values_, results);
+          
+              ACE_DEBUG ((LM_DEBUG, "\n"));
+            }
+          else
+            {
+              ACE_DEBUG ((LM_DEBUG, "ok.\n"));
+            }
+        }
+
+    }
+
+  return returnval;
+}