public void EnumValueDeprecationReason()
{
// arrange
var source = @"
enum Abc {
A
B @deprecated(reason: ""reason123"")
C
}";
// act
ISchema schema = SchemaBuilder.New()
.AddDocumentFromString(source)
.AddQueryType <DummyQuery>()
.Create();
// assert
EnumType type = schema.GetType <EnumType>("Abc");
IEnumValue value = type.Values.FirstOrDefault(t => t.Name == "B");
Assert.NotNull(value);
Assert.True(value.IsDeprecated);
Assert.Equal("reason123", value.DeprecationReason);
}
public void EnumValueDeprecationReason()
{
// arrange
string source = @"
enum Abc {
A
B @deprecated(reason: ""reason123"")
C
}";
// act
var schema = Schema.Create(source, c =>
{
c.RegisterQueryType <DummyQuery>();
});
// assert
EnumType type = schema.GetType <EnumType>("Abc");
IEnumValue value = type.Values.FirstOrDefault(t => t.Name == "B");
Assert.NotNull(value);
Assert.True(value.IsDeprecated);
Assert.Equal("reason123", value.DeprecationReason);
}
public object GetDeserializedObject(object obj, Type targetType)
{
IEnumValue enumValue = obj as IEnumValue;
if (enumValue != null)
{
return(enumValue.Value);
}
return(obj);
}
private static void VerifySameValue(IEnumValue actual, IEnumValue expected, bool checkMapNameOnly = false)
{
Assert.True(string.Compare(actual.Name, expected.Name) == 0);
if (!checkMapNameOnly)
{
Assert.True(string.Compare(actual.DisplayName, expected.DisplayName) == 0);
Assert.True(actual.IsDefault == expected.IsDefault);
}
}
private static bool EnumValueHandler(YangStatement statement, IEnumValue partial)
{
if (statement.Keyword != "value")
{
return(false);
}
partial.Value = int.Parse(statement.Argument);
return(true);
}
public EnumValueModel(
NameString name,
string?description,
IEnumValue value,
string?underlyingValue)
{
Name = name.EnsureNotEmpty(nameof(name));
Description = description;
Value = value ?? throw new ArgumentNullException(nameof(value));
UnderlyingValue = underlyingValue;
}
private static void VerifySameValue(IEnumValue?actual, IEnumValue expected, bool checkMapNameOnly = false)
{
Assert.NotNull(actual);
Assert.Equal(expected.Name, actual.Name);
if (!checkMapNameOnly)
{
Assert.Equal(expected.DisplayName, actual.DisplayName);
Assert.True(actual.IsDefault == expected.IsDefault);
}
}
static internal int ToEnumValue(object value)
{
if (!value.GetType().IsPrimitive)
{
IEnumValue enumValue = value as IEnumValue;
if (enumValue != null)
{
value = enumValue.Value;
}
}
return(Convert.ToInt32(value));
}
private async Task <bool> GetIsClassLibraryAsync()
{
// Used by default Windows debugger to figure out whether to add an extra
// pause to end of window when CTRL+F5'ing a console application
var configuration = await Properties.GetConfigurationGeneralPropertiesAsync()
.ConfigureAwait(false);
IEnumValue outputType = (IEnumValue)await configuration.OutputType.GetValueAsync()
.ConfigureAwait(false);
return(StringComparers.PropertyValues.Equals(outputType.Name, ConfigurationGeneral.OutputTypeValues.Library));
}
public void Change_Value_Name_With_Attribute()
{
// act
ISchema schema = SchemaBuilder.New()
.AddEnumType <Enum1>()
.ModifyOptions(o => o.StrictValidation = false)
.Create();
// assert
IEnumValue value = schema.GetType <EnumType>("Enum1").Values.First();
Assert.Equal("ABC", value.Name);
}
private static EnumValueDefinitionNode SerializeEnumValue(
IEnumValue enumValue,
ReferencedTypes referenced)
{
var directives = enumValue.Directives
.Select(t => SerializeDirective(t, referenced))
.ToList();
return(new EnumValueDefinitionNode
(
null,
new NameNode(enumValue.Name),
SerializeDescription(enumValue.Description),
directives
));
}
public object Parse(NameValueCollection data, string key, string prefix, out bool succeed)
{
Array array = Array.CreateInstance(typeof(T), 0);
string[] values = BindUtils.GetValues(data, key, prefix);
if (values != null)
{
array = Array.CreateInstance(typeof(T), values.Length);
for (int i = 0; i < values.Length; i++)
{
IEnumValue enumConvert = BindUtils.GetEnumConvert(typeof(T));
array.SetValue(enumConvert.GetValue(values[i], out succeed), i);
}
}
succeed = true;
return(array);
}
public object Parse(NameValueCollection data, string key, string prefix, out bool succeed)
{
string value = BindUtils.GetValue(data, key, prefix);
object result;
if (string.IsNullOrEmpty(value))
{
succeed = true;
result = default(T);
}
else
{
IEnumValue enumConvert = BindUtils.GetEnumConvert(typeof(T));
result = enumConvert.GetValue(value, out succeed);
}
return(result);
}
private bool GetValueTypeValue(System.Collections.Specialized.NameValueCollection data, string Prefix, out object value)
{
IConvert convert = null;
value = null;
Type createtype = Info.ParameterType;
if (Binder != null && Binder.Convert == null && Binder.Fungible != null)
{
createtype = Binder.Fungible;
}
bool succed = false;
if (Binder != null && !string.IsNullOrEmpty(Binder.Prefix))
{
Prefix = Binder.Prefix;
}
if (Binder != null)
{
convert = Binder.GetConvert();
}
if (convert == null)
{
if (BindUtils.Converts.ContainsKey(createtype))
{
convert = BindUtils.Converts[createtype];
}
}
if (convert != null)
{
value = convert.Parse(data, Info.Name, Prefix, out succed);
}
else
{
if (createtype.IsEnum)
{
string pvalue = BindUtils.GetValue(data, Info.Name, Prefix);
IEnumValue evalue = BindUtils.GetEnumConvert(createtype);
value = evalue.GetValue(pvalue, out succed);
}
}
return(succed);
}
public async Task DebugProfileEnumValuesGenerator_TryCreateEnumValueAsyncTests()
{
var testProfiles = new Mock <ILaunchSettings>();
testProfiles.Setup(m => m.ActiveProfile).Returns(() => { return(_profiles[1]); });
testProfiles.Setup(m => m.Profiles).Returns(() =>
{
return(_profiles.ToImmutableList());
});
var moqProfileProvider = new Mock <ILaunchSettingsProvider>();
moqProfileProvider.Setup(p => p.CurrentSnapshot).Returns(testProfiles.Object);
var threadingService = new IProjectThreadingServiceMock();
var generator =
new DebugProfileEnumValuesGenerator(moqProfileProvider.Object, threadingService);
Assert.False(generator.AllowCustomValues);
IEnumValue result = await generator.TryCreateEnumValueAsync("Profile1");
Assert.True(result.Name == "Profile1" && result.DisplayName == "Profile1");
result = await generator.TryCreateEnumValueAsync("MyCommand");
Assert.True(result.Name == "MyCommand" && result.DisplayName == "MyCommand");
// case sensitive check
result = await generator.TryCreateEnumValueAsync("mycommand");
Assert.Null(result);
result = await generator.TryCreateEnumValueAsync("Foo");
Assert.True(result.Name == "Foo" && result.DisplayName == "Foo");
result = await generator.TryCreateEnumValueAsync("Bar");
Assert.True(result.Name == "Bar" && result.DisplayName == "Bar");
}
protected override int SortValues(IEnumValue a, IEnumValue b)
{
return(NaturalStringComparer.Instance.Compare(a.DisplayName, b.DisplayName));
}
private void initializeInstanceValue(IDataType type, Encoding encoding, object targetInstance, Type targetType, object targetMember, byte[] data, int offset)
{
object obj2 = null;
switch (type.Category)
{
case DataTypeCategory.Primitive:
case DataTypeCategory.String:
this._internalConverter.TypeMarshaller.Unmarshal(type, encoding, data, offset, out obj2);
this.initializeInstanceValue(targetInstance, targetMember, obj2);
return;
case DataTypeCategory.Alias:
{
IAliasType type2 = (IAliasType)type;
this.initializeInstanceValue(type2.BaseType, encoding, targetInstance, targetType, targetMember, data, offset);
return;
}
case DataTypeCategory.Enum:
{
IEnumType enumType = (IEnumType)type;
Type managedType = ((IManagedMappableType)enumType.BaseType).ManagedType;
IEnumValue value2 = EnumValueFactory.Create(enumType, data, offset);
if (!targetType.IsEnum)
{
throw new ArgumentException("Type is not an enum type or enum base type!", "type");
}
obj2 = Enum.Parse(targetType, value2.ToString(), true);
this.initializeInstanceValue(targetInstance, targetMember, obj2);
return;
}
case DataTypeCategory.Array:
{
IArrayType type6 = (IArrayType)type;
int arrayRank = targetType.GetArrayRank();
Array array = (Array)targetInstance;
int[] numArray = new int[arrayRank];
int[] numArray2 = new int[arrayRank];
int[] lowerBounds = type6.Dimensions.LowerBounds;
int[] upperBounds = type6.Dimensions.UpperBounds;
for (int i = 0; i < arrayRank; i++)
{
numArray[i] = array.GetLowerBound(i);
numArray2[i] = array.GetUpperBound(i);
}
int position = 0;
while (position < type6.Dimensions.ElementCount)
{
int[] indicesOfPosition = ((ArrayType)type6).GetIndicesOfPosition(position);
int[] indices = new int[indicesOfPosition.Length];
int index = 0;
while (true)
{
if (index >= indicesOfPosition.Length)
{
object obj3 = array.GetValue(indices);
int elementOffset = ((ArrayType)type6).GetElementOffset(indicesOfPosition);
if (obj3 != null)
{
this.initializeInstanceValue(type6.ElementType, encoding, obj3, obj3.GetType(), indices, data, elementOffset);
}
else
{
TwinCAT.Ads.Module.Trace.TraceError("Failed to fill array element!");
}
position++;
break;
}
int num6 = numArray[index] - lowerBounds[index];
indices[index] = indicesOfPosition[index] + num6;
index++;
}
}
return;
}
case DataTypeCategory.Struct:
foreach (IMember member in ((IStructType)type).AllMembers)
{
PropertyInfo property = targetType.GetProperty(member.InstanceName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
if (((property != null) && (property.GetGetMethod() != null)) && (property.GetSetMethod() != null))
{
this.initializeInstanceValue(member.DataType, encoding, targetInstance, targetType, property, data, offset + member.ByteOffset);
continue;
}
FieldInfo field = targetType.GetField(member.InstanceName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
if (field != null)
{
this.initializeInstanceValue(member.DataType, encoding, targetInstance, targetType, field, data, offset + member.ByteOffset);
}
else
{
object[] args = new object[] { member.InstanceName, targetType.ToString() };
TwinCAT.Ads.Module.Trace.TraceWarning("Struct member '{0}' not found within {1}!", args);
}
}
break;
case DataTypeCategory.SubRange:
case DataTypeCategory.Bitset:
break;
case DataTypeCategory.Pointer:
case DataTypeCategory.Reference:
{
int byteSize = ((IReferenceType)type).ByteSize;
return;
}
default:
throw new NotSupportedException();
}
}
protected abstract int SortValues(IEnumValue a, IEnumValue b);
protected override int SortValues(IEnumValue a, IEnumValue b)
{
return(StringComparer.OrdinalIgnoreCase.Compare(a.DisplayName, b.DisplayName));
}
internal int Marshal(IDataType type, Encoding encoding, object val, byte[] bValue, int offset)
{
int num = 0;
Type type2 = val.GetType();
switch (type.Category)
{
case DataTypeCategory.Primitive:
case DataTypeCategory.SubRange:
case DataTypeCategory.String:
num = this._internalConverter.TypeMarshaller.Marshal(type, encoding, val, bValue, offset);
offset += num;
return(num);
case DataTypeCategory.Alias:
{
IAliasType type3 = (IAliasType)type;
return(this.Marshal(type3.BaseType, encoding, val, bValue, offset));
}
case DataTypeCategory.Enum:
{
IEnumType enumType = (IEnumType)type;
if (!type2.IsEnum)
{
throw new ArgumentException("Type is not an enum type!", "type");
}
IEnumValue value2 = EnumValueFactory.Create(enumType, val);
Array.Copy(value2.RawValue, 0, bValue, offset, value2.RawValue.Length);
offset += value2.RawValue.Length;
return(num + value2.RawValue.Length);
}
case DataTypeCategory.Array:
break;
case DataTypeCategory.Struct:
foreach (IMember member in ((IStructType)type).AllMembers)
{
PropertyInfo property = type2.GetProperty(member.InstanceName, BindingFlags.Public | BindingFlags.IgnoreCase);
if (((property != null) && (property.GetGetMethod() != null)) && (property.GetSetMethod() != null))
{
num += this.Marshal(member, property.GetValue(type2, new object[0]), bValue, offset);
continue;
}
FieldInfo field = type2.GetField(member.InstanceName, BindingFlags.Public | BindingFlags.IgnoreCase);
if (field == null)
{
throw new ArgumentException("Struct member not found!", "type");
}
num += this.Marshal(member, field.GetValue(type2), bValue, offset);
}
return(num);
default:
throw new NotSupportedException();
}
IArrayType type6 = (IArrayType)type;
int arrayRank = type2.GetArrayRank();
Array array = (Array)val;
int[] numArray = new int[arrayRank];
int[] numArray2 = new int[arrayRank];
int[] numArray3 = new int[arrayRank];
int[] numArray4 = new int[arrayRank];
int index = 0;
while (true)
{
if (index >= arrayRank)
{
int position = 0;
while (position < type6.Dimensions.ElementCount)
{
int[] indicesOfPosition = ((ArrayType)type6).GetIndicesOfPosition(position);
int[] indices = new int[indicesOfPosition.Length];
int num6 = 0;
while (true)
{
if (num6 >= indicesOfPosition.Length)
{
object obj4 = array.GetValue(indices);
int elementOffset = ((ArrayType)type6).GetElementOffset(indices);
num += this.Marshal(type, encoding, obj4, bValue, offset + elementOffset);
position++;
break;
}
int num7 = numArray[num6] - numArray3[num6];
indices[num6] = indicesOfPosition[num6] + num7;
num6++;
}
}
break;
}
numArray[index] = array.GetLowerBound(index);
numArray2[index] = array.GetUpperBound(index);
numArray3[index] = ((Dimension)type6.Dimensions[index]).LowerBound;
numArray4[index] = ((Dimension)type6.Dimensions[index]).UpperBound;
index++;
}
return(num);
}
public FastFmtInstructionDef(EnumValue code, string mnemonic, IEnumValue flags)
{
Code = code;
Mnemonic = mnemonic;
Flags = flags;
}
