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); } } } } }