public void GeneratesProperObjectSampleData()
{
var propertyDictionary = new CaseInsensitiveDictionary <SchemaObject>();
propertyDictionary.Add("IntegerProp", new SchemaObject()
{
Type = DataType.Integer.Value
});
propertyDictionary.Add("StringProp", new SchemaObject()
{
Type = DataType.String.Value
});
propertyDictionary.Add("ObjectProp", new SchemaObject()
{
Type = DataType.Object.Value,
Properties = new CaseInsensitiveDictionary <SchemaObject>()
{
{
"InnerProp", new SchemaObject()
{
Type = DataType.Integer.Value
}
}
}
});
var objectString = SampleData.GenerateSampleData(DataType.Object, null, properties: propertyDictionary);
objectString = objectString.Replace("\"\"", "\"");
objectString.ShouldBe("{\"IntegerProp\":\"30\",\"StringProp\":\"String text\",\"ObjectProp\":{\"InnerProp\":\"30\"}}");
}
private static NameWrapper AddNameToUniqueStrings(string name, Dictionary <string, string> dontShortenStrings,
CaseInsensitiveDictionary <StringWrapper> uniqueStrings)
{
NameWrapper nameWrapper = new NameWrapper();
List <string> nameStrings = StringUtils.SplitAndReallyRemoveEmptyEntries(name, Utils.NAME_SEPARATOR, StringComparison.OrdinalIgnoreCase);
foreach (string nameString in nameStrings)
{
bool canShorten = !dontShortenStrings.ContainsKey(nameString);
StringWrapper stringWrapper;
if (uniqueStrings.TryGetValue(nameString, out stringWrapper))
{
DebugUtils.AssertDebuggerBreak(stringWrapper.CanShorten == canShorten);
}
else
{
stringWrapper = new StringWrapper(nameString, canShorten);
uniqueStrings.Add(nameString, stringWrapper);
}
nameWrapper.AddString(stringWrapper);
}
return(nameWrapper);
}
public static CaseInsensitiveDictionary <SchemaObject> BuildSchemaDictionary <T>(string contractString, Func <T> handleRefError, Func <T> handleFailure)
{
var schemaDictionary = new CaseInsensitiveDictionary <SchemaObject>();
try
{
var schemaObject = (JsonObject)JsonValue.Parse(contractString);
foreach (var key in schemaObject.Keys)
{
var contractObjectString = schemaObject[key].ToString();
var contractObject = ConvertJsonToSchema(contractObjectString);
schemaDictionary.Add(key, contractObject);
}
if (schemaDictionary["Contract"].Properties.Any(p => p.Value.Reference != null))
{ // References are used in the schema, so populate them
var populatedDictionary = PopulateReferences(schemaDictionary);
if (populatedDictionary.HasReferenceError)
{
handleRefError();
}
schemaDictionary = populatedDictionary.SchemaDictionary;
}
}
catch
{
handleFailure();
}
return(schemaDictionary);
}
public void CaseInsensitiveDictionary_Construction_2()
{
CaseInsensitiveDictionary <int> dictionary
= new CaseInsensitiveDictionary <int>(100);
Assert.AreEqual(0, dictionary.Count);
dictionary.Add("first", 1);
dictionary.Add("second", 2);
dictionary.Add("third", 3);
Assert.AreEqual(3, dictionary.Count);
Assert.IsTrue(dictionary.ContainsKey("first"));
Assert.IsTrue(dictionary.ContainsKey("FIRST"));
Assert.IsTrue(dictionary.ContainsKey("second"));
Assert.IsTrue(dictionary.ContainsKey("SECOND"));
Assert.IsTrue(dictionary.ContainsKey("third"));
Assert.IsTrue(dictionary.ContainsKey("THIRD"));
Assert.IsFalse(dictionary.ContainsKey("fourth"));
Assert.IsFalse(dictionary.ContainsKey("FOURTH"));
}
/// <summary>
///A test for Remove
///</summary>
public void RemoveTestHelper <TValue>()
{
var target = new CaseInsensitiveDictionary <TValue>();
var key = "a";
TValue value = default(TValue);
target.Add(key, value);
target.Remove(key);
Assert.IsFalse(((Dictionary <string, TValue>)target).ContainsKey(key));
}
/// <summary>
///A test for ContainsKey
///</summary>
public void ContainsKeyTestHelper <TValue>()
{
var target = new CaseInsensitiveDictionary <TValue>();
string key = "a";
target.Add(key, default(TValue));
bool actual;
actual = target.ContainsKey(key);
Assert.IsTrue(actual);
}
//
//You can use the following additional attributes as you write your tests:
//
//Use ClassInitialize to run code before running the first test in the class
//[ClassInitialize()]
//public static void MyClassInitialize(TestContext testContext)
//{
//}
//
//Use ClassCleanup to run code after all tests in a class have run
//[ClassCleanup()]
//public static void MyClassCleanup()
//{
//}
//
//Use TestInitialize to run code before running each test
//[TestInitialize()]
//public void MyTestInitialize()
//{
//}
//
//Use TestCleanup to run code after each test has run
//[TestCleanup()]
//public void MyTestCleanup()
//{
//}
//
#endregion
/// <summary>
///A test for Item
///</summary>
public void ItemTestHelper <TValue>()
{
var target = new CaseInsensitiveDictionary <TValue>();
string key = "a";
string ukey = "A";
target.Add(key, default(TValue));
TValue expected = default(TValue);
TValue actual;
target[key] = expected;
actual = target[ukey];
Assert.AreEqual(expected, actual);
}
/// <summary>
///A test for Remove
///</summary>
public void RemoveTest3Helper <TValue>()
{
var target = new CaseInsensitiveDictionary <TValue>();
var key = "a";
var zkey = "z";
TValue value = default(TValue);
target.Add(key, value);
try
{
target.Remove(zkey);
} catch {}
Assert.IsTrue(((Dictionary <string, TValue>)target).ContainsKey(key));
}
private void AddToInsensitiveList(
BlockCommandContext context,
string word)
{
// Update the internal dictionaries.
CaseInsensitiveDictionary.Add(word.ToLowerInvariant());
// Clear the spell-checking on the entire document and reparse it.
Project.Plugins.ClearAnalysis(BlockAnalyzer);
Project.Plugins.ProcessBlockAnalysis();
// Make sure the settings are written out.
WriteSettings();
}
public void DeserializeContractToTupleTest(string contract)
{
var testDictionary = new CaseInsensitiveDictionary <SchemaObject>();
var jsonObjectDictionary = (JsonObject)JsonValue.Parse(contract);
foreach (var key in jsonObjectDictionary.Keys)
{
var jsonObject = jsonObjectDictionary[key];
var schemaObjectString = jsonObject.ToString();
JsonValue.Parse(schemaObjectString);
var schemaObject = SchemaObject.ConvertJsonToSchema(schemaObjectString);
testDictionary.Add(key, schemaObject);
}
testDictionary.ShouldNotBeEmpty();
testDictionary.Count.ShouldBe(2);
}
private static Log GetLogger(string name = null)
{
var logName = name ?? Assembly.GetCallingAssembly().GetName().Name;
Log log;
lock (LoggerLock)
{
if (Loggers.TryGetValue(logName, out log))
{
return(log);
}
log = new Log(logName);
Loggers.Add(logName, log);
}
return(log);
}
static void ProcessRecord
(
[NotNull] MarcRecord record
)
{
string index = record.FM(903);
if (string.IsNullOrEmpty(index))
{
return;
}
if (_indexes.ContainsKey(index))
{
Console.WriteLine("Repeating index: {0}", index);
return;
}
_indexes.Add(index, false);
string description = _GetDescription(record);
if (string.IsNullOrEmpty(description))
{
return;
}
description = description.Limit(500);
IrbisData data = new IrbisData
{
Index = index.Limit(32),
Description = description,
Heading = _GetHeading(record),
Title = _GetTitle(record),
Author = _GetAuthors(record),
Count = _GetExemplars(record),
Year = _GetYear(record),
Link = _GetLink(record),
Type = _GetType(record)
};
_database.Insert(data);
Console.WriteLine("[{0}] {1}", record.Mfn, data.Description);
}
public void ReadXml(XmlReader reader)
{
// We are already at the starting point of this element, so read until the
// end.
string elementName = reader.LocalName;
// Read until we get to the end element.
while (reader.Read())
{
// If we aren't in our namespace, we don't need to bother.
if (reader.NamespaceURI != XmlConstants.ProjectNamespace)
{
continue;
}
// If we got to the end of the node, then stop reading.
if (reader.LocalName == elementName)
{
return;
}
// Look for a key, if we have it, set that value.
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.LocalName)
{
case "sensitive":
string sensitive = reader.ReadString();
CaseSensitiveDictionary.Add(sensitive);
break;
case "insensitive":
string insensitive = reader.ReadString();
CaseInsensitiveDictionary.Add(insensitive);
break;
}
}
}
}
/// <summary>
/// Retrieves the setting substitutions and rebuilds the internal list.
/// </summary>
public void ReadSettings()
{
// Clear out the existing settings.
CaseInsensitiveDictionary.Clear();
CaseSensitiveDictionary.Clear();
// Go through all of the settings in the various projects.
IList <LocalWordsSettings> settingsList =
Project.Settings.GetAll <LocalWordsSettings>(LocalWordsSettings.SettingsPath);
foreach (LocalWordsSettings settings in settingsList)
{
// Add the two dictionaries.
foreach (string word in settings.CaseInsensitiveDictionary)
{
CaseInsensitiveDictionary.Add(word);
}
foreach (string word in settings.CaseSensitiveDictionary)
{
CaseSensitiveDictionary.Add(word);
}
}
}
public void Compile(Function func)
{
if (Target is UFunction uFunction)
{
var nextItem = uFunction.Children;
UProperty returnValue = null;
while (uFunction.Export.FileRef.TryGetUExport(nextItem, out ExportEntry nextChild))
{
var objBin = ObjectBinary.From(nextChild);
switch (objBin)
{
case UProperty uProperty:
if (uProperty.PropertyFlags.HasFlag(UnrealFlags.EPropertyFlags.ReturnParm))
{
returnValue = uProperty;
}
else if (uProperty.PropertyFlags.HasFlag(UnrealFlags.EPropertyFlags.Parm))
{
parameters.Add(nextChild.ObjectName.Instanced, uProperty);
}
else
{
locals.Add(nextChild.ObjectName.Instanced, uProperty);
}
nextItem = uProperty.Next;
break;
default:
nextItem = 0;
break;
}
}
foreach (FunctionParameter parameter in func.Parameters.Where(param => param.IsOptional))
{
if (parameter.DefaultParameter is Expression expr)
{
WriteOpCode(OpCodes.DefaultParmValue);
using (WriteSkipPlaceholder())
{
Emit(expr);
WriteOpCode(OpCodes.EndParmValue);
}
}
else
{
WriteOpCode(OpCodes.Nothing);
}
}
Emit(func.Body);
WriteOpCode(OpCodes.Return);
if (returnValue != null)
{
WriteOpCode(OpCodes.ReturnNullValue);
WriteObjectRef(returnValue.Export);
}
else
{
WriteOpCode(OpCodes.Nothing);
}
WriteOpCode(OpCodes.EndOfScript);
foreach ((Label label, List <JumpPlaceholder> jumpPlaceholders) in LabelJumps)
{
foreach (JumpPlaceholder jumpPlaceholder in jumpPlaceholders)
{
jumpPlaceholder.End(label.StartOffset);
}
}
Target.ScriptBytecodeSize = GetMemLength();
Target.ScriptBytes = GetByteCode();
Target.Export.WriteBinary(Target);
}
else
{
throw new Exception("Cannot compile a function to a state!");
}
}
public static Class ConvertClass(UClass uClass, bool decompileBytecode, FileLib lib = null)
{
IMEPackage pcc = uClass.Export.FileRef;
VariableType parent = new VariableType(pcc.GetEntry(uClass.SuperClass)?.ObjectName.Instanced ?? "object");
VariableType outer = new VariableType(pcc.GetEntry(uClass.OuterClass)?.ObjectName.Instanced ?? parent.Name);
// TODO: components
var interfaces = new List <VariableType>();
foreach ((UIndex interfaceUIndex, UIndex _) in uClass.Interfaces)
{
interfaces.Add(new VariableType(pcc.GetEntry(interfaceUIndex)?.ObjectName.Instanced ?? "UNK_INTERFACE"));
}
var Types = new List <VariableType>();
var Vars = new List <VariableDeclaration>();
var Funcs = new List <Function>();
var States = new List <State>();
var nextItem = uClass.Children;
while (pcc.TryGetUExport(nextItem, out ExportEntry nextChild))
{
var objBin = ObjectBinary.From(nextChild);
switch (objBin)
{
case UConst uConst:
Types.Add(new Const(uConst.Export.ObjectName.Instanced, uConst.Value)
{
Literal = new ClassOutlineParser(new TokenStream <string>(new StringLexer(uConst.Value))).ParseConstValue()
});
nextItem = uConst.Next;
break;
case UEnum uEnum:
Types.Add(ConvertEnum(uEnum));
nextItem = uEnum.Next;
break;
case UFunction uFunction:
Funcs.Add(ConvertFunction(uFunction, uClass, decompileBytecode));
nextItem = uFunction.Next;
break;
case UProperty uProperty:
Vars.Add(ConvertVariable(uProperty));
nextItem = uProperty.Next;
break;
case UScriptStruct uScriptStruct:
Types.Add(ConvertStruct(uScriptStruct));
nextItem = uScriptStruct.Next;
break;
case UState uState:
nextItem = uState.Next;
States.Add(ConvertState(uState, uClass, decompileBytecode));
break;
default:
nextItem = 0;
break;
}
}
var propObject = pcc.GetUExport(uClass.Defaults);
var defaultProperties = ConvertDefaultProperties(propObject);
Class AST = new Class(uClass.Export.ObjectName.Instanced, parent, outer, uClass.ClassFlags, interfaces, Types, Vars, Funcs, States, defaultProperties)
{
ConfigName = uClass.ClassConfigName,
Package = uClass.Export.Parent is null?Path.GetFileNameWithoutExtension(pcc.FilePath) : uClass.Export.ParentInstancedFullPath,
};
// Ugly quick fix:
foreach (var member in Types)
{
member.Outer = AST;
}
foreach (var member in Vars)
{
member.Outer = AST;
}
foreach (var member in Funcs)
{
member.Outer = AST;
}
foreach (var member in States)
{
member.Outer = AST;
}
var virtFuncLookup = new CaseInsensitiveDictionary <ushort>();
for (ushort i = 0; i < uClass.FullFunctionsList.Length; i++)
{
virtFuncLookup.Add(uClass.FullFunctionsList[i].GetEntry(pcc)?.ObjectName, i);
}
AST.VirtualFunctionLookup = virtFuncLookup;
return(AST);
}
public async Task RunAsync()
{
var lineWithCommand = new Regex($"^{_context.CommandPrefix} (\\S+)(?: (\\S+))*$");
using (var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(_context.InputFile))))
{
while (!stream.EndOfStream)
{
var line = await stream.ReadLineAsync();
if (line == null)
{
continue;
}
var commandCheck = lineWithCommand.Match(line);
if (commandCheck.Success)
{
var groupEnumerator = commandCheck.Groups.GetEnumerator();
groupEnumerator.MoveNext();
groupEnumerator.MoveNext();
var group = groupEnumerator.Current as Group;
if (group == null)
{
continue;
}
var command = group.Value;
if (command == null)
{
continue;
}
if (!_instructions.TryGetValue(command, out var instruction))
{
continue;
}
var parameters = new List <string>();
while (groupEnumerator.MoveNext())
{
var value = (groupEnumerator.Current as Group)?.Value;
if (!string.IsNullOrWhiteSpace(value))
{
parameters.Add(value ?? throw new InvalidOperationException());
}
}
if (!_activeInstructions.ContainsKey(instruction.Command))
{
_activeInstructions.Add(instruction.Command, instruction);
}
await instruction.InitializeInstructionAsync(_context, parameters.ToArray());
}
else
{
foreach (var inst in _activeInstructions.Values)
{
await inst.HandleLineAsync(line);
}
}
}
}
}