private short?ConvertToObjectItem(string csvItem)
{
var c = new ShortConverter();
Assert.IsTrue(c.TryConvertToObjectItem(CreateConvertToObjectItemContext(csvItem), out object?result, out string _));
return((short?)result);
}
public void ConvertToCsvItemTest()
{
var c = new ShortConverter();
Assert.AreEqual("1000", c.ConvertToCsvItem(CreateConvertToCsvItemContext((short)1000)));
Assert.AreEqual("1,000", c.ConvertToCsvItem(CreateConvertToCsvItemContext((short)1000, "FormattedValue")));
}
public ShortRatingConverter(ShortConverter innerConverter, TimeSpan period) :
base(innerConverter)
{
Period = period;
tokenSource = new CancellationTokenSource();
reportTask = ReportAsync();
}
public void TryConvertToObjectItemRequireTest()
{
var c = new ShortConverter();
var context = CreateConvertToObjectItemContext(string.Empty);
Assert.IsFalse(c.TryConvertToObjectItem(context, out object?_, out string message));
Assert.AreEqual(CsvConfig.Current.ValidationMessage.GetRequiredError(context), message);
}
public void TryConvertToObjectItemFailureTest()
{
var c = new ShortConverter();
var context = CreateConvertToObjectItemContext("x");
Assert.IsFalse(c.TryConvertToObjectItem(context, out object?_, out string message));
Assert.AreEqual(CsvConfig.Current.ValidationMessage.GetNumericConvertError(context), message);
}
public void CanSerializeAndDeserialize()
{
short value = short.MaxValue;
ShortConverter converter = new ShortConverter();
byte[] bytes = converter.Serialize(value);
short valueFromBytes = converter.Deserialize(bytes);
Assert.Equal(valueFromBytes, value);
}
public void SetConverter(ShortConverter converter)
{
if (converter != null)
{
Converter = new ShortRatingConverter(converter);
Converter.RateCalculated += Converter_RateCalculated;
}
else
{
Converter = null;
}
}
public void ShortConverter_CorrectConversionTest()
{
Array[] data = new short[][]
{
new short[] { short.MinValue, short.MaxValue },
new short[] { -30000, 30000 },
};
var converter = new ShortConverter();
var sut = converter.Convert(data, 2, 2);
var expectation = new ushort[] { 0, ushort.MaxValue, 2768, 62768 };
sut.Should().BeEquivalentTo(expectation);
}
public void ValidateReadShort()
{
var val = new ShortConverter(123).GetString("", CultureInfo.CurrentCulture);
Assert.AreEqual("123", val);
}
public void ValidateConvertShortToString()
{
var val = new ShortConverter("123").ConvertToObject("", CultureInfo.CurrentCulture);
Assert.AreEqual((short)123, val);
}
public void Test_ToArray()
{
ushort[] value = ShortConverter.ToArray(IntPtr.Zero, 4);
Assert.Null(value);
}
public OutShortConverter(ShortConverter innerConverter)
{
InnerConverter = innerConverter;
}
/**
* Matches a signature to the MsArg and if the signature matches unpacks the component values of a MsgArg into an object.
* This function resolved through variants, so if the MsgArg is a variant that references a 32 bit integer is can be unpacked
* directly into a 32 bit integer pointer.
*
* - @c 'a' An object containing an array
* - @c 'b' An object containing a bool
* - @c 'd' An object containing a double (64 bits)
* - @c 'g' An object containing a string that represents an AllJoyn signature
* - @c 'h' An object containing a Socket file desciptor
* - @c 'i' An object containing an int
* - @c 'n' An object containing a short
* - @c 'o' An object containing a string that represents the name of an AllJoyn object
* - @c 'q' An object containing a ushort
* - @c 's' An object containing a string
* - @c 't' An object containing a ulong
* - @c 'u' An object containing a uint
* - @c 'v' An object containing a MsgArg
* - @c 'x' An object containing a long
* - @c 'y' An object containing a byte
*
* - @c '(' and @c ')' An object containing a struct
* - @c '{' and @c '}' An object containing the key and value pair of a dictonary
*
* - @c '*' This matches any value type. This should not show up in a signature it is used by AllJoyn for matching
*
* @param sig The signature for MsgArg value
* @param[out] value object to hold the values unpacked from the MsgArg
* @return
* - QStatus.OK if the signature matched and MsgArg was successfully unpacked.
* - QStatus.BUS_SIGNATURE_MISMATCH if the signature did not match.
* - An error status otherwise
*/
//TODO add in examples into the Get documentation
public QStatus Get(string sig, out object value)
{
QStatus status = QStatus.OK;
value = null;
// handle multiple signatures in one get command
if (sig.Length > 1)
{
string[] sigs = splitSignature(sig);
if (sigs.Length > 1)
{
//is the signature larger than the passed in MsgArg?
if (sigs.Length > _length)
{
return AllJoyn.QStatus.BUS_BAD_SIGNATURE;
}
object[] values = new object[sigs.Length];
for (int j = 0; j < sigs.Length; ++j)
{
status = this[j].Get(sigs[j], out values[j]);
if (AllJoyn.QStatus.OK != status)
{
return status;
}
}
value = values;
return status;
}
}
switch ((AllJoynTypeId)sig[0])
{
case AllJoynTypeId.ALLJOYN_BYTE:
byte y;
status = alljoyn_msgarg_get_uint8(_msgArg, out y);
value = y;
break;
case AllJoynTypeId.ALLJOYN_BOOLEAN:
bool b;
status = alljoyn_msgarg_get_bool(_msgArg, out b);
value = b;
break;
case AllJoynTypeId.ALLJOYN_INT16:
short n;
status = alljoyn_msgarg_get_int16(_msgArg, out n);
value = n;
break;
case AllJoynTypeId.ALLJOYN_UINT16:
ushort q;
status = alljoyn_msgarg_get_uint16(_msgArg, out q);
value = q;
break;
case AllJoynTypeId.ALLJOYN_INT32:
int i;
status = alljoyn_msgarg_get_int32(_msgArg, out i);
value = i;
break;
case AllJoynTypeId.ALLJOYN_UINT32:
uint u;
status = alljoyn_msgarg_get_uint32(_msgArg, out u);
value = u;
break;
case AllJoynTypeId.ALLJOYN_INT64:
long x;
status = alljoyn_msgarg_get_int64(_msgArg, out x);
value = x;
break;
case AllJoynTypeId.ALLJOYN_UINT64:
ulong t;
status = alljoyn_msgarg_get_uint64(_msgArg, out t);
value = t;
break;
case AllJoynTypeId.ALLJOYN_DOUBLE:
double d;
status = alljoyn_msgarg_get_double(_msgArg, out d);
value = d;
break;
case AllJoynTypeId.ALLJOYN_STRING:
IntPtr s;
status = alljoyn_msgarg_get_string(_msgArg, out s);
value = Marshal.PtrToStringAnsi(s);
break;
case AllJoynTypeId.ALLJOYN_OBJECT_PATH:
IntPtr o;
status = alljoyn_msgarg_get_objectpath(_msgArg, out o);
value = Marshal.PtrToStringAnsi(o);
break;
case AllJoynTypeId.ALLJOYN_SIGNATURE:
IntPtr g;
status = alljoyn_msgarg_get_signature(_msgArg, out g);
value = Marshal.PtrToStringAnsi(g);
break;
case AllJoynTypeId.ALLJOYN_VARIANT:
IntPtr v;
status = alljoyn_msgarg_get_variant(_msgArg, out v);
if (status)
{
value = new MsgArg(v);
}
break;
case AllJoynTypeId.ALLJOYN_ARRAY:
int length;
switch ((AllJoynTypeId)sig[1])
{
case AllJoynTypeId.ALLJOYN_BYTE:
IntPtr ay;
status = alljoyn_msgarg_get_uint8_array(_msgArg, out length, out ay);
byte[] ay_result = new byte[length];
Marshal.Copy(ay, ay_result, 0, length);
value = ay_result;
break;
case AllJoynTypeId.ALLJOYN_BOOLEAN:
IntPtr ab;
status = alljoyn_msgarg_get_bool_array(_msgArg, out length, out ab);
int[] ab_result = new int[length];
Marshal.Copy(ab, ab_result, 0, length);
bool[] ab_retValue = new bool[length];
for (int j = 0; j < length; j++)
{
if (ab_result[j] == 0)
{
ab_retValue[j] = false;
}
else
{
ab_retValue[j] = true;
}
}
value = ab_retValue;
break;
case AllJoynTypeId.ALLJOYN_INT16:
IntPtr an;
status = alljoyn_msgarg_get_int16_array(_msgArg, out length, out an);
short[] an_result = new short[length];
Marshal.Copy(an, an_result, 0, length);
value = an_result;
break;
case AllJoynTypeId.ALLJOYN_UINT16:
IntPtr aq;
status = alljoyn_msgarg_get_uint16_array(_msgArg, out length, out aq);
short[] aq_result = new short[length];
Marshal.Copy(aq, aq_result, 0, length);
ShortConverter shortConverter = new ShortConverter();
shortConverter.Shorts = aq_result;
value = shortConverter.UShorts;
break;
case AllJoynTypeId.ALLJOYN_INT32:
IntPtr ai;
status = alljoyn_msgarg_get_int32_array(_msgArg, out length, out ai);
int[] ai_result = new int[length];
Marshal.Copy(ai, ai_result, 0, length);
value = ai_result;
break;
case AllJoynTypeId.ALLJOYN_UINT32:
IntPtr au;
status = alljoyn_msgarg_get_uint32_array(_msgArg, out length, out au);
int[] au_result = new int[length];
Marshal.Copy(au, au_result, 0, length);
IntConverter intConverter = new IntConverter();
intConverter.Ints = au_result;
value = intConverter.UInts;
break;
case AllJoynTypeId.ALLJOYN_INT64:
IntPtr ax;
status = alljoyn_msgarg_get_int64_array(_msgArg, out length, out ax);
long[] ax_result = new long[length];
Marshal.Copy(ax, ax_result, 0, length);
value = ax_result;
break;
case AllJoynTypeId.ALLJOYN_UINT64:
IntPtr at;
status = alljoyn_msgarg_get_uint64_array(_msgArg, out length, out at);
long[] at_result = new long[length];
Marshal.Copy(at, at_result, 0, length);
LongConverter longConverter = new LongConverter();
longConverter.Longs = at_result;
value = longConverter.ULongs;
break;
case AllJoynTypeId.ALLJOYN_DOUBLE:
IntPtr ad;
status = alljoyn_msgarg_get_double_array(_msgArg, out length, out ad);
double[] ad_result = new double[length];
Marshal.Copy(ad, ad_result, 0, length);
value = ad_result;
break;
case AllJoynTypeId.ALLJOYN_STRING:
IntPtr sa;
status = alljoyn_msgarg_get_variant_array(_msgArg, "as", out length, out sa);
if (status)
{
string[] as_result = new string[length];
for (int j = 0; j < length; ++j)
{
if (status)
{
IntPtr inner_s;
status = alljoyn_msgarg_get_string(alljoyn_msgarg_array_element(sa, (UIntPtr)j), out inner_s);
as_result[j] = Marshal.PtrToStringAnsi(inner_s);
}
else
{
break;
}
}
value = as_result;
}
break;
case AllJoynTypeId.ALLJOYN_OBJECT_PATH:
IntPtr ao;
status = alljoyn_msgarg_get_variant_array(_msgArg, "ao", out length, out ao);
if (status)
{
string[] ao_result = new string[length];
for (int j = 0; j < length; ++j)
{
if (status)
{
IntPtr inner_o;
status = alljoyn_msgarg_get_objectpath(alljoyn_msgarg_array_element(ao, (UIntPtr)j), out inner_o);
ao_result[j] = Marshal.PtrToStringAnsi(inner_o);
}
else
{
break;
}
}
value = ao_result;
}
break;
case AllJoynTypeId.ALLJOYN_SIGNATURE:
IntPtr ag;
status = alljoyn_msgarg_get_variant_array(_msgArg, "ag", out length, out ag);
if (status)
{
string[] ag_result = new string[length];
for (int j = 0; j < length; ++j)
{
if (status)
{
IntPtr inner_g;
status = alljoyn_msgarg_get_signature(alljoyn_msgarg_array_element(ag, (UIntPtr)j), out inner_g);
ag_result[j] = Marshal.PtrToStringAnsi(inner_g);
}
else
{
break;
}
}
value = ag_result;
}
break;
case AllJoynTypeId.ALLJOYN_VARIANT:
IntPtr av;
status = alljoyn_msgarg_get_variant_array(_msgArg, "av", out length, out av);
if (status)
{
MsgArg av_result = new MsgArg(av);
av_result._length = length;
value = av_result;
}
break;
case AllJoynTypeId.ALLJOYN_DICT_ENTRY_OPEN:
int dict_size = alljoyn_msgarg_get_array_numberofelements(_msgArg);
System.Collections.Generic.Dictionary<object, object> dict = new System.Collections.Generic.Dictionary<object, object>();
// signature of form a{KV} where key is always one letter value
// just must be a complete signature lenght - 1 for K - 2 for 'a{' and '}'
string key_sig = sig.Substring(2, 1);
string value_sig = sig.Substring(3, sig.Length - 4);
if (key_sig == null || value_sig == null)
{
status = AllJoyn.QStatus.BUS_SIGNATURE_MISMATCH;
}
for (int j = 0; j < dict_size; ++j)
{
IntPtr inner_data_ptr;
alljoyn_msgarg_get_array_element(_msgArg, (UIntPtr)j, out inner_data_ptr);
Object actualKey;
Object actualValue;
MsgArg key_MsgArg = new MsgArg(alljoyn_msgarg_getkey(inner_data_ptr));
MsgArg value_MsgArg = new MsgArg(alljoyn_msgarg_getvalue(inner_data_ptr));
key_MsgArg.Get(key_sig, out actualKey);
value_MsgArg.Get(value_sig, out actualValue);
dict.Add(actualKey, actualValue);
}
value = dict;
break;
case AllJoynTypeId.ALLJOYN_STRUCT_OPEN:
int struct_array_size = alljoyn_msgarg_get_array_numberofelements(_msgArg);
MsgArg struct_array = new MsgArg(struct_array_size);
for (int j = 0; j < struct_array_size; ++j)
{
IntPtr struct_array_ptr;
alljoyn_msgarg_get_array_element(_msgArg, (UIntPtr)j, out struct_array_ptr);
AllJoyn.MsgArg tmp = new MsgArg(struct_array_ptr);
struct_array[j] = tmp;
}
value = struct_array;
break;
case AllJoynTypeId.ALLJOYN_ARRAY:
int outer_array_size = alljoyn_msgarg_get_array_numberofelements(_msgArg);
object[] outerArray = new object[outer_array_size];
for (int j = 0; j < outer_array_size; j++)
{
if (status)
{
IntPtr inner_data_ptr;
alljoyn_msgarg_get_array_element(_msgArg, (UIntPtr)j, out inner_data_ptr);
MsgArg tmp = new MsgArg(inner_data_ptr);
string inner_array_sig = Marshal.PtrToStringAnsi(alljoyn_msgarg_get_array_elementsignature(_msgArg, (UIntPtr)j));
status = tmp.Get(inner_array_sig, out outerArray[j]);
}
else
{
break;
}
}
value = outerArray;
break;
default:
status = QStatus.WRITE_ERROR;
break;
}
break;
case AllJoynTypeId.ALLJOYN_STRUCT_OPEN:
if ((AllJoynTypeId)sig[sig.Length - 1] != AllJoynTypeId.ALLJOYN_STRUCT_CLOSE)
{
return AllJoyn.QStatus.BUS_BAD_SIGNATURE;
}
string[] struct_sigs = splitSignature(sig.Substring(1, sig.Length - 2));
if (struct_sigs == null)
{
return AllJoyn.QStatus.BUS_BAD_SIGNATURE;
}
int numMembers = alljoyn_msgarg_getnummembers(_msgArg);
if (numMembers != struct_sigs.Length)
{
return AllJoyn.QStatus.BUS_BAD_SIGNATURE;
}
object[] structObjects = new object[numMembers];
for (int j = 0; j < struct_sigs.Length; ++j)
{
MsgArg arg = new MsgArg(alljoyn_msgarg_getmember(_msgArg, (UIntPtr)j));
status = arg.Get(struct_sigs[j], out structObjects[j]);
if (AllJoyn.QStatus.OK != status)
{
return status;
}
}
value = structObjects;
break;
case AllJoynTypeId.ALLJOYN_DICT_ENTRY_OPEN:
// A dictionary entry must start with 'a' followed by '{'
// if it starts with '{' it is an invalid signature.
status = QStatus.BUS_BAD_SIGNATURE;
break;
default:
status = QStatus.WRITE_ERROR;
break;
}
return status;
}
public FloatToPCMConverter(ShortConverter innerConverter)
: base(innerConverter)
{ }
public ShortSimplifier(ShortConverter innerConverter, int ratio, int frameSize)
: base(innerConverter)
{
Ratio = ratio;
FrameSize = frameSize;
}
public void Test_ToArray()
{
ushort[] value = ShortConverter.ToArray(IntPtr.Zero, 4);
Assert.AreEqual(null, value);
}
public ShortRatingConverter(ShortConverter innerConverter) : this(innerConverter, new TimeSpan(0, 0, 1))
{
}
