public unsafe void QueueEvent(IntPtr ptr)
{
var eventPtr = (InputEvent *)ptr;
var eventSize = eventPtr->sizeInBytes;
var alignedEventSize = NumberHelpers.AlignToMultiple(eventSize, 4);
lock (m_Lock)
{
eventPtr->eventId = m_NextEventId;
++m_NextEventId;
// Enlarge buffer, if we have to.
if ((m_EventWritePosition + alignedEventSize) > m_EventBuffer.Length)
{
var newBufferSize = m_EventBuffer.Length + Mathf.Max((int)alignedEventSize, 1024);
var newBuffer = new NativeArray <byte>(newBufferSize, Allocator.Persistent);
UnsafeUtility.MemCpy(newBuffer.GetUnsafePtr(), m_EventBuffer.GetUnsafePtr(), m_EventWritePosition);
m_EventBuffer.Dispose();
m_EventBuffer = newBuffer;
}
// Copy event.
UnsafeUtility.MemCpy((byte *)m_EventBuffer.GetUnsafePtr() + m_EventWritePosition, ptr.ToPointer(), eventSize);
m_EventWritePosition += (int)alignedEventSize;
++m_EventCount;
}
}
/// <summary>
/// Advance the read position to the next event in the buffer, preserving or not preserving the
/// current event depending on <paramref name="leaveEventInBuffer"/>.
/// </summary>
/// <param name="currentReadPos"></param>
/// <param name="currentWritePos"></param>
/// <param name="numEventsRetainedInBuffer"></param>
/// <param name="numRemainingEvents"></param>
/// <param name="leaveEventInBuffer"></param>
/// <remarks>
/// This method MUST ONLY BE CALLED if the current event has been fully processed. If the at <paramref name="currentWritePos"/>
/// is smaller than the current event, then this method will OVERWRITE parts or all of the current event.
/// </remarks>
internal void AdvanceToNextEvent(ref InputEvent *currentReadPos,
ref InputEvent *currentWritePos, ref int numEventsRetainedInBuffer,
ref int numRemainingEvents, bool leaveEventInBuffer)
{
Debug.Assert(Contains(currentReadPos));
Debug.Assert(Contains(currentWritePos));
Debug.Assert(currentReadPos >= currentWritePos);
// Get new read position *before* potentially moving the current event so that we don't
// end up overwriting the data we need to find the next event in memory.
var newReadPos = currentReadPos;
if (numRemainingEvents > 1)
{
newReadPos = InputEvent.GetNextInMemoryChecked(currentReadPos, ref this);
}
// If the current event should be left in the buffer, advance write position.
if (leaveEventInBuffer)
{
// Move down in buffer if read and write pos have deviated from each other.
var numBytes = currentReadPos->sizeInBytes;
if (currentReadPos != currentWritePos)
{
UnsafeUtility.MemMove(currentWritePos, currentReadPos, numBytes);
}
currentWritePos = (InputEvent *)((byte *)currentWritePos + NumberHelpers.AlignToMultiple(numBytes, 4));
++numEventsRetainedInBuffer;
}
currentReadPos = newReadPos;
--numRemainingEvents;
}
public void GetSumOfDigitsTest2()
{
var number = "1234";
var sum = NumberHelpers.GetSumOfDigits(number);
Assert.AreEqual(10, sum);
}
public void InvalidUpdateSystemField(FieldType fieldType, string fieldName, CreateUpdateTestData.InvalidProperty invalidValue)
{
var fieldHandler = new FieldManager();
var fieldResponse = fieldHandler.GetFieldDetails(fieldName);
PrAssume.That(fieldResponse, PrIs.SuccessfulResponse(), $"Cannot read field {fieldName}");
var properties = new Dictionary <string, object>();
var deletedField = UuidUtil.GetId(PreparedDeletedFieldId.Data[CommonHelpers.Resources.FirstOrDefault()]);
var deletedOption = PreparedDeletedOptionId.Data;
CreateUpdateTestData.InvalidPropertyValueMapper[invalidValue](properties, deletedField, deletedOption);
var updateParam = new Dictionary <string, object>
{
[Properties.Parameters.Resource.GetEnumStringValue()] = fieldName.Split('.')[0].ToLower(),
[Properties.Parameters.Properties.GetEnumStringValue()] = properties
};
var request = NumberHelpers.GenerateRequestUpdate(fieldResponse.Result.Values.Keys.First().ToString(), updateParam);
var handler = new DefaultManager();
var response = handler.Send <object>(FieldManager.FieldHandlingRelativeUrl, request.ToJson(), HttpMethod.PUT);
if (fieldType == FieldType.Telephone && invalidValue == CreateUpdateTestData.InvalidProperty.TelWithString)
{
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.NoContent), "Not able update Field");
}
else
if (fieldType == FieldType.Mail && (invalidValue == CreateUpdateTestData.InvalidProperty.MailWithout || invalidValue == CreateUpdateTestData.InvalidProperty.MailWithoutDomain || invalidValue == CreateUpdateTestData.InvalidProperty.MailWithoutDot || invalidValue == CreateUpdateTestData.InvalidProperty.MailWithoutName || invalidValue == CreateUpdateTestData.InvalidProperty.LeadingDot))
{
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.NoContent), "Not able update Field");
}
else
{
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest), "Still able update Field");
}
}
/// <summary>
/// Get the next event after the given one.
/// </summary>
/// <param name="currentPtr">A valid event pointer.</param>
/// <returns>Pointer to the next event in memory.</returns>
/// <remarks>
/// This method applies no checks and must only be called if there is an event following the
/// given one. Also, the size of the given event must be 100% as the method will simply
/// take the size and advance the given pointer by it (and aligning it to <see cref="kAlignment"/>).
/// </remarks>
/// <seealso cref="GetNextInMemoryChecked"/>
internal static unsafe InputEvent *GetNextInMemory(InputEvent *currentPtr)
{
Debug.Assert(currentPtr != null);
var alignedSizeInBytes = NumberHelpers.AlignToMultiple(currentPtr->sizeInBytes, kAlignment);
return((InputEvent *)((byte *)currentPtr + alignedSizeInBytes));
}
public void InvalidInjectionCreateFieldSpecial(Enum param, Enums.InvalidInjection invalidInjection)
{
string parameter = param.GetEnumStringValue();
var properties = NumberHelpers.GenerateRequiredProperties((int)FieldType.Number, Properties.Label.Max);
if (param.GetType() == typeof(Properties.PropertyName))
{
properties[parameter] = MapperData.InvalidInjectionMapper[invalidInjection];
}
var handler = new DefaultManager();
var createParam = GenerateCreateParam(properties);
createParam.Remove(Properties.Parameters.Alias.GetEnumStringValue());
if (param.GetEnumStringValue() != Properties.Parameters.Create.GetEnumStringValue() && param.GetType() == typeof(Properties.Parameters))
{
createParam[parameter] = MapperData.InvalidInjectionMapper[invalidInjection];
}
var request = GenerateCreateRequest(createParam);
if (param.GetEnumStringValue() == Properties.Parameters.Create.GetEnumStringValue())
{
request[parameter] = MapperData.InvalidInjectionMapper[invalidInjection];
}
var response = handler.Send <FieldCreateResponse>(FieldManager.FieldHandlingRelativeUrl, request.ToJson(), HttpMethod.POST);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest), "Still able Create Field");
}
public MiningResult AttemptMineNewCoin()
{
int candidate = NumberHelpers.GenerateRandomNumber(0, 1000);
bool success = _mathService.IsPrime(candidate);
if (!success)
{
return(new MiningResult()
{
CoinCreated = false
});
}
else
{
var newCoin = new Coin()
{
CreationDate = DateTime.Now, Id = Guid.NewGuid()
};
return(new MiningResult()
{
CoinCreated = true, NewCoin = newCoin
});
}
}
public void InvalidCreateFieldSpecial(Enum param, MapperData.Invalid invalidValue)
{
string parameter = param.GetEnumStringValue();
var properties = NumberHelpers.GenerateRequiredProperties((int)FieldType.Number, Properties.Label.Max);
if (param.GetType() == typeof(Properties.PropertyName))
{
CreateUpdateTestData.InvalidMapperValue[invalidValue](properties, parameter);
}
var handler = new DefaultManager();
var createParam = GenerateCreateParam(properties);
CommonMapperValue.AliasMapperValue[Properties.Alias.Max](createParam);
CreateUpdateTestData.InjectInvalidValue(parameter, createParam, invalidValue);
var request = GenerateCreateRequest(createParam);
CreateUpdateTestData.InjectInvalidValue(parameter, request, invalidValue);
var response = handler.Send <FieldCreateResponse>(FieldManager.FieldHandlingRelativeUrl, request.ToJson(), HttpMethod.POST);
if (param.GetEnumStringValue() == Properties.PropertyName.Label.GetEnumStringValue() && invalidValue == MapperData.Invalid.SpecialChars)
{
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Not able Create Field");
}
else if ((param.GetEnumStringValue() == Properties.PropertyName.Caption.GetEnumStringValue() && (invalidValue == MapperData.Invalid.StringEmpty || invalidValue == MapperData.Invalid.Missing || invalidValue == MapperData.Invalid.SpecialChars)) ||
(param.GetEnumStringValue().ContainsStrings(new[] { Properties.PropertyName.Caption, Properties.PropertyName.Search, Properties.PropertyName.Match, Properties.PropertyName.Web, Properties.PropertyName.Highlight, Properties.PropertyName.Require }.Select(e => e.GetEnumStringValue()).ToArray()) && (invalidValue == MapperData.Invalid.Missing)) ||
(param.GetEnumStringValue() == Properties.PropertyName.SType.GetEnumStringValue() && invalidValue == MapperData.Invalid.PositiveNumberWithPlusSign) ||
(param.GetEnumStringValue() == Properties.PropertyName.Default.GetEnumStringValue() && invalidValue == MapperData.Invalid.StringEmpty))
{
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Not able Create Field");
}
else
{
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest), "Still able Create Field");
}
}
public void ValidCreateFieldOptionalProperties(ResourceId resourceId, Properties.Alias alias, Properties.Caption caption, Properties.Search search, Properties.Match match, Properties.Web web, Properties.Highlight highlight, Properties.Require require, Properties.Default defaultProperty, Properties.Min min, Properties.Max max, Properties.Scale scale)
{
var handler = new DefaultManager();
var properties = NumberHelpers.GenerateProperties(NumberFieldTestData.NumberFieldType, Properties.Label.Max, caption, search, match, highlight, require, defaultProperty, min, max, scale);
var createParam = new Dictionary <string, object>
{
[Properties.Parameters.Resource.GetEnumStringValue()] = resourceId.ToString().ToLower(),
[Properties.Parameters.Alias.GetEnumStringValue()] = "",
[Properties.Parameters.Properties.GetEnumStringValue()] = properties
};
CommonMapperValue.AliasMapperValue[alias](createParam);
var request = new Dictionary <string, object>
{
[Properties.Parameters.Create.GetEnumStringValue()] = createParam
}.ToJson();
PrAssert.That(request, PrIs.Not.EqualTo(string.Empty));
var response = handler.Send <FieldCreateResponse>(FieldManager.FieldHandlingRelativeUrl, request, HttpMethod.POST);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not Create Field");
var fieldHandler = new FieldManager();
var readResponse = fieldHandler.GetFieldDetails(response.Result.Id);
CommonHelpers.DeleteField(new[] { response.Result.Id });
PrAssert.That(readResponse, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not Read Field");
PrAssert.That(readResponse.Result.Values.Count, PrIs.EqualTo(1), "Can not read Field");
PrAssert.That(readResponse.Result.Values.First().Value.Properties[Properties.PropertyName.SType.GetEnumStringValue()], PrIs.EqualTo($"{NumberFieldTestData.NumberFieldType}"), "Not as expected s.type");
PrAssert.That(readResponse.Result.Values.First().Value.Properties[Properties.PropertyName.Label.GetEnumStringValue()], PrIs.EqualTo(CommonMapperValue.LabelMapperValue[Properties.Label.Max]), "Not as expected d.label.ja");
NumberHelpers.VerifyProperties(readResponse.Result.Values.First().Value.Properties, properties);
}
// Compute the total size of we need for a single state buffer to encompass
// all devices we have and also linearly assign offsets to all the devices
// within such a buffer.
private static uint ComputeSizeOfSingleBufferAndOffsetForEachDevice(InputDevice[] devices, int deviceCount, ref uint[] offsets)
{
if (devices == null)
{
return(0);
}
var result = new uint[deviceCount];
var currentOffset = 0u;
var sizeInBytes = 0u;
for (var i = 0; i < deviceCount; ++i)
{
var size = devices[i].m_StateBlock.alignedSizeInBytes;
size = NumberHelpers.AlignToMultiple(size, 4);
////REVIEW: what should we do about this case? silently accept it and just give the device the current offset?
if (size == 0)
{
throw new Exception(string.Format("Device '{0}' has a zero-size state buffer", devices[i]));
}
sizeInBytes += size;
result[i] = currentOffset;
currentOffset += (uint)size;
}
offsets = result;
return(sizeInBytes);
}
// Compute the total size of we need for a single state buffer to encompass
// all devices we have and also linearly assign offsets to all the devices
// within such a buffer.
private static uint ComputeSizeOfSingleBufferAndOffsetForEachDevice(InputDevice[] devices, int deviceCount, ref uint[] offsets)
{
if (devices == null)
{
return(0);
}
var result = new uint[deviceCount];
var sizeInBytes = 0u;
for (var i = 0; i < deviceCount; ++i)
{
var sizeOfDevice = devices[i].m_StateBlock.alignedSizeInBytes;
sizeOfDevice = NumberHelpers.AlignToMultiple(sizeOfDevice, 4);
if (sizeOfDevice == 0) // Shouldn't happen as we don't allow empty layouts but make sure we catch this if something slips through.
{
throw new Exception($"Device '{devices[i]}' has a zero-size state buffer");
}
result[i] = sizeInBytes;
sizeInBytes += sizeOfDevice;
}
offsets = result;
return(sizeInBytes);
}
static public void Run()
{
Link.CreatedEvent += LinkCreated;
Link x = Net.CreateThing();
Link number = NumberHelpers.FromNumber(4637694687);
return;
do
{
Console.Write("-> ");
string readMessage = Console.ReadLine();
if (string.Compare("exit", readMessage, ignoreCase: true) == 0)
{
break;
}
Console.Write("<- ");
Console.WriteLine(readMessage);
}while (true);
}
public void InvalidUpdateFieldSpecial(Enum param, MapperData.Invalid invalidValue)
{
string fieldUUID = PreparedFieldId.Data[ResourceId.Client].ToString();
string parameter = param.GetEnumStringValue() == Properties.Parameters.Guid.GetEnumStringValue() ? fieldUUID : param.GetEnumStringValue();
var handler = new DefaultManager();
var properties = NumberHelpers.GenerateRequiredProperties((int)FieldType.Number, Properties.Label.Min);
if (param.GetType() == typeof(Properties.PropertyName))
{
CreateUpdateTestData.InvalidMapperValue[invalidValue](properties, parameter);
}
var updateParam = NumberHelpers.GenerateUpdateParam(ResourceId.Client, properties);
CreateUpdateTestData.InjectInvalidValue(parameter, updateParam, invalidValue);
var idParam = new Dictionary <string, object>
{
[fieldUUID] = updateParam
};
CreateUpdateTestData.InjectInvalidValue(parameter, idParam, invalidValue);
var request = new Dictionary <string, object>
{
[Properties.Parameters.Update.GetEnumStringValue()] = idParam
};
CreateUpdateTestData.InjectInvalidValue(parameter, request, invalidValue);
var response = handler.Send <object>(FieldManager.FieldHandlingRelativeUrl, request.ToJson(), HttpMethod.PUT);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest), "Still able update Field");
}
public void SumOfDigits()
{
var number = BigInteger.Pow(2, 1000).ToString();
var sum = NumberHelpers.GetSumOfDigits(number);
Assert.AreEqual(1366, sum);
}
// Allocates all buffers to serve the given updates and comes up with a spot
// for the state block of each device. Returns the new state blocks for the
// devices (it will *NOT* install them on the devices).
public unsafe uint[] AllocateAll(InputUpdateType updateMask, InputDevice[] devices)
{
uint[] newDeviceOffsets = null;
sizePerBuffer = ComputeSizeOfSingleBufferAndOffsetForEachDevice(devices, ref newDeviceOffsets);
if (sizePerBuffer == 0)
{
return(null);
}
sizePerBuffer = NumberHelpers.AlignToMultiple(sizePerBuffer, 4);
var isDynamicUpdateEnabled = (updateMask & InputUpdateType.Dynamic) == InputUpdateType.Dynamic;
var isFixedUpdateEnabled = (updateMask & InputUpdateType.Fixed) == InputUpdateType.Fixed;
// Determine how much memory we need.
var deviceCount = devices.Length;
var mappingTableSizePerBuffer = (uint)(deviceCount * sizeof(void *) * 2);
if (isDynamicUpdateEnabled)
{
totalSize += sizePerBuffer * 2;
totalSize += mappingTableSizePerBuffer;
}
if (isFixedUpdateEnabled)
{
totalSize += sizePerBuffer * 2;
totalSize += mappingTableSizePerBuffer;
}
// Before render doesn't have its own buffers.
#if UNITY_EDITOR
totalSize += sizePerBuffer * 2;
totalSize += mappingTableSizePerBuffer;
#endif
// Allocate.
m_AllBuffers = (IntPtr)UnsafeUtility.Malloc(totalSize, 4, Allocator.Persistent);
UnsafeUtility.MemClear(m_AllBuffers.ToPointer(), totalSize);
// Set up device to buffer mappings.
var ptr = m_AllBuffers;
if (isDynamicUpdateEnabled)
{
m_DynamicUpdateBuffers =
SetUpDeviceToBufferMappings(devices, ref ptr, sizePerBuffer, mappingTableSizePerBuffer);
}
if (isFixedUpdateEnabled)
{
m_FixedUpdateBuffers =
SetUpDeviceToBufferMappings(devices, ref ptr, sizePerBuffer, mappingTableSizePerBuffer);
}
#if UNITY_EDITOR
m_EditorUpdateBuffers =
SetUpDeviceToBufferMappings(devices, ref ptr, sizePerBuffer, mappingTableSizePerBuffer);
#endif
return(newDeviceOffsets);
}
public void MainTest()
{
BigInteger a = 1;
for (var i = 2; i <= 100; i++)
{
a = BigInteger.Multiply(a, i);
}
Assert.AreEqual(648, NumberHelpers.GetSumOfDigits(a.ToString()));
}
public void InvalidSpecialCreateFieldSpecial(ResourceId resourceId)
{
var properties = NumberHelpers.GenerateRequiredProperties((int)FieldType.Number, Properties.Label.Max);
var handler = new DefaultManager();
var createParam = GenerateCreateParam(properties);
var request = GenerateCreateRequest(createParam);
var response = handler.Send <FieldCreateResponse>(FieldManager.FieldHandlingRelativeUrl, request.ToJson(), HttpMethod.POST);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest), "Still able Create Field");
}
public void InvalidCreateFieldSpecial(ResourceId resource, NumberHelpers.InvalidCreateField invalidCreateField)
{
var handler = new FieldManager();
var properties = NumberHelpers.GenerateRequiredProperties(NumberFieldTestData.NumberFieldType, Properties.Label.Max);
NumberHelpers.InvalidCreateMapperValue[invalidCreateField](properties);
var response = handler.CreateField(resource, properties);
PrAssert.That(response, PrIs.ErrorResponse().And.HttpCode(System.Net.HttpStatusCode.BadRequest), "Still able Create Field");
}
public void Utilities_NumberHelpers_CanConvertUIntToNormalizedFloatAndBack(uint value, uint minValue, uint maxValue, float expected)
{
var result = NumberHelpers.UIntToNormalizedFloat(value, minValue, maxValue);
Assert.That(result, Is.EqualTo(expected).Within(float.Epsilon));
var integer = NumberHelpers.NormalizedFloatToUInt(result, minValue, maxValue);
Assert.That(integer, Is.EqualTo(Clamp(value, minValue, maxValue)));
}
public InputEvent *AllocateEvent(int sizeInBytes, int capacityIncrementInBytes = 2048)
{
if (sizeInBytes < InputEvent.kBaseEventSize)
{
throw new ArgumentException(
string.Format("sizeInBytes must be >= sizeof(InputEvent) == {0} (was {1})",
InputEvent.kBaseEventSize, sizeInBytes),
"sizeInBytes");
}
var alignedSizeInBytes = NumberHelpers.AlignToMultiple(sizeInBytes, InputEvent.kAlignment);
// See if we need to enlarge our buffer.
var currentCapacity = capacityInBytes;
if (currentCapacity < alignedSizeInBytes)
{
// Yes, so reallocate.
var newCapacity = Math.Max(currentCapacity + capacityIncrementInBytes,
currentCapacity + alignedSizeInBytes);
var newSize = this.sizeInBytes + newCapacity;
if (newSize > int.MaxValue)
{
throw new NotImplementedException("NativeArray long support");
}
var newBuffer =
new NativeArray <byte>((int)newSize, Allocator.Persistent, NativeArrayOptions.ClearMemory);
if (m_Buffer.IsCreated)
{
UnsafeUtility.MemCpy(newBuffer.GetUnsafePtr(), m_Buffer.GetUnsafeReadOnlyPtr(), this.sizeInBytes);
}
else
{
m_BufferEnd = 0;
}
if (m_WeOwnTheBuffer)
{
m_Buffer.Dispose();
}
m_Buffer = newBuffer;
m_WeOwnTheBuffer = true;
}
var eventPtr = (InputEvent *)((byte *)m_Buffer.GetUnsafePtr() + m_BufferEnd);
eventPtr->sizeInBytes = (uint)sizeInBytes;
m_BufferEnd += alignedSizeInBytes;
++m_EventCount;
return(eventPtr);
}
public unsafe void State_CanGetMetrics()
{
// Make sure we start out with blank data.
var metrics = InputSystem.GetMetrics();
Assert.That(metrics.totalEventCount, Is.Zero);
Assert.That(metrics.totalEventBytes, Is.Zero);
Assert.That(metrics.totalUpdateCount, Is.Zero);
var device1 = InputSystem.AddDevice <Gamepad>();
var device2 = InputSystem.AddDevice <Keyboard>();
InputSystem.QueueStateEvent(device1, new GamepadState());
InputSystem.QueueStateEvent(device1, new GamepadState());
InputSystem.QueueStateEvent(device2, new KeyboardState());
InputSystem.Update();
var device3 = InputSystem.AddDevice <Mouse>();
InputSystem.RemoveDevice(device3);
metrics = InputSystem.GetMetrics();
// Manually compute the size of the combined state buffer so that we
// have a check that catches if the size changes (for good or no good reason).
var overheadPerBuffer = 3 * sizeof(void *) * 2; // Mapping table with front and back buffer pointers for three devices.
var combinedDeviceStateSize = NumberHelpers.AlignToMultiple(
device1.stateBlock.alignedSizeInBytes + device2.stateBlock.alignedSizeInBytes +
device3.stateBlock.alignedSizeInBytes, 4);
var sizePerBuffer = overheadPerBuffer + combinedDeviceStateSize * 2; // Front+back
var sizeOfSingleBuffer = combinedDeviceStateSize;
const int kDoubleBufferCount =
#if UNITY_EDITOR
3 // Dynamic + fixed + editor
#else
2 // Dynamic + fixed
#endif
;
var eventByteCount =
StateEvent.GetEventSizeWithPayload <GamepadState>() * 2 +
StateEvent.GetEventSizeWithPayload <KeyboardState>();
Assert.That(metrics.maxNumDevices, Is.EqualTo(3));
Assert.That(metrics.maxStateSizeInBytes, Is.EqualTo((kDoubleBufferCount * sizePerBuffer) + (sizeOfSingleBuffer * 2)));
Assert.That(metrics.totalEventBytes, Is.EqualTo(eventByteCount));
Assert.That(metrics.totalEventCount, Is.EqualTo(3));
Assert.That(metrics.totalUpdateCount, Is.EqualTo(1));
Assert.That(metrics.totalEventProcessingTime, Is.GreaterThan(0.0000001));
Assert.That(metrics.averageEventBytesPerFrame, Is.EqualTo(eventByteCount).Within(0.00001));
Assert.That(metrics.averageProcessingTimePerEvent, Is.GreaterThan(0.0000001));
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
if (!string.IsNullOrEmpty(value.ToString()))
{
var money = value.ToString().Replace(".", "");
if (NumberHelpers.IsNumber(money))
{
return(Decimal.Parse(money));
}
}
return(DependencyProperty.UnsetValue);
}
private string getEmotion(EmotionScores emotion)
{
KeyValuePair <string, float> bestMatch = new KeyValuePair <string, float>("", 0);
foreach (KeyValuePair <string, float> item in emotion.ToRankedList())
{
if (item.Value > bestMatch.Value)
{
bestMatch = item;
}
}
return(bestMatch.Key + " (" + NumberHelpers.ToPercent(bestMatch.Value) + ")");
}
public override void Execute(string text)
{
base.Execute(text);
char[] sp = { ' ', '\t' };
var argv = text.Split(sp, 1, StringSplitOptions.RemoveEmptyEntries);
if (argv.Length != 1)
{
Context.CONSOLE.Write(CommandHelp);
return;
}
var strArgAddr = argv[0];
var varArgAddr = Context.IDE.Debugger.GetExpression(strArgAddr, false, 100);
var processId = Context.IDE.Debugger.CurrentProcess.ProcessID;
if (!varArgAddr.IsValidValue)
{
Context.CONSOLE.Write("Argument <address>: " + strArgAddr + " is invalid!");
return;
}
long lpAddress = 0;
var numStyleAddr = NumberHelpers.IsHexNumber(varArgAddr.Value)
? NumberStyles.HexNumber
: NumberStyles.Integer;
var bRet = true;
bRet = bRet && NumberHelpers.TryParseLong(varArgAddr.Value, numStyleAddr, out lpAddress);
if (!bRet)
{
Context.CONSOLE.Write("Failed to evaluate command arguments!");
return;
}
var ntdbgStatus = NativeMethods.NtdbgOk;
if (NativeMethods.NtdbgOk != (ntdbgStatus = MemoryHelpers.ProcFree(processId, lpAddress)))
{
Context.CONSOLE.Write("Failed to release memory!");
Context.CONSOLE.Write("Error code:" + ntdbgStatus + " - " + NativeMethods.GetStatusString(ntdbgStatus) +
".");
return;
}
Context.CONSOLE.Write("Released memory at address: " + NumberHelpers.ToHex(lpAddress));
}
public override void Execute(string text)
{
base.Execute(text);
char[] sp = { ' ', '\t' };
var argv = text.Split(sp, 1, StringSplitOptions.RemoveEmptyEntries);
if (argv.Length != 1)
{
Context.CONSOLE.Write(CommandHelp);
return;
}
var strArgSize = argv[0];
var varArgSize = Context.IDE.Debugger.GetExpression(strArgSize, false, 100);
var processId = Context.IDE.Debugger.CurrentProcess.ProcessID;
if (!varArgSize.IsValidValue)
{
Context.CONSOLE.Write("Argument <size>: " + strArgSize + " is invalid!");
return;
}
long dataSize = 0;
var numStyleSize = NumberHelpers.IsHexNumber(varArgSize.Value)
? NumberStyles.HexNumber
: NumberStyles.Integer;
var bRet = true;
bRet = bRet && NumberHelpers.TryParseLong(varArgSize.Value, numStyleSize, out dataSize);
if (!bRet)
{
Context.CONSOLE.Write("Failed to evaluate command arguments!");
return;
}
ulong qwPtr = 0;
qwPtr = MemoryHelpers.ProcAlloc(processId, dataSize);
if (0 == qwPtr)
{
Context.CONSOLE.Write("Failed to allocate memory!");
return;
}
Context.CONSOLE.Write("Allocated: " + dataSize + " bytes at address: " + NumberHelpers.ToHex((long)qwPtr));
}
public void ValidCreateFieldRequiredProperties(ResourceId resourceId, Properties.Label label)
{
var handler = new FieldManager();
var properties = NumberHelpers.GenerateRequiredProperties(NumberFieldTestData.NumberFieldType, label);
var response = handler.CreateField(resourceId, properties);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not Create Field");
var readResponse = handler.GetFieldDetails(response.Result.Id);
CommonHelpers.DeleteField(new[] { response.Result.Id });
PrAssert.That(readResponse, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not Read Field");
PrAssert.That(readResponse.Result.Values.Count, PrIs.EqualTo(1), "Can not read Field");
PrAssert.That(readResponse.Result.Values.First().Value.Properties[Properties.PropertyName.SType.GetEnumStringValue()], PrIs.EqualTo($"{NumberFieldTestData.NumberFieldType}"), "Not as expected s.type");
PrAssert.That(readResponse.Result.Values.First().Value.Properties[Properties.PropertyName.Label.GetEnumStringValue()], PrIs.EqualTo(CommonMapperValue.LabelMapperValue[label]), "Not as expected d.label.ja");
}
public void ValidDuplicateCreateField(ResourceId resourceId, System.Enum param, Enums.ValidDuplicated validDuplicated)
{
var handler = new DefaultManager();
var properties = NumberHelpers.GenerateProperties(NumberFieldTestData.NumberFieldType, Properties.Label.Max, Properties.Caption.Min, Properties.Search.True, Properties.Match.True, Properties.Highlight.True, Properties.Require.True, Properties.Default.EqualTo, Properties.Min.EqualToMax, Properties.Max.EqualToMin, Properties.Scale.One);
var otherProperties = NumberHelpers.GenerateProperties(NumberFieldTestData.NumberFieldType, Properties.Label.Min, Properties.Caption.Max, Properties.Search.False, Properties.Match.False, Properties.Highlight.False, Properties.Require.False, Properties.Default.LessThan, Properties.Min.LessThanMax, Properties.Max.GreaterThanMin, Properties.Scale.One);
if (param.GetEnumStringValue() == Properties.PropertyName.Scale.GetEnumStringValue() && validDuplicated == Enums.ValidDuplicated.NotSameValue)
{
NumberHelpers.ScaleMapperValue[Properties.Scale.Two](properties);
}
var request = CommonHelpers.CreateDuplicateRequest(resourceId, properties, otherProperties, param, validDuplicated);
var response = handler.Send <FieldCreateResponse>(FieldManager.FieldHandlingRelativeUrl, request, HttpMethod.POST);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.OK), "Can not Create Field");
CommonHelpers.DeleteField(new[] { response.Result.Id });
}
/// <summary>
/// Get the next event after the given one. Throw if that would point to invalid memory as indicated
/// by the given memory buffer.
/// </summary>
/// <param name="currentPtr">A valid event pointer to an event inside <paramref name="buffer"/>.</param>
/// <param name="buffer">Event buffer in which to advance to the next event.</param>
/// <returns>Pointer to the next event.</returns>
/// <exception cref="InvalidOperationException">There are no more events in the given buffer.</exception>
internal static unsafe InputEvent *GetNextInMemoryChecked(InputEvent *currentPtr, ref InputEventBuffer buffer)
{
Debug.Assert(currentPtr != null);
Debug.Assert(buffer.Contains(currentPtr), "Given event is not contained in given event buffer");
var alignedSizeInBytes = NumberHelpers.AlignToMultiple(currentPtr->sizeInBytes, kAlignment);
var nextPtr = (InputEvent *)((byte *)currentPtr + alignedSizeInBytes);
if (!buffer.Contains(nextPtr))
{
throw new InvalidOperationException(string.Format(
"Event '{0}' is last event in given buffer with size {1}", new InputEventPtr(currentPtr),
buffer.sizeInBytes));
}
return(nextPtr);
}
public void ValidUpdateFieldSpecial(ResourceId resourceId, string field, Selects.ValidSelect validValue)
{
var fieldHandler = new FieldManager();
var fieldResponse = fieldHandler.GetFieldGuid(new[] { field }, new[] { resourceId });
PrAssume.That(fieldResponse, PrIs.SuccessfulResponse(), $"Cannot read field {field}");
string fieldUUID = fieldResponse.Result.Result.First().Id.ToString();
var handler = new DefaultManager();
var properties = new Dictionary <string, object>();
CreateUpdateTestData.ValidPropertyValueMapper[validValue](properties);
var updateParam = NumberHelpers.GenerateUpdateParam(resourceId, properties);
var request = NumberHelpers.GenerateRequestUpdate(fieldUUID, updateParam);
var response = handler.Send <object>(FieldManager.FieldHandlingRelativeUrl, request.ToJson(), HttpMethod.PUT);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.NoContent), "Still able update Field");
}
public void ValidDuplicateUpdateUserField(ResourceId resourceId, System.Enum param, Enums.ValidDuplicated validDuplicated)
{
var fieldUUID = PreparedFieldId.Data[$"{resourceId}0"];
var otherFieldUUID = PreparedFieldId.Data[$"{resourceId}1"];
var handler = new DefaultManager();
var properties = NumberHelpers.GenerateProperties(CurrencyFieldTestData.CurrencyFieldType, Properties.Label.Max, Properties.Caption.Min, Properties.Search.True, Properties.Match.True, Properties.Highlight.True, Properties.Require.True, Properties.Default.EqualTo, Properties.Min.EqualToMax, Properties.Max.EqualToMin, Properties.Scale.One);
var otherProperties = NumberHelpers.GenerateProperties(CurrencyFieldTestData.CurrencyFieldType, Properties.Label.Min, Properties.Caption.Max, Properties.Search.False, Properties.Match.False, Properties.Highlight.False, Properties.Require.False, Properties.Default.LessThan, Properties.Min.LessThanMax, Properties.Max.GreaterThanMin, Properties.Scale.One);
if (param.GetEnumStringValue() == Properties.PropertyName.Scale.GetEnumStringValue() && validDuplicated == Enums.ValidDuplicated.NotSameValue)
{
NumberHelpers.ScaleMapperValue[Properties.Scale.Two](properties);
}
var request = CommonHelpers.UpdateDuplicateRequest(resourceId, fieldUUID, otherFieldUUID, properties, otherProperties, param, validDuplicated);
var response = handler.Send <object>(FieldManager.FieldHandlingRelativeUrl, request, HttpMethod.PUT);
PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.NoContent), "Can not update Field");
}