/// <summary>
/// Sets a custom option
/// </summary>
/// <param name="optionName"></param>
/// <param name="optionValue"></param>
/// <param name="flags"></param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="optionName"/> is <c>null</c></exception>
public void SetDateTime(string optionName, TimeSpan optionValue, UInt32 flags)
{
if (string.IsNullOrWhiteSpace(optionName))
{
throw new ArgumentNullException("optionName");
}
this.AssertNotDisposed();
MI_Datetime dt = new MI_Datetime(optionValue);
MI_Result result = this._subscriptionDeliveryOptionsHandle.SetDateTime(optionName, dt, flags);
CimException.ThrowIfMiResultFailure(result);
}
internal static void MIDatetimesEqual(MI_Datetime expected, MI_Datetime actual)
{
Assert.Equal(expected.isTimestamp, actual.isTimestamp);
if (expected.isTimestamp)
{
Assert.Equal(expected.timestamp.day, actual.timestamp.day, "Expect day to be equal");
Assert.Equal(expected.timestamp.month, actual.timestamp.month, "Expect month to be equal");
Assert.Equal(expected.timestamp.year, actual.timestamp.year, "Expect year to be equal");
Assert.Equal(expected.timestamp.second, actual.timestamp.second, "Expect second to be equal");
Assert.Equal(expected.timestamp.hour, actual.timestamp.hour, "Expect hour to be equal");
Assert.Equal(expected.timestamp.minute, actual.timestamp.minute, "Expect minute to be equal");
Assert.Equal(expected.timestamp.microseconds, actual.timestamp.microseconds, "Expect microseconds to be equal");
}
else
{
MIIntervalsEqual(expected.interval, actual.interval);
}
}
internal static MI_Value ConvertToNativeLayer(object value, CimType cimType)
{
if (value == null)
{
return(null);
}
MI_Value miv = new MI_Value();
var count = 0;
IList arrayOfObjects = null;
if (value.GetType().IsArray)
{
arrayOfObjects = (IList)value;
count = arrayOfObjects.Count;
}
switch (cimType)
{
case CimType.Boolean:
miv.Boolean = Convert.ToBoolean(value, CultureInfo.InvariantCulture);
return(miv);
case CimType.Char16:
miv.Char16 = Convert.ToChar(value, CultureInfo.InvariantCulture);
return(miv);
case CimType.Real32:
miv.Real32 = Convert.ToSingle(value, CultureInfo.InvariantCulture);
return(miv);
case CimType.Real64:
miv.Real64 = Convert.ToDouble(value, CultureInfo.InvariantCulture);
return(miv);
case CimType.SInt16:
miv.Sint16 = Convert.ToInt16(value, CultureInfo.InvariantCulture);
return(miv);
case CimType.SInt32:
miv.Sint32 = Convert.ToInt32(value, CultureInfo.InvariantCulture);
return(miv);
case CimType.SInt64:
miv.Sint64 = Convert.ToInt64(value, CultureInfo.InvariantCulture);
return(miv);
case CimType.SInt8:
miv.Sint8 = Convert.ToSByte(value, CultureInfo.InvariantCulture);
return(miv);
case CimType.String:
if (value is Boolean)
{
miv.String = Convert.ToString(value, CultureInfo.InvariantCulture).ToLower(CultureInfo.InvariantCulture);
return(miv);
}
miv.String = Convert.ToString(value, CultureInfo.InvariantCulture);
return(miv);
case CimType.UInt16:
miv.Uint16 = Convert.ToUInt16(value, CultureInfo.InvariantCulture);
return(miv);
case CimType.UInt32:
miv.Uint32 = Convert.ToUInt32(value, CultureInfo.InvariantCulture);
return(miv);
case CimType.UInt64:
miv.Uint64 = Convert.ToUInt64(value, CultureInfo.InvariantCulture);
return(miv);
case CimType.UInt8:
miv.Uint8 = Convert.ToByte(value, CultureInfo.InvariantCulture);
return(miv);
case CimType.BooleanArray:
if (arrayOfObjects != null)
{
Boolean[] array = new Boolean[count];
for (int i = 0; i < count; i++)
{
array[i] = Convert.ToBoolean(arrayOfObjects[i], CultureInfo.InvariantCulture);
}
miv.BooleanA = array;
return(miv);
}
break;
case CimType.Char16Array:
if (arrayOfObjects != null)
{
Char[] array = new Char[count];
for (int i = 0; i < count; i++)
{
array[i] = Convert.ToChar(arrayOfObjects[i], CultureInfo.InvariantCulture);
}
miv.Char16A = array;
return(miv);
}
break;
case CimType.Real32Array:
if (arrayOfObjects != null)
{
Single[] array = new Single[count];
for (int i = 0; i < count; i++)
{
array[i] = Convert.ToSingle(arrayOfObjects[i], CultureInfo.InvariantCulture);
}
miv.Real32A = array;
return(miv);
}
break;
case CimType.Real64Array:
if (arrayOfObjects != null)
{
Double[] array = new Double[count];
for (int i = 0; i < count; i++)
{
array[i] = Convert.ToDouble(arrayOfObjects[i], CultureInfo.InvariantCulture);
}
miv.Real64A = array;
return(miv);
}
break;
case CimType.SInt16Array:
if (arrayOfObjects != null)
{
Int16[] array = new Int16[count];
for (int i = 0; i < count; i++)
{
array[i] = Convert.ToInt16(arrayOfObjects[i], CultureInfo.InvariantCulture);
}
miv.Sint16A = array;
return(miv);
}
break;
case CimType.SInt32Array:
if (arrayOfObjects != null)
{
Int32[] array = new Int32[count];
for (int i = 0; i < count; i++)
{
array[i] = Convert.ToInt32(arrayOfObjects[i], CultureInfo.InvariantCulture);
}
miv.Sint32A = array;
return(miv);
}
break;
case CimType.SInt64Array:
if (arrayOfObjects != null)
{
Int64[] array = new Int64[count];
for (int i = 0; i < count; i++)
{
array[i] = Convert.ToInt64(arrayOfObjects[i], CultureInfo.InvariantCulture);
}
miv.Sint64A = array;
return(miv);
}
break;
case CimType.SInt8Array:
if (arrayOfObjects != null)
{
SByte[] array = new SByte[count];
for (int i = 0; i < count; i++)
{
array[i] = Convert.ToSByte(arrayOfObjects[i], CultureInfo.InvariantCulture);
}
miv.Sint8A = array;
return(miv);
}
break;
case CimType.StringArray:
if (arrayOfObjects != null)
{
String[] array = new String[count];
for (int i = 0; i < count; i++)
{
if (arrayOfObjects[i] is Boolean)
{
array[i] = Convert.ToString(arrayOfObjects[i], CultureInfo.InvariantCulture).ToLower(CultureInfo.InvariantCulture);
}
else
{
array[i] = Convert.ToString(arrayOfObjects[i], CultureInfo.InvariantCulture);
}
}
miv.StringA = array;
return(miv);
}
break;
case CimType.UInt16Array:
if (arrayOfObjects != null)
{
UInt16[] array = new UInt16[count];
for (int i = 0; i < count; i++)
{
array[i] = Convert.ToUInt16(arrayOfObjects[i], CultureInfo.InvariantCulture);
}
miv.Uint16A = array;
return(miv);
}
break;
case CimType.UInt32Array:
if (arrayOfObjects != null)
{
UInt32[] array = new UInt32[count];
for (int i = 0; i < count; i++)
{
array[i] = Convert.ToUInt32(arrayOfObjects[i], CultureInfo.InvariantCulture);
}
miv.Uint32A = array;
return(miv);
}
break;
case CimType.UInt64Array:
if (arrayOfObjects != null)
{
UInt64[] array = new UInt64[count];
for (int i = 0; i < count; i++)
{
array[i] = Convert.ToUInt64(arrayOfObjects[i], CultureInfo.InvariantCulture);
}
miv.Uint64A = array;
return(miv);
}
break;
case CimType.UInt8Array:
if (arrayOfObjects != null)
{
Byte[] array = new Byte[count];
for (int i = 0; i < count; i++)
{
array[i] = Convert.ToByte(arrayOfObjects[i], CultureInfo.InvariantCulture);
}
miv.Uint8A = array;
return(miv);
}
break;
case CimType.DateTime:
miv.Datetime = MI_Datetime.ConvertToDateTime(value);
return(miv);
case CimType.DateTimeArray:
if (arrayOfObjects != null)
{
MI_Datetime[] array = new MI_Datetime[count];
for (int i = 0; i < count; i++)
{
array[i] = MI_Datetime.ConvertToDateTime(arrayOfObjects[i]);
}
miv.DatetimeA = array;
return(miv);
}
var arrayOfDateTime = value as DateTime[];
if (arrayOfDateTime != null)
{
MI_Datetime[] array = new MI_Datetime[arrayOfDateTime.Length];
for (int i = 0; i < arrayOfDateTime.Length; i++)
{
array[i] = MI_Datetime.ConvertToDateTime(arrayOfDateTime[i]);
}
miv.DatetimeA = array;
return(miv);
}
var arrayOfTimeSpan = value as TimeSpan[];
if (arrayOfTimeSpan != null)
{
MI_Datetime[] array = new MI_Datetime[arrayOfTimeSpan.Length];
for (int i = 0; i < arrayOfTimeSpan.Length; i++)
{
array[i] = MI_Datetime.ConvertToDateTime(arrayOfTimeSpan[i]);
}
miv.DatetimeA = array;
return(miv);
}
return(miv);
case CimType.Unknown:
miv.String = "UnknownType";
return(miv);
case CimType.Reference:
case CimType.ReferenceArray:
case CimType.Instance:
case CimType.InstanceArray:
default:
break;
}
return(miv);
}
internal static void MIPropertiesEqual(TestMIProperty expectedProperty, TestMIProperty actualProperty, string propertyName)
{
// Note that we do not check the flags - the behavior is too inconsistent across scenarios to be worth
// the current amount of effort, and it's not a marshalling issue
Assert.Equal(expectedProperty.Type, actualProperty.Type, "Expect the property types to be the same");
if ((expectedProperty.Flags & MI_Flags.MI_FLAG_NULL) != 0)
{
return;
}
if (expectedProperty.Type == MI_Type.MI_DATETIME)
{
MI_Datetime expected = (MI_Datetime)expectedProperty.Value;
var actual = (MI_Datetime)actualProperty.Value;
if (expected.isTimestamp)
{
MIAssert.MIDatetimesEqual(expected, actual);
}
}
else if (expectedProperty.Type == MI_Type.MI_DATETIMEA)
{
MI_Datetime[] expected = (MI_Datetime[])expectedProperty.Value;
var actual = (MI_Datetime[])actualProperty.Value;
Assert.Equal(expected.Length, actual.Length, "Expect the MI_DATETIME arrays to be of the same length");
for (int i = 0; i < expected.Length; i++)
{
MIAssert.MIDatetimesEqual(expected[i], (MI_Datetime)actual[i]);
}
}
else if (expectedProperty.Type == MI_Type.MI_INSTANCE || expectedProperty.Type == MI_Type.MI_REFERENCE)
{
MI_Instance expected = (MI_Instance)expectedProperty.Value;
MI_Instance actual = actualProperty.Value as MI_Instance;
MIAssert.InstancesEqual(expected, actual, propertyName);
}
else if (expectedProperty.Type == MI_Type.MI_INSTANCEA || expectedProperty.Type == MI_Type.MI_REFERENCEA)
{
MI_Instance[] expectedArray = (MI_Instance[])expectedProperty.Value;
MI_Instance[] actualArray = actualProperty.Value as MI_Instance[];
Assert.Equal(expectedArray.Length, actualArray.Length, "Expect instance/reference arrays to have the same length");
for (int j = 0; j < expectedArray.Length; j++)
{
MI_Instance expected = expectedArray[j];
MI_Instance actual = actualArray[j];
uint expectedElementCount;
expected.GetElementCount(out expectedElementCount);
uint actualElementCount;
actual.GetElementCount(out actualElementCount);
Assert.Equal(expectedElementCount, actualElementCount, "Expect the instance/references arrays to be of the same length");
for (uint i = 0; i < expectedElementCount; i++)
{
MI_Flags expectedElementFlags;
MI_Value expectedElementValue = null;
MI_Type expectedElementType;
string expectedElementName = null;
expected.GetElementAt(i, out expectedElementName, out expectedElementValue, out expectedElementType, out expectedElementFlags);
MI_Flags actualElementFlags;
MI_Value actualElementValue = null;
MI_Type actualElementType;
string actualElementName = null;
actual.GetElementAt(i, out actualElementName, out actualElementValue, out actualElementType, out actualElementFlags);
Assert.Equal(expectedElementName, actualElementName, "Expect the element names to be the same within the instances");
MIAssert.MIPropertiesEqual(new TestMIProperty(expectedElementValue, expectedElementType, expectedElementFlags),
new TestMIProperty(actualElementValue, actualElementType, actualElementFlags), propertyName);
}
}
}
else if ((expectedProperty.Type & MI_TypeFlags.MI_ARRAY) == MI_TypeFlags.MI_ARRAY)
{
ICollection collectionValue = actualProperty.Value as ICollection;
Assert.NotNull(collectionValue, "Expect the property value to be an ICollection since it was an MI_ARRAY");
Assert.Equal(expectedProperty.Value as ICollection, collectionValue);
}
else
{
Assert.Equal(expectedProperty.Value, actualProperty.Value, "Expect the simple MI property values to match");
}
}
