private static void addParameter(Instruction instruction, int childIndex, ParameterReader paramData, GameObject parent) { string type = paramData.readWord().ToLower(); if (type.Equals("boolean")) { BooleanParameter boolean = (BooleanParameter)instruction.addBooleanChild(); boolean.Valeur = paramData.readBoolean(); } else if (type.Equals("integer")) { IntegerParameter integer = (IntegerParameter)instruction.addIntegerChild(); integer.Valeur = paramData.readInt(); if (paramData.hasNextWord()) { addIntegerMethod(integer, paramData.readWord(), instruction.gameObject); } if (paramData.hasNextWord()) { integer.autoCompile = paramData.readBoolean(); } } else { Debug.LogError("MAPLOADER - ERROR : Unknown parameter type for " + type); } }
public void PressiusTestObject_ShouldPermutateWithStaticGenerator() { var addedParameterDefinitions = new List <IParameterDefinition> { new ValidLocation() }; var pressiusTestObjectList = Permutor.Generate <PressiusTestObject>( new PressiusTestObjectObjectDefinition(), addedParameterDefinitions).ToList(); pressiusTestObjectList.ShouldNotBeNull(); pressiusTestObjectList.ToList().Count.ShouldBeGreaterThan(0); var objectList = pressiusTestObjectList.ToList(); var integerParams = new IntegerParameter(); var stringParams = new StringParameter(); var validLocation = new ValidLocation(); var id = 1; objectList.ForEach(obj => { _output.WriteLine("Obj: {0} {1} {2}", obj.Id, obj.Name, obj.Address); obj.Id.ShouldBe(id); validLocation.InputCatalogues.ShouldContain(obj.Address); stringParams.InputCatalogues.ShouldContain(obj.Name); id++; }); }
private static void TestParameterIs(IntegerParameter p, int val) { Assert.That(p.Value, Is.EqualTo(val)); int result; bool isInt; Assert.That(p.Corrupted, Is.False); Assert.That(p.ValueAsString(), Is.EqualTo(val.ToString(CultureInfo.InvariantCulture))); //Tempting to simply verify it will parse as the correct value but we need to be consistent with existing files using (TemporaryCulture.English()) { isInt = int.TryParse(p.DisplayValue((a, b) => ""), out result); Assert.That(isInt); if (isInt) { Assert.That(result, Is.EqualTo(val)); } } using (TemporaryCulture.European()) { isInt = int.TryParse(p.DisplayValue((a, b) => ""), out result); Assert.That(isInt); if (isInt) { Assert.That(result, Is.EqualTo(val)); } } }
public void PressiusTestObjectWithEnum_ShouldPermutateWithIntegerEnum() { var permutor = new Permutor(); var pressiusTestObjectList = permutor .AddParameterDefinition(new ValidCounterEnumWithNumber()) .GeneratePermutation <PressiusTestObjectWithEnum>(); pressiusTestObjectList.ShouldNotBeNull(); var objectList = pressiusTestObjectList.ToList(); objectList.Count.ShouldBeGreaterThan(0); var integerParams = new IntegerParameter(); var stringParams = new StringParameter(); var counterParams = new ValidCounterEnum(); var count = 1; objectList.ForEach(obj => { _output.WriteLine("Obj: {0} {1} {2} {3}", obj.Id, obj.Name, obj.Address, obj.Counter); obj.Id.ShouldBe(count); count++; stringParams.InputCatalogues.ShouldContain(obj.Name); stringParams.InputCatalogues.ShouldContain(obj.Address); counterParams.InputCatalogues.ShouldContain(obj.Counter); }); }
public IntegerParameter addIntegerChild() { GameObject go = createChild(); IntegerParameter parameter = go.AddComponent <IntegerParameter>(); return(parameter); }
public void PressiusTestObject_ShouldPermutate() { var pressiusTestObjectList = Permutor.Generate <PressiusTestObject>(); pressiusTestObjectList.ShouldNotBeNull(); var objectList = pressiusTestObjectList.ToList(); objectList.Count.ShouldBeGreaterThan(0); var integerParams = new IntegerParameter(); var stringParams = new StringParameter(); var booleanParams = new BooleanParameter(); var decimalParams = new DecimalParameter(); var id = 1; objectList.ForEach(obj => { _output.WriteLine("Obj: {0} {1} {2} {3} {4} {5} {6}", obj.Id, obj.Name, obj.Address, obj.NullableInteger, obj.DecimalValue, obj.BooleanValue, obj.Created); obj.Id.ShouldBe(id); integerParams.InputCatalogues.ShouldContain(obj.NullableInteger); stringParams.InputCatalogues.ShouldContain(obj.Name); stringParams.InputCatalogues.ShouldContain(obj.Address); booleanParams.InputCatalogues.ShouldContain(obj.BooleanValue); decimalParams.InputCatalogues.ShouldContain(obj.DecimalValue); id++; }); }
public void Clones_Have_Same_Value() { IntegerParameter p0 = new IntegerParameter("id", null, 68); IntegerParameter p1 = p0.Clone() as IntegerParameter; Assert.AreEqual((int)p0.GetValue(), (int)p1.GetValue()); }
public override IEnumerable <Parameter> CreateParameters(string parameterPrefix) { Power = new EnumParameter <EPowerStatus>(parameterPrefix + "Pwr", "Power", "", false); Step = new IntegerParameter(parameterPrefix + "Stp", "Oscillograph Step", "Step", 1, 10, 1, false); return(new List <Parameter> { Power, Step }); }
public void ImplicitOperator_ReturnsValue() { IntegerParameter p = new IntegerParameter("test", "test", 455); if (p > 400) { Assert.Pass(); } Assert.Fail(); }
public override IEnumerable <Parameter> CreateParameters(string parameterPrefix) { OscillatorType = new EnumParameter <EOscillatorType>(parameterPrefix + "Osc", "LFO Type", "Osc", false); Frequency = new FrequencyParameter(parameterPrefix + "Frq", "LFO Frequency", "Frq", 0.01, 1000); MatchKey = new BooleanParameter(parameterPrefix + "Mtch", "LFO Phase Key Link", "Match", false); Gain = new RealParameter(parameterPrefix + "Gain", "LFO Gain", "Gain", 0, 1, 0.01, false); TargetParameter = new ParameterName(parameterPrefix, Processor.PluginController.ParametersManager); TargetParameter.OnValueChange += TargetParameterNumberOnValueChange; return(new List <Parameter> { OscillatorType, Frequency, MatchKey, Gain, TargetParameter }); }
public static void TestNullDefault() { string name = "nameasd"; Id <Parameter> id = Id <Parameter> .Parse("C6AE15FF-0242-4289-AADD-F9F71F4CFEBB"); ParameterType type = ParameterType.Parse("86EDCBA3-7807-4DD5-B0E8-0769C52BA0EB"); IntegerParameter.Definition definition = new IntegerParameter.Definition(null, null); IntegerParameter p = new IntegerParameter(name, id, type, definition, null); Assert.That(p.Corrupted, Is.True); p.SetValueAction(1).Value.Redo(); TestParameterIs(p, 1); }
public IntegerParameter CreateIntegerParameter(string parameterName) { if (string.IsNullOrEmpty(parameterName)) { throw new ArgumentException("Invalid parameter name"); } if (_Parameters.ContainsKey(parameterName)) { throw new ArgumentException("parameter name already exist"); } IntegerParameter parameter = new IntegerParameter(parameterName, this); _Parameters.Add(parameterName, parameter); return(parameter); }
static void addIntegerMethod(IntegerParameter integer, string method, GameObject parent) { if (method.StartsWith("setPlayerJumpHeight")) { GravityChanger gc = parent.AddComponent <GravityChanger>(); gc.gravityValue = integer; integer.observers.Add(gc); } else if (method.StartsWith("addScore")) { ScoreAdder sa = integer.gameObject.AddComponent <ScoreAdder>(); sa.integerParameter = integer; integer.observers.Add(sa); } else if (method.StartsWith("removeScore")) { ScoreRemover sr = integer.gameObject.AddComponent <ScoreRemover>(); sr.integerParameter = integer; integer.observers.Add(sr); } else if (method.StartsWith("addTime")) { TimeAdder ta = integer.gameObject.AddComponent <TimeAdder>(); ta.integerParameter = integer; integer.observers.Add(ta); } else if (method.StartsWith("removeTime")) { TimeRemover tr = integer.gameObject.AddComponent <TimeRemover>(); tr.integerParameter = integer; integer.observers.Add(tr); } else if (method.StartsWith("showScore")) { integer.gameObject.AddComponent <ScoreShower>(); integer.canBeChanged = false; } else if (method.StartsWith("showTime")) { integer.gameObject.AddComponent <TimeShower>(); integer.canBeChanged = false; } else { Debug.LogError("MAPLOADER - ERROR : Unknown Function type for " + method); } }
public void PressiusTestObject_UsingXunitTheory_ShouldCreateMultiple(int id, string name, string address, int?nullableInteger, decimal decimalValues, bool booleanValues, DateTime created) { var integerParams = new IntegerParameter(); var stringParams = new StringParameter(); var booleanParams = new BooleanParameter(); var decimalParams = new DecimalParameter(); _output.WriteLine("Obj: {0} {1} {2} {3} {4} {5} {6}", id, name, address, nullableInteger, decimalValues, booleanValues, created); //integerParams.InputCatalogues.ShouldContain(id); integerParams.InputCatalogues.ShouldContain(nullableInteger); stringParams.InputCatalogues.ShouldContain(name); stringParams.InputCatalogues.ShouldContain(address); booleanParams.InputCatalogues.ShouldContain(booleanValues); decimalParams.InputCatalogues.ShouldContain(decimalValues); }
public void PressiusTestObjectWithConstructor_ShouldPermutate() { var pressiusTestObjectList = Permutor.GenerateWithConstructor <PressiusTestObjectWithConstructor>(); pressiusTestObjectList.ShouldNotBeNull(); var objectList = pressiusTestObjectList.ToList(); objectList.Count.ShouldBeGreaterThan(0); var integerParams = new IntegerParameter(); var stringParams = new StringParameter(); objectList.ForEach(obj => { _output.WriteLine("Obj: {0} {1} {2}", obj.Id, obj.Name, obj.Address); integerParams.InputCatalogues.ShouldContain(obj.Id); stringParams.InputCatalogues.ShouldContain(obj.Name); obj.Address.ShouldBe("Default Address"); }); }
public static void TestBasicConstruction() { string name = "nameasd"; Id <Parameter> id = Id <Parameter> .Parse("C6AE15FF-0242-4289-AADD-F9F71F4CFEBB"); ParameterType type = ParameterType.Parse("86EDCBA3-7807-4DD5-B0E8-0769C52BA0EB"); { IntegerParameter.Definition definition = new IntegerParameter.Definition(min: null, max: null); IntegerParameter p = new IntegerParameter(name, id, type, definition, null); Assert.That(p.Id, Is.EqualTo(id)); Assert.That(p.Name, Is.EqualTo(name)); Assert.That(p.TypeId, Is.EqualTo(type)); Assert.That(p.Min, Is.EqualTo(int.MinValue)); Assert.That(p.Max, Is.EqualTo(int.MaxValue)); } { IntegerParameter.Definition definition = new IntegerParameter.Definition(min: null, max: 45); IntegerParameter p = new IntegerParameter(name, id, type, definition, null); Assert.That(p.Id, Is.EqualTo(id)); Assert.That(p.Name, Is.EqualTo(name)); Assert.That(p.TypeId, Is.EqualTo(type)); Assert.That(p.Min, Is.EqualTo(int.MinValue)); Assert.That(p.Max, Is.EqualTo(45)); } { IntegerParameter.Definition definition = new IntegerParameter.Definition(min: -1232, max: null); IntegerParameter p = new IntegerParameter(name, id, type, definition, null); Assert.That(p.Id, Is.EqualTo(id)); Assert.That(p.Name, Is.EqualTo(name)); Assert.That(p.TypeId, Is.EqualTo(type)); Assert.That(p.Min, Is.EqualTo(-1232)); Assert.That(p.Max, Is.EqualTo(int.MaxValue)); } { IntegerParameter.Definition definition = new IntegerParameter.Definition(min: -34985, max: 34986); IntegerParameter p = new IntegerParameter(name, id, type, definition, null); Assert.That(p.Id, Is.EqualTo(id)); Assert.That(p.Name, Is.EqualTo(name)); Assert.That(p.TypeId, Is.EqualTo(type)); Assert.That(p.Min, Is.EqualTo(-34985)); Assert.That(p.Max, Is.EqualTo(34986)); } }
public static void Test() { string name = "nameasd"; Id <Parameter> id = Id <Parameter> .Parse("C6AE15FF-0242-4289-AADD-F9F71F4CFEBB"); ParameterType type = ParameterType.Parse("86EDCBA3-7807-4DD5-B0E8-0769C52BA0EB"); IntegerParameter.Definition definition = new IntegerParameter.Definition(-100, 100); IntegerParameter p = new IntegerParameter(name, id, type, definition, "2"); TestParameterIs(p, 2); //Test range checking Assert.That(() => p.SetValueAction(-101), Throws.ArgumentException); TestParameterIs(p, 2); Assert.That(() => p.SetValueAction(101), Throws.ArgumentException); TestParameterIs(p, 2); //Test undo/redo var actions = p.SetValueAction(12); Assert.That(actions, Is.Not.Null); TestParameterIs(p, 2); actions.Value.Redo(); TestParameterIs(p, 12); actions.Value.Undo(); TestParameterIs(p, 2); p.TryDeserialiseValue("shane"); TestCorruptParameter(p, "shane"); //Test what happens if we undo back to an invalid state var actions2 = p.SetValueAction(1); actions2.Value.Redo(); TestParameterIs(p, 1); actions2.Value.Undo(); TestCorruptParameter(p, "shane"); p.TryDeserialiseValue("54"); TestParameterIs(p, 54); }
GlowContainer IElementVisitor <ElementToGlowOptions, GlowContainer> .Visit(IntegerParameter element, ElementToGlowOptions state) { var glow = new GlowQualifiedParameter(element.Path); var dirFieldMask = state.DirFieldMask; if (dirFieldMask.HasBits(GlowFieldFlags.Identifier)) { glow.Identifier = element.Identifier; } if (dirFieldMask.HasBits(GlowFieldFlags.Description) && String.IsNullOrEmpty(element.Description) == false) { glow.Description = element.Description; } if (dirFieldMask.HasBits(GlowFieldFlags.Value)) { glow.Value = new GlowValue(element.Value); } if (dirFieldMask == GlowFieldFlags.All) { glow.Minimum = new GlowMinMax(element.Minimum); glow.Maximum = new GlowMinMax(element.Maximum); if (element.IsWritable) { glow.Access = GlowAccess.ReadWrite; } } if ((dirFieldMask == GlowFieldFlags.All) && String.IsNullOrEmpty(element.SchemaIdentifier) == false) { glow.SchemaIdentifiers = element.SchemaIdentifier; } return(glow); }
public void PressiusTestObject_WithValidNameConstructorAndNoObjectDefinition_ShouldPermutateWithCustomValues() { var pressius = new Permutor(); var pressiusTestObjectList = pressius .AddParameterDefinition(new ValidNameWithCompareParamName()) .WithConstructor() .GeneratePermutation <PressiusTestObjectWithConstructor>(); pressiusTestObjectList.ShouldNotBeNull(); pressiusTestObjectList.ToList().Count.ShouldBeGreaterThan(0); var objectList = pressiusTestObjectList.ToList(); var integerParams = new IntegerParameter(); var validName = new ValidNameWithCompareParamName(); objectList.ForEach(obj => { _output.WriteLine("Obj: {0} {1} {2}", obj.Id, obj.Name, obj.Address); integerParams.InputCatalogues.ShouldContain(obj.Id); obj.Address.ShouldBe("Default Address"); validName.InputCatalogues.ShouldContain(obj.Name); }); }
public Dictionary <List <Entity>, IParameter> executePreprocessing(int newSelectionId, int oldSelectionId, int oldParamId, string prepType, int parameterPosition, int newParamId) { models.Parameter oldParam = ((models.Parameter)DatabaseManager.SharedManager.entityById(oldParamId, typeof(models.Parameter))); TypeParameter type; switch (prepType) { case "Линейная нормализация 1 (к float)": type = TypeParameter.Real; break; case "Нелинейная нормализация 2 (к float)": type = TypeParameter.Real; break; case "нормализация 3 (к int)": type = TypeParameter.Int; break; case "бинаризация": type = TypeParameter.Int; break; case "без предобработки": type = oldParam.Type; break; default: type = TypeParameter.Real; break; } List <string> values = new List <string>(); List <Entity> valueParam = new List <Entity>(); List <Entity> oldSelectionRows = SelectionRow.where (new Query("SelectionRow").addTypeQuery(TypeQuery.select) .addCondition("SelectionID", "=", oldSelectionId.ToString()), typeof(SelectionRow)); int index = 0; foreach (Entity entity in oldSelectionRows) { int selectionRowId = entity.ID; List <Entity> list = ValueParameter.where (new Query("ValueParameter").addTypeQuery(TypeQuery.select) .addCondition("ParameterID", "=", oldParamId.ToString()). addCondition("SelectionRowID", "=", selectionRowId.ToString()), typeof(ValueParameter)); valueParam = valueParam.Concat(list).ToList(); values.Add(((ValueParameter)valueParam[index]).Value); index++; } List <Entity> valuesForParameter = new List <Entity>(); IParameter p = null; switch (prepType) { case "Линейная нормализация 1 (к float)": case "Нелинейная нормализация 2 (к float)": case "нормализация 3 (к int)": if (oldParam.Type == TypeParameter.Real) { p = new RealParameter(values); valuesForParameter = normalizeValues(valueParam, p, newParamId, newSelectionId, prepType); } else if (oldParam.Type == TypeParameter.Int) { p = new IntegerParameter(values); valuesForParameter = normalizeValues(valueParam, p, newParamId, newSelectionId, prepType); } else if (oldParam.Type == TypeParameter.Enum) { p = new EnumeratedParameter(values); valuesForParameter = normalizeValues(valueParam, p, newParamId, newSelectionId, prepType); } break; case "бинаризация": valuesForParameter = binarizationValues(valueParam, newParamId, newSelectionId, parameterPosition); break; case "без предобработки": valuesForParameter = processWithoutPreprocessing(valueParam, newParamId, newSelectionId); break; } Dictionary <List <Entity>, IParameter> res = new Dictionary <List <Entity>, IParameter>(); res.Add(valuesForParameter, p); return(res); }
public GraphData(Id <NodeTemp> nodeId, Id <NodeTypeTemp> nodeTypeId, IEnumerable <NodeDataGeneratorParameterData> parameterData) { NodeId = nodeId; NodeTypeId = nodeTypeId; var allConnectorsDefinition = new ConnectorDefinitionData(null, null, null, null, false); var outputs = new List <Output>(); var parameters = new List <IParameter>(); DecimalParameter.Definition d = new DecimalParameter.Definition(null, null); ParameterType decimalType = ParameterType.Basic.Parse("721796b6-a242-4723-82e9-35201097e675"); ParameterType dynamicEnumType = ParameterType.Basic.Parse("6d2d52c8-5934-4ba8-8d4e-7081fe57f662"); DynamicEnumParameter.Source source = new DynamicEnumParameter.Source(); IEnumeration enumeration = new DummyEnumeration(); ParameterType integerEnumType = ParameterType.Basic.Parse("de108fdb-db50-4cd5-aad5-0ea791f04721"); IntegerParameter.Definition i = new IntegerParameter.Definition(null, null); AudioParameter = new AudioParameter("Audio", Id <Parameter> .Parse("3ac8d0ca-c9f6-4e06-b18c-c1366e1af7d3")); BooleanParameter = new BooleanParameter("Boolean", Id <Parameter> .Parse("0e12e8e3-4c95-43a5-a733-d2d1fbbb780c"), "false"); DecimalParameter = new DecimalParameter("Decimal", Id <Parameter> .Parse("765e616a-f165-4053-a15c-14ed593429af"), decimalType, d, "1.0"); DynamicEnumParameter = new DynamicEnumParameter("DynamicEnum", Id <Parameter> .Parse("7c5b019c-79d0-4ef0-b848-0a2c68908f34"), source, dynamicEnumType, "shnae", false); EnumParameter = new EnumParameter("Enum", Id <Parameter> .Parse("e576713b-5d45-48d0-8a4e-661f1fedcafd"), enumeration, enumeration.DefaultValue.ToString()); IntegerParameter = new IntegerParameter("Int", Id <Parameter> .Parse("275d75f3-fe4e-42b1-bfaf-e841ba591999"), integerEnumType, i, "1"); LocalizedStringParameter = new LocalizedStringParameter("Localized stirng", Id <Parameter> .Parse("f332e619-e9a3-421f-9851-d95a00b62da9"), ParameterType.Basic.Parse("4547dbf2-46cc-4c84-ac6e-81ab185575dc")); SetParameter = new SetParameter("Set", Id <Parameter> .Parse("2d6235ea-c8a1-447a-b9d8-692f6329be33"), enumeration, null); StringParameter = new StringParameter("string", Id <Parameter> .Parse("4752d30e-e1ab-47ba-bc15-b2e6ecfa5416")); StringParameter2 = new StringParameter("string2", Id <Parameter> .Parse("dcd4a349-b0a8-4fa3-8989-2d10469b1a17")); if (nodeTypeId == TYPE1) { outputs.Add(new Output(Id <TConnector> .Parse("0956c9d3-c230-49a2-874a-7e3747b58cff"), allConnectorsDefinition, this, null, DummyRules.Instance)); parameters.Add(AudioParameter); parameters.Add(BooleanParameter); parameters.Add(DecimalParameter); parameters.Add(DynamicEnumParameter); parameters.Add(EnumParameter); } else if (nodeTypeId == TYPE2) { outputs.Add(new Output(Id <TConnector> .Parse("da2b4ded-378e-4484-89f0-1328a42f00e3"), allConnectorsDefinition, this, null, DummyRules.Instance)); outputs.Add(new Output(Id <TConnector> .Parse("2bf2ca93-6b81-4a9a-814f-809a8bef332f"), allConnectorsDefinition, this, null, DummyRules.Instance)); parameters.Add(IntegerParameter); parameters.Add(LocalizedStringParameter); parameters.Add(SetParameter); parameters.Add(StringParameter); } else if (nodeTypeId == TYPE3) { outputs.Add(new Output(Id <TConnector> .Parse("c3f67c87-a3fd-428d-90a2-90cb87906eb2"), allConnectorsDefinition, this, null, DummyRules.Instance)); parameters.Add(StringParameter); parameters.Add(StringParameter2); } else { Assert.Fail("Unexpected Id"); } if (parameterData != null) { foreach (var data in parameterData) { parameters.Where(p => p.Id == data.Guid).Single().TryDeserialiseValue(data.Value); } } Connectors = outputs; Parameters = parameters; }
public void IntegerParameter_GreaterThanMaxInt32() { string testValue = "1" + Int32.MaxValue.ToString(); int expectedResult = 0; IntegerParameter testParameter = new IntegerParameter(); Assert.IsFalse(testParameter.HasErrors); testParameter.Text = testValue; Assert.AreEqual(expectedResult, testParameter.Value); Assert.IsTrue(testParameter.HasErrors); }
public void IntegerParameter_MinInt32() { string testValue = Int32.MinValue.ToString(); int expectedResult = Int32.MinValue; IntegerParameter testParameter = new IntegerParameter(); testParameter.Text = testValue; Assert.AreEqual(expectedResult, testParameter.Value); Assert.IsFalse(testParameter.HasErrors); }
public void IntegerParameter_NotAnInteger() { string testValue = "FOO"; int expectedResult = 0; IntegerParameter testParameter = new IntegerParameter(); Assert.IsFalse(testParameter.HasErrors); testParameter.Text = testValue; Assert.AreEqual(expectedResult, testParameter.Value); Assert.IsTrue(testParameter.HasErrors); }
public void IntegerParameter_Value() { IntegerParameter testParameter = new IntegerParameter(); int expectedResult = 0; Assert.AreEqual(expectedResult, testParameter.Value); }
public void IntegerParameter_Text() { IntegerParameter testParameter = new IntegerParameter(); string expectedResult = typeof(Int32).ToString(); Assert.AreEqual(expectedResult, testParameter.Type.ToString()); }
object IElementVisitor <object, object> .Visit(IntegerParameter element, object state) { _onParameter?.Invoke(element); return(null); }
private static void TestCorruptParameter(IntegerParameter p, string valueAsString) { Assert.That(p.Corrupted, Is.True); Assert.That(p.ValueAsString(), Is.EqualTo(valueAsString)); }