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