public void NoNewLineAtEnd()
{
var stringData = VimUtil.CreateStringDataBlock("cat", "dog");
var value = new RegisterValue(stringData, OperationKind.CharacterWise);
Assert.Equal("cat" + Environment.NewLine + "dog", value.StringValue);
}
public IDictionary <string, RegisterValue> GetCpuFlagsAndRegisters()
{
LibGPGX.RegisterInfo[] regs = new LibGPGX.RegisterInfo[LibGPGX.gpgx_getmaxnumregs()];
int n = LibGPGX.gpgx_getregs(regs);
if (n > regs.Length)
{
throw new InvalidOperationException("A buffer overrun has occured!");
}
var ret = new Dictionary <string, RegisterValue>();
for (int i = 0; i < n; i++)
{
// el hacko
string name = Marshal.PtrToStringAnsi(regs[i].Name);
byte size = 32;
if (name.Contains("68K SR") || name.StartsWith("Z80"))
{
size = 16;
}
ret[name] = new RegisterValue((ulong)regs[i].Value, size);
}
return(ret);
}
private void DispatchReadChannelDataMessage(ProtocolMessage protocolMessage)
{
byte id = protocolMessage.ControllerID;
CpuNode node = this.Nodes.First(x => x.Id == protocolMessage.ControllerID);
if (node == null)
{
throw new ArgumentException("No node found");
}
ReadChannelDataMessage readChannelDataMessage = new ReadChannelDataMessage(protocolMessage);
List <byte> value = readChannelDataMessage.Data.ToList();
for (int i = 255; i >= 0; i--)
{
if ((readChannelDataMessage.Mask >> i & 1) == 1 && this.DebugChannels[node].ContainsKey((byte)i))
{
byte[] myValue = value.Take(this.DebugChannels[node][(byte)i].Size).ToArray();
value.RemoveRange(0, this.DebugChannels[node][(byte)i].Size);
RegisterValue regVal = new RegisterValue
{
TimeStamp = readChannelDataMessage.TimeStamp,
ValueByteArray = myValue
};
NewValueReceived(this, new ValueReceivedEventArgs(regVal, this.DebugChannels[node][(byte)i], node));
}
}
}
private void DispatchQueryRegisterMessage(ProtocolMessage protocolMessage)
{
QueryRegisterMessage response = new QueryRegisterMessage(protocolMessage);
if (response.Value == null)
{
// Error reading occured!
throw new ArgumentException("Error reading occured");
}
if (this.Nodes.All(x => x.Id != protocolMessage.ControllerID))
{
throw new ArgumentException("No node found for the msg");
}
CpuNode node = this.Nodes.First(x => x.Id == protocolMessage.ControllerID);
MessageCodec.GetControlByteValues(node.ProtocolVersion, response.Control, out ReadWrite readWrite, out Source source, out int derefDepth);
Register r = node.EmbeddedConfig.GetRegister(response.Offset, readWrite);
if (r == null)
{
throw new ArgumentException("No register found with this offset or readwrite");
}
NewValueReceived(this, new ValueReceivedEventArgs(RegisterValue.GetRegisterValueByVariableType(r.VariableType, response.Value), r, node));
}
public void SmallDelete()
{
var reg = _map.GetRegister('c');
_map.SetRegisterValue(reg, RegisterOperation.Delete, RegisterValue.OfString("foo", OperationKind.CharacterWise));
AssertRegister(RegisterName.SmallDelete, "foo", OperationKind.CharacterWise);
}
public static void UpdateBlockValues(this Register reg, params string[] value)
{
var col = NonEmptyCollectionUtil.OfSeq(value).Value;
var data = StringData.NewBlock(col);
reg.RegisterValue = RegisterValue.NewString(data, OperationKind.CharacterWise);
}
public void ValueBackingTest1()
{
var backing = new MockRegisterValueBacking();
var reg = new Register(RegisterName.Unnamed, backing);
reg.RegisterValue = RegisterValue.OfString("foo", OperationKind.CharacterWise);
Assert.AreEqual("foo", backing.RegisterValue.StringValue);
}
/// <summary>
/// Update the value with the string followed by the specified VimKey values
/// </summary>
public static void UpdateValue(this Register reg, string value, params VimKey[] keys)
{
var left = value.Select(KeyInputUtil.CharToKeyInput);
var right = keys.Select(KeyInputUtil.VimKeyToKeyInput);
var all = left.Concat(right).ToFSharpList();
reg.RegisterValue = RegisterValue.NewKeyInput(all, OperationKind.CharacterWise);
}
public void DeleteOfMultipleLines()
{
_map.GetRegister(RegisterName.SmallDelete).UpdateValue("", OperationKind.LineWise);
var reg = _map.GetRegister('c');
var text = "cat" + Environment.NewLine + "dog";
_map.SetRegisterValue(reg, RegisterOperation.Delete, RegisterValue.OfString(text, OperationKind.CharacterWise));
AssertRegister(RegisterName.SmallDelete, "", OperationKind.LineWise);
}
public void DeleteSingleLine()
{
var reg = _map.GetRegister('c');
_map.SetRegisterValue(reg, RegisterOperation.Delete, RegisterValue.OfString("foo bar\n", OperationKind.CharacterWise));
AssertRegister(reg, "foo bar\n", OperationKind.CharacterWise);
AssertRegister(RegisterName.Unnamed, "foo bar\n", OperationKind.CharacterWise);
AssertRegister('1', "foo bar\n", OperationKind.CharacterWise);
}
public void SetRegisterValue_DeleteSingleLine()
{
var reg = _map.GetRegister('c');
_map.SetRegisterValue(reg, RegisterOperation.Delete, RegisterValue.OfString("foo bar", OperationKind.CharacterWise));
AssertRegister(reg, "foo bar", OperationKind.CharacterWise);
AssertRegister(RegisterName.Unnamed, "foo bar", OperationKind.CharacterWise);
AssertRegister(RegisterName.NewNumbered(NumberedRegister.Register_1), "foo bar", OperationKind.CharacterWise);
AssertRegister(RegisterName.SmallDelete, "foo bar", OperationKind.CharacterWise);
}
public void Yank()
{
var reg = _map.GetRegister('c');
_map.GetRegister(RegisterName.SmallDelete).UpdateValue("", OperationKind.LineWise);
_map.SetRegisterValue(reg, RegisterOperation.Yank, RegisterValue.OfString("foo bar", OperationKind.CharacterWise));
AssertRegister(reg, "foo bar", OperationKind.CharacterWise);
AssertRegister(RegisterName.Unnamed, "foo bar", OperationKind.CharacterWise);
AssertRegister(RegisterName.SmallDelete, "", OperationKind.LineWise);
}
public void Numbered()
{
var reg = _map.GetRegister('c');
_map.SetRegisterValue(reg, RegisterOperation.Delete, RegisterValue.OfString("f\n", OperationKind.CharacterWise));
_map.SetRegisterValue(reg, RegisterOperation.Delete, RegisterValue.OfString("o\n", OperationKind.CharacterWise));
AssertRegister(reg, "o\n", OperationKind.CharacterWise);
AssertRegister(RegisterName.Unnamed, "o\n", OperationKind.CharacterWise);
AssertRegister('1', "o\n", OperationKind.CharacterWise);
AssertRegister('2', "f\n", OperationKind.CharacterWise);
}
//name is the value that it adds to
public void addValue(string variablename, string name, RegisterValue val)
{
addedValue[variablename].Add(name, val);
CurrentValue[variablename] = 0;
foreach (RegisterValue x in addedValue[name].Values)
{
CurrentValue[variablename] += x.value;
}
CurrentValue[variablename] += valuePairs[variablename].value;
CurrentValue[variablename] = CurrentValue[variablename] >= MaxValue[variablename] ? CurrentValue[name] : MaxValue[variablename];
}
public void ForSpan_DeleteToBlackHole()
{
_map.GetRegister(RegisterName.Blackhole).UpdateValue("", OperationKind.LineWise);
_map.GetRegister(RegisterName.NewNumbered(NumberedRegister.Register_1)).UpdateValue("hey", OperationKind.CharacterWise);
var namedReg = _map.GetRegister('c');
_map.SetRegisterValue(namedReg, RegisterOperation.Yank, RegisterValue.OfString("foo bar", OperationKind.CharacterWise));
_map.SetRegisterValue(_map.GetRegister(RegisterName.Blackhole), RegisterOperation.Delete, RegisterValue.OfString("foo bar", OperationKind.CharacterWise));
AssertRegister(namedReg, "foo bar", OperationKind.CharacterWise);
AssertRegister(RegisterName.Unnamed, "foo bar", OperationKind.CharacterWise);
AssertRegister(RegisterName.NewNumbered(NumberedRegister.Register_1), "hey", OperationKind.CharacterWise);
AssertRegister(RegisterName.Blackhole, "", OperationKind.LineWise);
}
public IDictionary <string, RegisterValue> GetCpuFlagsAndRegisters()
{
var values = new int[RegisterNames.Length];
LibmGBA.BizGetRegisters(_core, values);
var ret = new Dictionary <string, RegisterValue>();
for (var i = 0; i < RegisterNames.Length; i++)
{
ret[RegisterNames[i]] = new RegisterValue(values[i]);
}
return(ret);
}
public override void WriteValue(CpuNode cpuNode, Register register, RegisterValue registerValue)
{
Version protocolVersion = cpuNode.ProtocolVersion;
byte control = MessageCodec.GetControlByte(protocolVersion, register.ReadWrite, register.Source, register.DerefDepth);
WriteRegisterMessage msg = new WriteRegisterMessage()
{
Offset = register.Offset,
Control = control,
Value = registerValue.ValueByteArray,
};
// TODO add the msgID
this.SendMessage(MessageCodec.EncodeMessage(msg.ToProtocolMessage(cpuNode.Id, 0x01)));
}
private void try2Register(RegisterInfo registerInfo, RegisterValue registerValue)
{
int keycodeState = -1;
var keycodeSql = String.Format("select * from keycode where keycode = \"{0}\"", registerInfo.KeyCode);
using (DatabaseKeeper.GetInstance().KeycodeDbLocker.ReadLock())
{
using (SQLiteDataReader dr = DatabaseKeeper.GetInstance().KeycodeDBHelper.ExecuteReader(keycodeSql))
{
if (dr.Read())
{
keycodeState = Int16.Parse(dr["state"].ToString());
}
}
}
//经过申请的keycode，可以用于注册
if (keycodeState == 1)
{
registerValue.KeyCode = registerInfo.KeyCode;
//更新keycode为已经使用
registerValue.Message = "注册成功";
var updateKeyCodeSql = String.Format("update keycode set state = 2 where keycode = \"{0}\"", registerInfo.KeyCode);
using (DatabaseKeeper.GetInstance().KeycodeDbLocker.WriteLock())
{
DatabaseKeeper.GetInstance().KeycodeDBHelper.ExecuteNonQuery(updateKeyCodeSql);
}
}
else if (keycodeState == 2)
{
registerValue.Message = "重复的注册码";
}
else
{
registerValue.Message = "无效的注册码";
}
}
public ValueReceivedEventArgs(RegisterValue registerValue, Register register, CpuNode cpuNode)
{
this.Value = registerValue;
this.Register = register;
this.CpuNode = cpuNode;
}
public abstract void WriteValue(CpuNode cpuNode, Register register, RegisterValue registerValue);
public static void UpdateValue(this Register reg, string value, OperationKind kind)
{
reg.RegisterValue = RegisterValue.OfString(value, kind);
}
/// <summary>
/// Write a value to a Register
/// </summary>
/// <param name="cpuNode">The CPU node ID</param>
/// <param name="register">The value to write to the register</param>
/// <param name="registerValue">The register to write to</param>
public void WriteToRegister(CpuNode cpuNode, Register register, RegisterValue registerValue)
{
this.Connection.WriteValue(cpuNode, register, registerValue);
}
protected virtual void OnRegisterValue(PropertyChangedEventArgs args)
{
RegisterValue?.Invoke(_target, args);
//_eventHandlerService.Invoke(RegisterValue, _target,args);
}
public void NoNewLineAtEnd()
{
var stringData = VimUtil.CreateStringDataBlock("cat", "dog");
var value = new RegisterValue(stringData, OperationKind.CharacterWise);
Assert.Equal("cat" + Environment.NewLine + "dog", value.StringValue);
}
public abstract RegisterCompareResult Compare(RegisterValue RegisterB);
public override RegisterCompareResult Compare(RegisterValue RegisterB)
{
RegisterCompareResult res;
try
{
byte[] valueB = RegisterB.ValueBytes;
res.EqualityResult = EqualityResult.NotEqual;
res.RangeResult = RangeResult.NotAvailable;
int i;
for (i = 0; i < _Value.Length; i++)
if (i < valueB.Length)
{
if (_Value[i] < valueB[i])
{
res.RangeResult = RangeResult.Less;
break;
}
else if (_Value[i] > valueB[i])
{
res.RangeResult = RangeResult.Greater;
break;
}
}
else
{
res.RangeResult = RangeResult.Greater;
break;
}
if (i == _Value.Length)
if (i < valueB.Length)
res.RangeResult = RangeResult.Less;
else
{
res.RangeResult = RangeResult.Equal;
res.EqualityResult = EqualityResult.Equal;
}
}
catch (Exception)
{
res.EqualityResult = EqualityResult.Incompatible;
res.RangeResult = RangeResult.NotAvailable;
}
return res;
}
public void StarRegister2()
{
_clipboard.SetupSet(x => x.Text = "bar").Verifiable();
_map.GetRegister('*').RegisterValue = RegisterValue.OfString("bar", OperationKind.CharacterWise);
_factory.Verify();
}
/// <summary>
/// Update the value with the spcefied set of VimKey values
/// </summary>
public static void UpdateValue(this Register reg, params VimKey[] keys)
{
var all = keys.Select(KeyInputUtil.VimKeyToKeyInput).ToFSharpList();
reg.RegisterValue = RegisterValue.NewKeyInput(all, OperationKind.CharacterWise);
}
/// <summary>
/// Update the value with the specified set of KeyInput values
/// </summary>
public static void UpdateValue(this Register reg, params KeyInput[] keys)
{
reg.RegisterValue = RegisterValue.NewKeyInput(keys.ToFSharpList(), OperationKind.CharacterWise);
}
private Message doPost(Message value)
{
var content = value.Content;
content = this.enciphermentUtil.decStringPlusBase64(content);
var registerInfo = JsonConvert.DeserializeObject <RegisterInfo>(content);
var sql = String.Format("select * from register where machineid = \"{0}\"", registerInfo.MachineId);
RegisterValue registerValue = null;
using (DatabaseKeeper.GetInstance().RegisterDbLocker.ReadLock())
{
using (SQLiteDataReader dr = DatabaseKeeper.GetInstance().RegisterDBHelper.ExecuteReader(sql))
{
if (dr.Read())
{
registerValue = new RegisterValue
{
MachineId = registerInfo.MachineId,
KeyCode = dr["keycode"].ToString(),
OccupyTimes = Int16.Parse(dr["occupytimes"].ToString())
};
}
}
}
if (registerValue == null)
{
registerValue = new RegisterValue
{
KeyCode = "",
OccupyTimes = 1,
MachineId = registerInfo.MachineId
};
registerValue.Message = "欢迎使用DesktopAndroid";
//升级到正式版
if (!String.IsNullOrEmpty(registerInfo.KeyCode))
{
try2Register(registerInfo, registerValue);
}
using (DatabaseKeeper.GetInstance().RegisterDbLocker.WriteLock())
{
var insertSql = String.Format("insert into register(machineid,keycode,occupytimes) values(\"{0}\",\"{1}\",\"{2}\")",
registerValue.MachineId, registerValue.KeyCode, registerValue.OccupyTimes);
DatabaseKeeper.GetInstance().RegisterDBHelper.ExecuteNonQuery(insertSql);
}
}
else
{
if (String.IsNullOrEmpty(registerValue.KeyCode))
{
//升级到正式版
if (!String.IsNullOrEmpty(registerInfo.KeyCode))
{
try2Register(registerInfo, registerValue);
//升级成功
if (!String.IsNullOrEmpty(registerValue.KeyCode))
{
using (DatabaseKeeper.GetInstance().RegisterDbLocker.WriteLock())
{
var updateSql = String.Format("update register set keycode = \"{0}\" where machineid = \"{1}\"", registerValue.KeyCode, registerValue.MachineId);
DatabaseKeeper.GetInstance().RegisterDBHelper.ExecuteNonQuery(updateSql);
}
}
}
else
{
if (registerValue.OccupyTimes >= LIMIT)
{
//不限制试用
//registerValue.IsLimited = true;
//registerValue.Message = "试用已结束，请升级到正式版";
registerValue.Message = "欢迎使用DesktopAndroid";
}
else
{
registerValue.Message = "欢迎使用DesktopAndroid";
//registerValue.Message = String.Format("你的试用次数还有{0}次", LIMIT - registerValue.OccupyTimes);
registerValue.OccupyTimes++;
using (DatabaseKeeper.GetInstance().RegisterDbLocker.WriteLock())
{
var updateSql = String.Format("update register set occupytimes = {0} where machineid = \"{1}\"", registerValue.OccupyTimes, registerValue.MachineId);
DatabaseKeeper.GetInstance().RegisterDBHelper.ExecuteNonQuery(updateSql);
}
}
}
}
}
registerValue.Random = registerInfo.Random;
var rspContent = JsonConvert.SerializeObject(registerValue);
rspContent = this.enciphermentUtil.encStringPlusBase64(rspContent);
return(new Message
{
Content = rspContent
});
}
public void CharacterWiseOperationKind()
{
var value = new RegisterValue(FSharpList <KeyInput> .Empty);
Assert.Equal(OperationKind.CharacterWise, value.OperationKind);
}
public override RegisterCompareResult Compare(RegisterValue RegisterB)
{
RegisterCompareResult res;
try
{
String valueB = RegisterB.ValueString;
if (_Value == valueB)
{
res.EqualityResult = EqualityResult.Equal;
res.RangeResult = RangeResult.Equal;
}
else
{
res.EqualityResult = EqualityResult.NotEqual;
if (String.Compare(_Value, valueB) < 1)
res.RangeResult = RangeResult.Less;
else
res.RangeResult = RangeResult.Greater;
}
}
catch (Exception)
{
res.EqualityResult = EqualityResult.Incompatible;
res.RangeResult = RangeResult.NotAvailable;
}
return res;
}
public static void UpdateValue(this Register reg, string value)
{
var data = StringData.NewSimple(value);
var regValue = new RegisterValue(data, MotionKind.Inclusive, OperationKind.CharacterWise);
reg.Value = regValue;
}
public void CharacterWiseOperationKind()
{
var value = new RegisterValue(FSharpList<KeyInput>.Empty);
Assert.Equal(OperationKind.CharacterWise, value.OperationKind);
}
