testjre.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

//%2006////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; Symantec Corporation; The Open Group.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//==============================================================================
//
//%/////////////////////////////////////////////////////////////////////////////

#include "Convert.h"
#include "JMPIImpl.h"
#include "JMPIProvider.h"

#include <Pegasus/Common/CIMClass.h>
#include <Pegasus/Common/CIMInstance.h>
#include <Pegasus/Common/CIMObjectPath.h>
#include <Pegasus/Common/CIMProperty.h>
#include <Pegasus/Common/CIMParamValue.h>
#include <Pegasus/Config/ConfigManager.h>
#include <Pegasus/Common/FileSystem.h>

PEGASUS_USING_PEGASUS;
PEGASUS_USING_STD;

int trace = 0;

#ifdef PEGASUS_DEBUG
#define DDD(x) if (trace) x;
#else
#define DDD(x)
#endif

#ifdef PEGASUS_OS_TYPE_WINDOWS
static LPCSTR g_cimservice_key  = TEXT("SYSTEM\\CurrentControlSet\\Services\\%s");

static bool _getRegInfo(const char *lpchKeyword, char *lpchRetValue)
{
  HKEY   hKey;
  DWORD  dw                   = _MAX_PATH;
  char   subKey[_MAX_PATH]    = {0};

  sprintf(subKey, g_cimservice_key, "cimserver");

  if ((RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                    subKey,
                    0,
                    KEY_READ,
                    &hKey)) != ERROR_SUCCESS)
    {
      return false;
    }

  if ((RegQueryValueEx(hKey,
                       lpchKeyword,
                       NULL,
                       NULL,
                       (LPBYTE)lpchRetValue,
                       &dw)) != ERROR_SUCCESS)
    {
      RegCloseKey(hKey);
      return false;
    }

  RegCloseKey(hKey);

  return true;
}
#endif

void
printEnvironmentVariables ()
{
   const char *apszEnvVariables[] = {
      "PEGASUS_HOME",
      "PEGASUS_ROOT",
      "PEGASUS_PLATFORM",
      "PEGASUS_DEBUG",
      "PEGASUS_JMPI_TRACE",
      "PATH",
      "LD_LIBRARY_PATH",
      "CLASSPATH",
      "JAVA_SDK",
      "JAVA_SDKINC"
   };

   for (size_t i = 0; i < sizeof (apszEnvVariables)/sizeof (apszEnvVariables[0]); i++)
   {
      const char *pszValue = 0;

      pszValue = getenv (apszEnvVariables[i]);

      if (pszValue)
      {
         printf ("%s = \"%s\"\n", apszEnvVariables[i], pszValue);
      }
      else
      {
         printf ("%s = NULL\n", apszEnvVariables[i]);
      }
   }
}

int testJVM ()
{
   JvmVector  *jv   = NULL;
   JNIEnv     *jEnv = NULL;

   jEnv = JMPIjvm::attachThread (&jv);

   if (!jEnv)
   {
      PEGASUS_STD(cerr)<<"testJVM: FAILURE: Could not attach a thread!"<<PEGASUS_STD(endl);
      return 1;
   }

   jobject jSI8 = jEnv->NewObject (JMPIjvm::jv.ByteClassRef,
                                   JMPIjvm::jv.ByteNewB,
                                   (jbyte)-42);
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Byte" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jSI8)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Byte" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create Byte" << PEGASUS_STD (endl);
   }
   jobject jUI8 = jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,
                                   JMPIjvm::jv.UnsignedInt8NewS,
                                   (jshort)16);
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create UnsignedInt8" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jUI8)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create UnsignedInt8" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create UnsignedInt8" << PEGASUS_STD (endl);
   }
   jobject jSI16 = jEnv->NewObject (JMPIjvm::jv.ShortClassRef,
                                    JMPIjvm::jv.ShortNewS,
                                    (jshort)-1578);
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Short" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jSI16)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Short" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create Short" << PEGASUS_STD (endl);
   }
   jobject jUI16 = jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,
                                    JMPIjvm::jv.UnsignedInt16NewI,
                                    (jint)9831);
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create UnsignedInt16" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jUI16)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create UnsignedInt16" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create UnsignedInt16" << PEGASUS_STD (endl);
   }
   jobject jSI32 = jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,
                                    JMPIjvm::jv.IntegerNewI,
                                    (jint)-45000);
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Integer" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jSI32)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Integer" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create Integer" << PEGASUS_STD (endl);
   }
   jobject jUI32 = jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,
                                    JMPIjvm::jv.UnsignedInt32NewJ,
                                    (jlong)33000);
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create UnsignedInt32" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jUI32)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create UnsignedInt32" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create UnsignedInt32" << PEGASUS_STD (endl);
   }
   jobject jSI64 = jEnv->NewObject (JMPIjvm::jv.LongClassRef,
                                    JMPIjvm::jv.LongNewJ,
                                    (jlong)-4500000);
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Long" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jSI64)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Long" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create Long" << PEGASUS_STD (endl);
   }
   // UnsignedInt64NewBi
   jobject jBiStr = jEnv->NewStringUTF ("1234567890");
   jobject jUI64  = jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,
                                     JMPIjvm::jv.UnsignedInt64NewStr,
                                     jBiStr);
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create UnsignedInt64" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jUI64)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create UnsignedInt64" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create UnsignedInt64" << PEGASUS_STD (endl);
   }
   jobject jStr = jEnv->NewStringUTF ("Hello world");
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create String" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jStr)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create String" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create String" << PEGASUS_STD (endl);
   }
   CIMDateTime *cdt       = new CIMDateTime (String ("20060227183400.000000-360"));
   jlong        jcdt      = DEBUG_ConvertCToJava (CIMDateTime *, jlong, cdt);
   jobject      jDateTime = jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef,
                                             JMPIjvm::jv.CIMDateTimeNewJ,
                                             DEBUG_ConvertJavaToC (jlong, CIMDateTime *, jcdt));
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create CIMDateTime" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jDateTime)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create CIMDateTime" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create CIMDateTime" << PEGASUS_STD (endl);
   }
   jobject jVector = jEnv->NewObject (JMPIjvm::jv.VectorClassRef,
                                      JMPIjvm::jv.VectorNew);
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Vector" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jVector)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Vector" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create Vector" << PEGASUS_STD (endl);
   }
   jobject jBoolean = jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,
                                       JMPIjvm::jv.BooleanNewZ,
                                       (jboolean)true);
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Boolean" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jBoolean)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Boolean" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create Boolean" << PEGASUS_STD (endl);
   }
   jobject jCharacter = jEnv->NewObject (JMPIjvm::jv.CharacterClassRef,
                                         JMPIjvm::jv.CharacterNewC,
                                         (jchar)'A');
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Character" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jCharacter)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Character" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create Character" << PEGASUS_STD (endl);
   }
   jobject jFloat = jEnv->NewObject (JMPIjvm::jv.FloatClassRef,
                                     JMPIjvm::jv.FloatNewF,
                                     (jfloat)3.1415279);
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Float" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jFloat)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Float" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create Float" << PEGASUS_STD (endl);
   }
   jobject jDouble = jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,
                                      JMPIjvm::jv.DoubleNewD,
                                      (jdouble)3.1415279);
   if (jEnv->ExceptionOccurred ())
   {
      DDD(jEnv->ExceptionDescribe ());
      DDD(jEnv->ExceptionClear ());
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Double" << PEGASUS_STD (endl);
      return 1;
   }
   else if (!jDouble)
   {
      PEGASUS_STD (cout) << "testJVM: FAILURE: Create Double" << PEGASUS_STD (endl);
      return 1;
   }
   else
   {
      PEGASUS_STD (cout) << "testJVM: SUCCESS: Create Double" << PEGASUS_STD (endl);
   }
   Sint8 si8CVInit = -8;
   CIMParamValue *cpv          = new CIMParamValue (String ("bob"),
                                                    CIMValue (si8CVInit));