public void BadHost()
{
MI_Session badSession;
MI_Instance extendedError = null;
MI_Result res = StaticFixtures.Application.NewSession(null,
"badhost",
MI_DestinationOptions.Null,
MI_SessionCreationCallbacks.Null,
out extendedError,
out badSession);
MIAssert.Succeeded(res, "Expect simple NewSession to succeed");
MI_Operation operation = null;
badSession.TestConnection(0, null, out operation);
bool moreResults;
MI_Result result;
string errorMessage = null;
MI_Instance instance = null;
MI_Instance errorDetails = null;
res = operation.GetInstance(out instance, out moreResults, out result, out errorMessage, out errorDetails);
MIAssert.Succeeded(res, "Expect the GetInstance operation to succeed");
MIAssert.Failed(result, "Expect the actual retrieval to fail");
Assert.True(!String.IsNullOrEmpty(errorMessage), "Expect error message to be available");
res = operation.Close();
MIAssert.Succeeded(res, "Expect to be able to close operation now");
res = badSession.Close(IntPtr.Zero, null);
MIAssert.Succeeded(res, "Expect to be able to close the bad session");
}
internal static MI_Class GetSerializableTestClass()
{
MI_Operation queryOperation;
StaticFixtures.Session.GetClass(MI_OperationFlags.Default, null, SerializableClassNamespace, SerializableClassClassname, null, out queryOperation);
MI_Class classResult;
MI_Result operationResult;
bool moreResults;
string errorMessage;
MI_Instance completionDetails;
MI_Result res = queryOperation.GetClass(out classResult, out moreResults, out operationResult, out errorMessage, out completionDetails);
MIAssert.Succeeded(res);
MIAssert.Succeeded(operationResult);
Assert.False(moreResults);
MI_Class clonedClass;
res = classResult.Clone(out clonedClass);
MIAssert.Succeeded(res);
queryOperation.Close();
return(clonedClass);
}
public void CanDeserializeInstanceWithInternalMOFMethod()
{
var cimClass = this.GetClassDefinition();
var serializedInstance = this.GetSerializedSingleton();
MI_ExtendedArray deserializedArray;
MI_Instance[] instances;
uint bufferRead;
MI_Instance cimErrorDetails;
MI_DeserializerCallbacks callbacks = new MI_DeserializerCallbacks();
var res = this.Deserializer.DeserializeInstanceArray(MI_SerializerFlags.None,
MI_OperationOptions.Null,
callbacks,
serializedInstance,
new MI_Class[] { cimClass },
out bufferRead,
out deserializedArray,
out cimErrorDetails);
MIAssert.Succeeded(res, "Expect to be able to deserialize instance");
instances = deserializedArray.ReadAsManagedPointerArray(MI_Instance.NewFromDirectPtr);
var expectedInstance = this.GetSerializableInstance();
Assert.Equal(1, instances.Length, "Expect only the instance we serialized");
MIAssert.InstancesEqual(expectedInstance, instances[0], "SerializedInstance");
cimClass.Delete();
expectedInstance.Delete();
deserializedArray.Delete();
}
internal MI_Instance GetSerializableInstance()
{
MI_Operation cimInstanceOperation;
this.Session.EnumerateInstances(MI_OperationFlags.Default, null, SerializationTestData.SingletonClassNamespace, SerializationTestData.SingletonClassClassname, true, null, out cimInstanceOperation);
MI_Instance instance;
MI_Instance outInstance;
bool moreResults;
MI_Result operationRes;
MI_Instance completionDetails;
string errorMessage;
var res = cimInstanceOperation.GetInstance(out instance, out moreResults, out operationRes, out errorMessage, out completionDetails);
MIAssert.Succeeded(res);
MIAssert.Succeeded(operationRes);
res = instance.Clone(out outInstance);
MIAssert.Succeeded(res);
while (moreResults)
{
res = cimInstanceOperation.GetInstance(out instance, out moreResults, out operationRes, out errorMessage, out completionDetails);
MIAssert.Succeeded(res);
}
cimInstanceOperation.Close();
return(outInstance);
}
public void CanGetSetOperationOptionsInterval()
{
MI_OperationOptions options;
this.Application.NewOperationOptions(false, out options);
MI_Interval myInterval = new MI_Interval()
{
days = 21,
hours = 2,
seconds = 1
};
var res = options.SetInterval("MyCustomOption", myInterval, MI_OperationOptionsFlags.Unused);
MIAssert.Succeeded(res, "Expect to be able to set an interval");
MI_Interval retrievedInterval;
MI_OperationOptionsFlags retrievedFlags;
UInt32 optionIndex;
res = options.GetInterval("MyCustomOption", out retrievedInterval, out optionIndex, out retrievedFlags);
MIAssert.Succeeded(res, "Expect to be able to get an interval");
MIAssert.MIIntervalsEqual(myInterval, retrievedInterval);
}
internal void VerifyRoundTripInstance()
{
var cimClass = this.GetClassDefinition();
var serializedInstance = this.GetSerializedSingleton();
MI_Instance instance;
uint bufferRead;
MI_Instance cimErrorDetails;
var res = this.Deserializer.DeserializeInstance(MI_SerializerFlags.None,
serializedInstance,
new MI_Class[] { cimClass },
null,
out bufferRead,
out instance,
out cimErrorDetails);
MIAssert.Succeeded(res, "Expect to be able to deserialize instance");
var expectedInstance = this.GetSerializableInstance();
MIAssert.InstancesEqual(expectedInstance, instance, "SerializedInstance");
cimClass.Delete();
instance.Delete();
expectedInstance.Delete();
}
internal MI_Class GetClassDefinition()
{
MI_Operation cimClassOperation;
this.Session.GetClass(MI_OperationFlags.Default, null, SerializationTestData.SingletonClassNamespace, SerializationTestData.SingletonClassClassname, null, out cimClassOperation);
MI_Class cimClass;
MI_Class cimClassOut;
bool moreResults;
MI_Result operationRes;
MI_Instance completionDetails;
string errorMessage;
var res = cimClassOperation.GetClass(out cimClass, out moreResults, out operationRes, out errorMessage, out completionDetails);
MIAssert.Succeeded(res);
MIAssert.Succeeded(operationRes);
Assert.False(moreResults, "Expect no more results after getting named class");
res = cimClass.Clone(out cimClassOut);
MIAssert.Succeeded(res, "Class Clone failed");
cimClassOperation.Close();
return(cimClassOut);
}
public void SimpleEnumerateInstance()
{
MI_Operation operation = null;
this.Session.EnumerateInstances(MI_OperationFlags.MI_OPERATIONFLAGS_DEFAULT_RTTI,
MI_OperationOptions.Null,
TestEnumerateInstanceNamespace,
TestEnumerateInstanceClassName,
false,
null,
out operation);
bool moreResults = true;
MI_Instance clonedInstance = null;
MI_Result secondaryResult;
string errorMessage = null;
MI_Instance instanceOut = null;
MI_Instance errorDetails = null;
var res = operation.GetInstance(out instanceOut, out moreResults, out secondaryResult, out errorMessage, out errorDetails);
MIAssert.Succeeded(res, "Expect the first GetInstance call to succeed");
MIAssert.Succeeded(secondaryResult, "Expect the logical result of the GetInstance call to succeed");
if (!instanceOut.IsNull)
{
res = instanceOut.Clone(out clonedInstance);
MIAssert.Succeeded(res, "Expect the clone to succeed");
}
while (moreResults)
{
res = operation.GetInstance(out instanceOut, out moreResults, out secondaryResult, out errorMessage, out errorDetails);
MIAssert.Succeeded(res, "Expect GetInstance to succeed even if we don't want the result");
MIAssert.Succeeded(secondaryResult, "Expect the logical result of the GetInstance call to succeed even if we don't want the result");
}
res = operation.Close();
MIAssert.Succeeded(res, "Expect operation to close successfully");
string className = null;
res = clonedInstance.GetClassName(out className);
MIAssert.Succeeded(res, "Expect GetClassName to succeed");
Assert.Equal(TestEnumerateInstanceClassName, className, "Expect the class name to be the one we queried");
MI_Value elementValue = null;
MI_Type elementType;
MI_Flags elementFlags;
UInt32 elementIndex;
res = clonedInstance.GetElement(TestEnumerateInstanceStringPropertyName, out elementValue, out elementType, out elementFlags, out elementIndex);
MIAssert.Succeeded(res, "Expect GetElement to succeed");
Assert.Equal(MI_Type.MI_STRING, elementType, "Expect that the property is registered as a string");
Assert.Equal(TestEnumerateInstanceStringPropertyFlags,
elementFlags, "Expect the element flags to also be properly available from the query");
Assert.Equal(TestEnumerateInstanceStringPropertyValue, elementValue.String, "Expect the machine name to have survived the whole journey");
}
public ApplicationFixture()
{
MI_Instance extendedError = null;
MI_Application newApplication;
MI_Result res = MI_Application.Initialize(ApplicationName, out extendedError, out newApplication);
MIAssert.Succeeded(res, "Expect basic application initialization to succeed");
this.Application = newApplication;
}
public NativeSerializerTestsBase(string format)
{
MI_Serializer newSerializer;
MI_Result res = this.Application.NewSerializer(MI_SerializerFlags.None,
format,
out newSerializer);
MIAssert.Succeeded(res, "Expect simple NewSerializer to succeed");
this.Serializer = newSerializer;
}
internal byte[] GetSerializationFromInstanceThunk(Func <MI_Instance> instanceGetter)
{
MI_Instance toSerialize = instanceGetter();
byte[] serializedInstance;
var res = this.Serializer.SerializeInstance(MI_SerializerFlags.None, toSerialize, out serializedInstance);
MIAssert.Succeeded(res);
toSerialize.Delete();
return(serializedInstance);
}
internal byte[] GetSerializationFromClassThunk(Func <MI_Class> classGetter)
{
MI_Class toSerialize = classGetter();
byte[] serializedInstance;
var res = this.Serializer.SerializeClass(MI_SerializerFlags.None, toSerialize, out serializedInstance);
MIAssert.Succeeded(res);
toSerialize.Delete();
return(serializedInstance);
}
internal static MI_Instance CreateBasicSerializableTestInstance()
{
MI_Instance toSerialize;
MI_Result res = StaticFixtures.Application.NewInstance("TestInstance", null, out toSerialize);
MIAssert.Succeeded(res);
MI_Value valueToSerialize = MI_Value.NewDirectPtr();
valueToSerialize.String = "Test string";
res = toSerialize.AddElement("string", valueToSerialize, MI_Type.MI_STRING, MI_Flags.None);
MIAssert.Succeeded(res);
return(toSerialize);
}
public NativeDeserializerTestsBase(string format) : base()
{
this.format = format;
var application = StaticFixtures.Application;
MI_Deserializer newDeserializer = null;
MI_Result res = application.NewDeserializer(MI_SerializerFlags.None,
format,
out newDeserializer);
MIAssert.Succeeded(res);
Assert.NotNull(newDeserializer, "Expect newly created deserializer to be non-null");
this.Deserializer = newDeserializer;
}
public SessionFixture()
{
var application = StaticFixtures.Application;
MI_Session newSession;
MI_Instance extendedError = null;
MI_Result res = application.NewSession(null,
null,
MI_DestinationOptions.Null,
MI_SessionCreationCallbacks.Null,
out extendedError,
out newSession);
MIAssert.Succeeded(res, "Expect simple NewSession to succeed");
this.Session = newSession;
}
public void CanGetNullPropertyOfInstance()
{
var res = this.instance.AddElement("Foo", MI_Value.Null, MI_Type.MI_INSTANCE, MI_Flags.MI_FLAG_NULL);
MIAssert.Succeeded(res);
var cimInstance = new CimInstance(this.instance);
var properties = cimInstance.CimInstanceProperties;
Assert.Equal(1, properties.Count, "Expect 1 property");
var property = properties["Foo"];
Assert.NotNull(property, "Expect property object to be non-null");
Assert.Equal(CimType.Instance, property.CimType, "Expect type to roundtrip correctly");
Assert.Equal(CimFlags.NullValue, property.Flags & CimFlags.NullValue, "Expect to get null value flags");
Assert.Null(property.Value, "Expect property value to be null");
}
public void CanDeserializeInstance()
{
var nativeDeserializerTests = new NativeDeserializerTestsBase(MI_SerializationFormat.MOF);
var classDefinition = nativeDeserializerTests.GetClassDefinition();
var originalInstance = nativeDeserializerTests.GetSerializableInstance();
var serializedRepresentation = nativeDeserializerTests.GetSerializedSingleton();
uint offset = 0;
IEnumerable <CimInstance> outInstances = this.deserializer.DeserializeInstances(serializedRepresentation, ref offset, new CimClass[] { new CimClass(classDefinition) }, null, null);
Assert.NotNull(outInstances, "Expect the result object to be non-null");
List <CimInstance> instanceList = outInstances.ToList();
Assert.Equal(1, instanceList.Count, "Expect only one instance since that's all we serialized");
MIAssert.InstancesEqual(originalInstance, instanceList[0].InstanceHandle, "SerializedInstance");
}
public void ReferenceTypesCanBeUsed()
{
MI_Instance InnerInstance = null;
var res = this.Application.NewInstance("TestClass", MI_ClassDecl.Null, out InnerInstance);
MIAssert.Succeeded(res);
MI_Instance InnerInstance2 = null;
res = this.Application.NewInstance("TestClass", MI_ClassDecl.Null, out InnerInstance2);
MIAssert.Succeeded(res);
try
{
MI_Value innerValue1 = new MI_Value();
innerValue1.String = "This is a property";
res = InnerInstance.AddElement("InnerInstanceProperty1", innerValue1, innerValue1.Type.Value, MI_Flags.MI_FLAG_BORROW);
MIAssert.Succeeded(res);
MI_Value innerValue2 = new MI_Value();
innerValue2.String = "This is another property";
res = InnerInstance.AddElement("InnerInstanceProperty2", innerValue2, innerValue2.Type.Value, MI_Flags.MI_FLAG_BORROW);
MIAssert.Succeeded(res);
MI_Value innerValue3 = new MI_Value();
innerValue3.String = "Still another property";
res = InnerInstance2.AddElement("InnerInstance2Property1", innerValue3, innerValue3.Type.Value, MI_Flags.MI_FLAG_BORROW);
MIAssert.Succeeded(res);
MI_Value innerValue4 = new MI_Value();
innerValue4.String = "Okay, bored now";
res = InnerInstance2.AddElement("InnerInstance2Property2", innerValue4, innerValue4.Type.Value, MI_Flags.MI_FLAG_BORROW);
MIAssert.Succeeded(res);
this.value.Reference = InnerInstance;
this.TestValueRoundtrip();
this.value.ReferenceA = new MI_Instance[] { InnerInstance, InnerInstance2 };
this.TestValueRoundtrip();
}
finally
{
InnerInstance.Delete();
InnerInstance2.Delete();
}
}
public void ValuesNullCanBeUsed()
{
foreach (MI_Type type in Enum.GetValues(typeof(MI_Type)))
{
string propertyName = type.ToString() + "_Null";
var res = this.instance.AddElement(propertyName, MI_Value.Null, type, MI_Flags.MI_FLAG_NULL);
MIAssert.Succeeded(res, "Expect add element to succeed for {0}", propertyName);
MI_Value returnedValue = null;
MI_Type elementType;
MI_Flags elementFlags = 0;
UInt32 elementIndex = 0;
res = instance.GetElement(propertyName, out returnedValue, out elementType, out elementFlags, out elementIndex);
MIAssert.Succeeded(res, "Expect to get element by name");
var testproperty = new TestMIProperty(returnedValue, elementType, elementFlags);
MIAssert.MIPropertiesEqual(new TestMIProperty(this.value, type, MI_Flags.MI_FLAG_NULL), testproperty, propertyName);
}
}
public void CanDeserializeClassWithInternalMOFMethod()
{
var serializedClass = this.GetSerializedClass();
MI_ExtendedArray deserializedArray;
MI_Class[] classes;
uint bufferRead;
MI_Instance cimErrorDetails;
MI_DeserializerCallbacks callbacks = new MI_DeserializerCallbacks();
var res = this.Deserializer.DeserializeClassArray(MI_SerializerFlags.None,
MI_OperationOptions.Null,
callbacks,
serializedClass,
new MI_Class[] {},
null,
null,
out bufferRead,
out deserializedArray,
out cimErrorDetails);
MIAssert.Succeeded(res, "Expect to be able to deserialize instance");
classes = deserializedArray.ReadAsManagedPointerArray(MI_Class.NewFromDirectPtr);
var expectedInstance = this.GetSerializableInstance();
Assert.Equal(1, classes.Length, "Expect only the class we serialized");
MI_Value elementValue;
UInt32 elementIndex;
MI_Type elementType;
MI_Flags elementFlags;
bool valueExists;
string referenceClass;
MI_QualifierSet qualifierSet;
res = classes[0].GetElement(SerializationTestData.SerializableClassStringProperty, out elementValue, out valueExists, out elementType, out referenceClass, out qualifierSet, out elementFlags, out elementIndex);
MIAssert.Succeeded(res, "Expect to be able to get property from deserialized class");
Assert.Equal(MI_Type.MI_STRING, elementType, "Expect the type to be correct");
expectedInstance.Delete();
deserializedArray.Delete();
}
private void TestValueRoundtrip()
{
Assert.True(this.value.Type.HasValue, "Expect value to have a value before calling helper");
string propertyName = this.value.Type.ToString();
var res = this.instance.AddElement(propertyName, this.value, this.value.Type.Value, MI_Flags.MI_FLAG_BORROW);
MIAssert.Succeeded(res, "Expect add element to succeed");
MI_Value returnedValue = null;
MI_Type elementType;
MI_Flags elementFlags = 0;
UInt32 elementIndex = 0;
res = instance.GetElement(propertyName, out returnedValue, out elementType, out elementFlags, out elementIndex);
MIAssert.Succeeded(res, "Expect to get element by name");
var testproperty = new TestMIProperty(returnedValue, elementType, elementFlags);
MIAssert.MIPropertiesEqual(new TestMIProperty(this.value, this.value.Type.Value, MI_Flags.None), testproperty, propertyName);
}
public void CanDeserializeClass()
{
var nativeDeserializer = new NativeDeserializerTestsBase(MI_SerializationFormat.MOF);
var originalClass = SerializationTestData.GetSerializableTestClass();
var serializedRepresentation = nativeDeserializer.GetSerializedClass();
string originalClassName;
var res = originalClass.GetClassName(out originalClassName);
MIAssert.Succeeded(res);
uint offset = 0;
IEnumerable <CimClass> outClasses = this.deserializer.DeserializeClasses(serializedRepresentation, ref offset, new CimClass[0], null, null, null, null);
Assert.NotNull(outClasses, "Expect the result object to be non-null");
List <CimClass> classList = outClasses.ToList();
Assert.Equal(1, classList.Count, "Expect only one class since that's all we serialized");
Assert.Equal(originalClassName, classList[0].CimSystemProperties.ClassName, "Expect class name to survive unscathed at least");
}
public void TestSessionPositive()
{
MI_Operation operation = null;
this.Session.TestConnection(MI_OperationFlags.Default, null, out operation);
bool moreResults;
MI_Result result;
string errorMessage = null;
MI_Instance instance = null;
MI_Instance errorDetails = null;
var res = operation.GetInstance(out instance, out moreResults, out result, out errorMessage, out errorDetails);
MIAssert.Succeeded(res, "Expect GetInstance result to succeed");
MIAssert.Succeeded(result, "Expect actual operation result to be success");
res = operation.Close();
MIAssert.Succeeded(res, "Expect to be able to close completed operation");
}
public void CanGetPrimitivePropertyOfInstance()
{
MI_Value primitiveValue = MI_Value.NewDirectPtr();
primitiveValue.Uint8 = 42;
var res = this.instance.AddElement("Foo", primitiveValue, MI_Type.MI_UINT8, MI_Flags.None);
MIAssert.Succeeded(res);
var cimInstance = new CimInstance(this.instance);
var properties = cimInstance.CimInstanceProperties;
Assert.Equal(1, properties.Count, "Expect 1 property");
var property = properties["Foo"];
Assert.NotNull(property, "Expect property object to be non-null");
Assert.Equal(CimType.UInt8, property.CimType, "Expect type to roundtrip correctly");
Assert.NotEqual(CimFlags.NullValue, property.Flags & CimFlags.NullValue, "Expect to not get null flags");
Assert.Equal <byte>(42, (byte)property.Value, "Expect property value to match original value");
}
internal void VerifyRoundTripClass()
{
var cimClass = this.GetClassDefinition();
var serializedClass = this.GetSerializedClass();
MI_Class deserializedClass;
uint bufferRead;
MI_Instance cimErrorDetails;
var res = this.Deserializer.DeserializeClass(MI_SerializerFlags.None,
serializedClass,
null,
null,
null,
IntPtr.Zero,
IntPtr.Zero,
out bufferRead,
out deserializedClass,
out cimErrorDetails);
MIAssert.Succeeded(res, "Expect to be able to deserialize instance");
MI_Value elementValue;
UInt32 elementIndex;
MI_Type elementType;
MI_Flags elementFlags;
bool valueExists;
string referenceClass;
MI_QualifierSet qualifierSet;
res = deserializedClass.GetElement(SerializationTestData.SerializableClassStringProperty, out elementValue, out valueExists, out elementType, out referenceClass, out qualifierSet, out elementFlags, out elementIndex);
MIAssert.Succeeded(res, "Expect to be able to get property from deserialized class");
Assert.Equal(MI_Type.MI_STRING, elementType, "Expect the type to be correct");
cimClass.Delete();
deserializedClass.Delete();
}
public void SimpleGetClass()
{
MI_Operation operation = null;
this.Session.GetClass(MI_OperationFlags.Default, MI_OperationOptions.Null, TestGetClassNamespace, TestGetClassClassName, null, out operation);
MI_Class classOut;
MI_Class clonedClass = null;
MI_Result result;
string errorMessage = null;
MI_Instance errorDetails = null;
bool moreResults = false;
var res = operation.GetClass(out classOut, out moreResults, out result, out errorMessage, out errorDetails);
MIAssert.Succeeded(res, "Expect the first GetClass call to succeed");
Assert.True(!classOut.IsNull, "Expect retrieved class instance to be non-null");
res = classOut.Clone(out clonedClass);
MIAssert.Succeeded(res, "Expect the clone to succeed");
while (moreResults)
{
MI_Result secondaryResult = MI_Result.MI_RESULT_OK;
res = operation.GetClass(out classOut, out moreResults, out secondaryResult, out errorMessage, out errorDetails);
MIAssert.Succeeded(res, "Expect GetClass to succeed even if we don't want the result");
}
res = operation.Close();
MIAssert.Succeeded(res, "Expect operation to close successfully");
MI_Value elementValue;
UInt32 elementIndex;
MI_Flags elementFlags;
MI_Type elementType;
bool valueExists;
string referenceClass;
MI_QualifierSet propertyQualifierSet;
res = clonedClass.GetElement(TestGetClassPropertyName, out elementValue, out valueExists, out elementType, out referenceClass, out propertyQualifierSet, out elementFlags, out elementIndex);
MIAssert.Succeeded(res, "Expect to see the normal property on the class");
Assert.Equal(MI_Type.MI_STRING, elementType, "Expect the CIM property to have the right type");
Assert.Equal(TestGetClassPropertyFlags, elementFlags, "Expect the CIM property to have the normal flags");
MI_Type miClassQualifierType;
MI_Value miClassQualifierValue;
MI_Flags miClassQualifierFlags;
MI_QualifierSet classQualifierSet;
res = clonedClass.GetClassQualifierSet(out classQualifierSet);
MIAssert.Succeeded(res, "Expect to be able to get class qualifiers set");
UInt32 qualifierIndex;
res = classQualifierSet.GetQualifier("UUID", out miClassQualifierType, out miClassQualifierFlags, out miClassQualifierValue, out qualifierIndex);
MIAssert.Succeeded(res, "Expect to be able to get qualifier information from class");
Assert.Equal(MI_Type.MI_STRING, miClassQualifierType, "Expect qualifier type to be a string");
Assert.True((miClassQualifierFlags & MI_Flags.MI_FLAG_ENABLEOVERRIDE) != 0, "Expect flags to be standard flags");
Assert.Equal(TestGetClassUUID, miClassQualifierValue.String, "Expect UUID of class to be the known UUID");
MI_ParameterSet parameters;
MI_QualifierSet methodQualifierSet;
UInt32 methodIndex;
res = clonedClass.GetMethod(TestGetClassMethodName, out methodQualifierSet, out parameters, out methodIndex);
MIAssert.Succeeded(res, "Expect to be able to get method from class");
UInt32 parameterCount;
res = parameters.GetParameterCount(out parameterCount);
MIAssert.Succeeded(res, "Expect to be able to get count from parameter set");
Assert.Equal(TestGetClassParameterCount, parameterCount, "Expect there to be the documented number of parameters");
MI_Type parameterType;
string parameterReferenceClass;
MI_QualifierSet parameterQualifierSet;
UInt32 parameterIndex;
res = parameters.GetParameter(TestGetClassParameterName, out parameterType, out parameterReferenceClass, out parameterQualifierSet, out parameterIndex);
MIAssert.Succeeded(res, "Expect to be able to get parameter from parameter set");
Assert.Equal(TestGetClassParameterType, parameterType, "Expect parameter type to be the documented type");
Assert.Equal(TestGetClassParameterIndex, parameterIndex, "Expect the power state to be the first parameter");
}
public MIValueTests()
{
var res = this.Application.NewInstance("TestClass", MI_ClassDecl.Null, out this.instance);
MIAssert.Succeeded(res);
}
internal void VerifyRoundtripWithCallback()
{
var cimClass = this.GetClassDefinition();
var serializedInstance = this.GetSerializedSingleton();
MI_Instance instance;
uint bufferRead;
MI_Instance cimErrorDetails;
bool callbackCalled = false;
Exception callbackException = null;
MI_Deserializer.MI_Deserializer_ClassObjectNeeded callback = delegate(
string serverName,
string namespaceName,
string className,
out MI_Class requestedObject
)
{
requestedObject = null;
callbackCalled = true;
try
{
Assert.Null(serverName, "Expect server name to be null because we connected to local host");
// TODO: Verify that this being null is expected where the namespace is root/cimv2
//Assert.Equal(SerializationTestData.SingletonClassNamespace, namespaceName, "Expect namespace to be the namespace of the class");
Assert.Equal(SerializationTestData.SingletonClassClassname, className, "Expect namespace to be the namespace of the class");
}
catch (Exception ex)
{
callbackException = ex;
return(MI_Result.MI_RESULT_FAILED);
}
requestedObject = cimClass;
return(MI_Result.MI_RESULT_OK);
};
var res = this.Deserializer.DeserializeInstance(MI_SerializerFlags.None,
serializedInstance,
new MI_Class[0],
callback,
out bufferRead,
out instance,
out cimErrorDetails);
Assert.True(callbackCalled, "Expect callback to be called");
if (callbackException != null)
{
throw callbackException;
}
MIAssert.Succeeded(res, "Expect to be able to deserialize instance");
var expectedInstance = this.GetSerializableInstance();
MIAssert.InstancesEqual(expectedInstance, instance, "SerializedInstance");
cimClass.Delete();
instance.Delete();
expectedInstance.Delete();
}
public CimInstanceTests()
{
var res = StaticFixtures.Application.NewInstance("TestClass", null, out this.instance);
MIAssert.Succeeded(res);
}
