public void TestAuthenticationAttributeFromLoginModule()
{
var attributeReader = new AttributeReader();
var authRequired = attributeReader.ReadAuthenticationFlagFromT <LoginResponse>();
Assert.IsFalse(authRequired);
}
public static bool?ShouldGenericArgumentsBeIncluded(IMethod method)
{
var iga = AttributeReader.ReadAttribute <IncludeGenericArgumentsAttribute>(method);
if (iga != null)
{
return(iga.Include);
}
var imp = AttributeReader.ReadAttribute <ImportedAttribute>(method.DeclaringTypeDefinition);
if (imp != null)
{
return(false);
}
var def = AttributeReader.ReadAttribute <IncludeGenericArgumentsDefaultAttribute>(method.ParentAssembly.AssemblyAttributes);
switch (def != null ? def.MethodDefault : GenericArgumentsDefault.IncludeExceptImported)
{
case GenericArgumentsDefault.IncludeExceptImported:
return(true);
case GenericArgumentsDefault.Ignore:
return(false);
case GenericArgumentsDefault.RequireExplicitSpecification:
return(null);
default:
throw new ArgumentException("Invalid generic arguments default " + def.TypeDefault);
}
}
private JsExpression CompileImportedTypeCheckCode(IType type, ref JsExpression @this, IRuntimeContext context, bool isTypeIs)
{
var def = type.GetDefinition();
if (def == null)
{
return(null);
}
var ia = AttributeReader.ReadAttribute <ImportedAttribute>(def);
if (ia == null || string.IsNullOrEmpty(ia.TypeCheckCode))
{
return(null);
}
// Can ignore errors here because they are caught by the metadata importer
var method = MetadataUtils.CreateTypeCheckMethod(type, _compilation);
var tokens = InlineCodeMethodCompiler.Tokenize(method, ia.TypeCheckCode, _ => {});
int thisCount = tokens.Count(t => t.Type == InlineCodeToken.TokenType.This);
if (!isTypeIs || thisCount > 0)
{
@this = context.EnsureCanBeEvaluatedMultipleTimes(@this, new JsExpression[0]);
}
return(JsExpression.LogicalAnd(
ReferenceNotEquals(@this, JsExpression.Null, context),
InlineCodeMethodCompiler.CompileExpressionInlineCodeMethodInvocation(method, tokens, @this, EmptyList <JsExpression> .Instance, n => { var t = ReflectionHelper.ParseReflectionName(n).Resolve(_compilation); return t.Kind == TypeKind.Unknown ? JsExpression.Null : InstantiateType(t, context); }, t => InstantiateTypeForUseAsTypeArgumentInInlineCode(t, context), _ => {})));
}
public void TestAuthenticationAttributeFromDownloadModule()
{
var attributeReader = new AttributeReader();
var authRequired = attributeReader.ReadAuthenticationFlagFromT <ResumeTaskResponse>();
Assert.IsTrue(authRequired);
}
public void RouteIsCorrect()
{
var route = AttributeReader.GetClassAttribute <RouteAttribute>(typeof(TranslationItemController))
.Template;
route.Should().Be("api/{language:language}/translationitems");
}
public void FieldAttribute()
{
var rd = new AttributeReader();
var attrs = rd.GetAttributes <ColumnAttribute>(MemberHelper.MemberOf <AttributeReaderTest>(a => a.Field1));
Assert.AreEqual(0, attrs.Length);
}
public void FieldAttribute()
{
var rd = new AttributeReader();
var attrs = rd.GetAttributes<ColumnAttribute>(MemberHelper.MemberOf<AttributeReaderTest>(a => a.Field1));
Assert.AreEqual(0, attrs.Length);
}
public void TestNonExistingAuthenticationAttribute()
{
var attrubuteReader = new AttributeReader();
var result = attrubuteReader.ReadAuthenticationFlagFromT <InfoResponse>();
Assert.IsFalse(result, "This should never be set to true if an exception is thrown");
}
public void ReadNext_SingleDateTimeAttribute()
{
var valueDateTime = new DateTime(2018, 2, 11, 17, 50, 0);
var valueString = valueDateTime.ToString(DateTimeValue.Format);
var valueBytes = Encoding.UTF8.GetBytes(valueString);
var headerBytes = new byte[]
{
0x04, 0x00, // type
(byte)'t', (byte)'e', (byte)'s', (byte)'t', 0x00, // name
};
var inputMemoryStream = new MemoryStream();
inputMemoryStream.Write(headerBytes, 0, headerBytes.Length);
inputMemoryStream.Write(valueBytes, 0, valueBytes.Length);
inputMemoryStream.WriteByte(0);
inputMemoryStream.Position = 0;
var reader = new AttributeReader(new BinaryReader(inputMemoryStream));
var attr = reader.Read();
Assert.AreEqual("test", attr.Name);
Assert.AreEqual(valueDateTime, ((DateTimeValue)attr.Value).Value);
Assert.IsNull(reader.Read());
}
public static bool IsReflectable(IMember member, IMetadataImporter metadataImporter)
{
var ra = AttributeReader.ReadAttribute <ReflectableAttribute>(member);
if (ra != null)
{
return(ra.Reflectable);
}
if (member.Attributes.Any(a => metadataImporter.GetTypeSemantics(a.AttributeType.GetDefinition()).Type == TypeScriptSemantics.ImplType.NormalType))
{
return(true); // Any scriptable attribute will cause reflectability (unless [Reflectable(false)] was specified.
}
if (member.DeclaringType.Kind != TypeKind.Anonymous)
{
var tdr = AttributeReader.ReadAttribute <DefaultMemberReflectabilityAttribute>(member.DeclaringTypeDefinition);
if (tdr != null)
{
return(IsMemberReflectable(member, tdr.DefaultReflectability));
}
var adr = AttributeReader.ReadAttribute <DefaultMemberReflectabilityAttribute>(member.ParentAssembly.AssemblyAttributes);
if (adr != null)
{
return(IsMemberReflectable(member, adr.DefaultReflectability));
}
}
return(false);
}
public void ReadNext_TwoAttributes()
{
var input = new MemoryStream(new byte[]
{
0x01, 0x00, // type int
(byte)'t', (byte)'e', (byte)'s', (byte)'t', 0x00, // name
0x78, 0x56, 0x34, 0x12, // value
0x03, 0x00, // type string
(byte)'t', (byte)'m', (byte)'p', 0x00, // name
(byte)'v', (byte)'a', (byte)'l', (byte)'u', (byte)'e', 0x00 // value
});
var reader = new AttributeReader(new BinaryReader(input));
var attr = reader.Read();
Assert.AreEqual("test", attr.Name);
Assert.AreEqual(0x12345678, ((IntValue)attr.Value).Value);
attr = reader.Read();
Assert.AreEqual("tmp", attr.Name);
Assert.AreEqual("value", ((StringValue)attr.Value).Value);
Assert.IsNull(reader.Read());
}
private static void AddToCache <T>(UnitType unitType)
where T : struct, IComparable, IFormattable, IConvertible
{
Type enumType = typeof(T);
int[] a = (int[])Enum.GetValues(enumType);
for (int x = 0; x < a.Length; x++)
{
MemberInfo parentInfo = GetMemberInfo(enumType, Enum.GetName(enumType, x));
string parrentKey = AttributeReader.GetAbbreviation(parentInfo);
for (int i = 0; i < a.Length; i++)
{
if (x == i)
{
continue;
}
MemberInfo info = GetMemberInfo(enumType, Enum.GetName(enumType, i));
string key = string.Format(
CultureInfo.InvariantCulture,
ExpressionFormat,
parrentKey,
AttributeReader.GetAbbreviation(info));
convertionCache.Add(
key, new ConvertionMap(unitType, x, i));
}
}
}
static DisableDirScrubbingTests()
{
VerifierSettings.DontScrubSolutionDirectory();
VerifierSettings.DontScrubProjectDirectory();
var solutionDirectory = AttributeReader.GetSolutionDirectory();
VerifierSettings.AddScrubber(s => s.Replace(solutionDirectory, "CustomReplace\\"));
}
public void ReadNext_EmptyInput()
{
var input = new MemoryStream(new byte[0]);
var reader = new AttributeReader(new BinaryReader(input));
Assert.IsNull(reader.Read());
Assert.IsNull(reader.Read());
}
public void HttpVerbIsCorrect()
{
var verb = AttributeReader.GetMethodAttribute <HttpGetAttribute>(
typeof(TranslationItemController),
nameof(TranslationItemController.GetTranslationItems));
verb.Should().NotBeNull();
}
public void PropertyAttribute()
{
var rd = new AttributeReader();
var attrs = rd.GetAttributes<ColumnAttribute>(MemberHelper.MemberOf<AttributeReaderTest>(a => a.Property1));
Assert.NotNull (attrs);
Assert.AreEqual(1, attrs.Length);
Assert.AreEqual("TestName", attrs[0].Name);
}
public void TestApiAttributeForBaseApi()
{
var attributeReader = new AttributeReader();
var infoApiString = attributeReader.ReadApiNameFromT <InfoResponse>();
var loginApiString = attributeReader.ReadApiNameFromT <LoginResponse>();
Assert.AreEqual("SYNO.API.Info", infoApiString);
Assert.AreEqual("SYNO.API.Auth", loginApiString);
}
public static void Main(string[] args)
{
PPerson p1 = new PPerson("NewYork");
PPerson p2 = new PPerson("London");
AttributeReader <PPerson> .Read(p1);
AttributeReader <PPerson> .Read(p2);
}
public void PropertyAttribute()
{
var rd = new AttributeReader();
var attrs = rd.GetAttributes <ColumnAttribute>(MemberHelper.MemberOf <AttributeReaderTest>(a => a.Property1));
Assert.NotNull(attrs);
Assert.AreEqual(1, attrs.Length);
Assert.AreEqual("TestName", attrs[0].Name);
}
public void TypeAttribute()
{
var rd = new AttributeReader();
var attrs = rd.GetAttributes<TestFixtureAttribute>(typeof(AttributeReaderTest));
Assert.NotNull (attrs);
Assert.AreEqual(1, attrs.Length);
Assert.AreEqual(null, attrs[0].Description);
}
public void RouteIsCorrect()
{
var route = AttributeReader.GetMethodAttribute <HttpGetAttribute>(
typeof(TranslationItemController),
nameof(TranslationItemController.GetTranslationItems))
.Template;
route.Should().BeNull();
}
public void GetDescription()
{
string result = AttributeReader.GetDescription <SpeedUnit>(SpeedUnit.MilePerHour);
Assert.AreEqual("Mile/Hour", result);
result = AttributeReader.GetDescription <SpeedUnit>(SpeedUnit.Knot);
Assert.AreEqual("Knot", result);
}
public void GetAbbreviation()
{
string result = AttributeReader.GetAbbreviation <SpeedUnit>(SpeedUnit.MilePerHour);
Assert.AreEqual("mph", result);
result = AttributeReader.GetAbbreviation <SpeedUnit>(SpeedUnit.Knot);
Assert.AreEqual("knot", result);
}
public void TypeAttribute()
{
var rd = new AttributeReader();
var attrs = rd.GetAttributes <TestFixtureAttribute>(typeof(AttributeReaderTest));
Assert.NotNull(attrs);
Assert.AreEqual(1, attrs.Length);
Assert.AreEqual(null, attrs[0].Description);
}
public void RouteIsCorrect()
{
var route = AttributeReader.GetMethodAttribute <HttpDeleteAttribute>(
typeof(TranslationItemController),
nameof(TranslationItemController.DeleteTranslationItem))
.Template;
route.Should().Be("{key}");
}
public void ReadNext_UnexpectedEndInType()
{
var input = new MemoryStream(new byte[]
{
0x01,
});
var reader = new AttributeReader(new BinaryReader(input));
reader.Read();
}
void StartBlazorApp()
{
var projectDir = Path.Combine(AttributeReader.GetSolutionDirectory(), "BlazorWebApp");
ProcessStartInfo startInfo = new("dotnet", "run --no-build --no-restore")
{
WorkingDirectory = projectDir
};
process = Process.Start(startInfo);
}
public void TestMethodAttributeForBaseApi()
{
var attributeReader = new AttributeReader();
var authMethodName = attributeReader.ReadMethodAttributeFromT <LoginResponse>();
var infoMethodName = attributeReader.ReadMethodAttributeFromT <InfoResponse>();
Assert.AreEqual("query", infoMethodName);
Assert.AreEqual("login", authMethodName);
}
public object Convert(object value, Type targetType, object parameter, string language)
{
if (value is null)
{
return(0);
}
string propertyName = parameter as string;
return(AttributeReader.GetPropertyVatValueValue(value, propertyName));
}
public object Convert(object value, Type targetType, object parameter, string language)
{
if (value is null)
{
return("");
}
string propertyName = parameter as string;
return(Localization.GetLocalizedString(AttributeReader.GetPropertyDescriptionValue(value, propertyName)));
}
public static string GetModuleName(ITypeDefinition type)
{
for (var current = type; current != null; current = current.DeclaringTypeDefinition)
{
var mna = AttributeReader.ReadAttribute <ModuleNameAttribute>(type);
if (mna != null)
{
return(!String.IsNullOrEmpty(mna.ModuleName) ? mna.ModuleName : null);
}
}
return(GetModuleName(type.ParentAssembly));
}
public void ReadNext_InvalidType()
{
var input = new MemoryStream(new byte[]
{
0x00, 0x01, // type
(byte)'t', (byte)'e', (byte)'s', (byte)'t', 0x00, // name
0x78, 0x56, 0x34, 0x12 // value
});
var reader = new AttributeReader(new BinaryReader(input));
reader.Read();
}
private JsType ConvertType(JsClass type)
{
if (type.InstanceMethods.Any(m => m.Name == "runTests"))
{
_errorReporter.Region = type.CSharpTypeDefinition.Region;
_errorReporter.Message(MessageSeverity.Error, 7019, string.Format("The type {0} cannot define a method named 'runTests' because it has a [TestFixtureAttribute].", type.CSharpTypeDefinition.FullName));
return(type);
}
var instanceMethods = new List <JsMethod>();
var tests = new List <Tuple <string, string, bool, int?, JsFunctionDefinitionExpression> >();
foreach (var method in type.InstanceMethods)
{
var testAttr = AttributeReader.ReadAttribute <TestAttribute>(method.CSharpMember);
if (testAttr != null)
{
if (!method.CSharpMember.IsPublic || !method.CSharpMember.ReturnType.IsKnownType(KnownTypeCode.Void) || ((IMethod)method.CSharpMember).Parameters.Count > 0 || ((IMethod)method.CSharpMember).TypeParameters.Count > 0)
{
_errorReporter.Region = method.CSharpMember.Region;
_errorReporter.Message(MessageSeverity.Error, 7020, string.Format("Method {0}: Methods decorated with a [TestAttribute] must be public, non-generic, parameterless instance methods that return void.", method.CSharpMember.FullName));
}
tests.Add(Tuple.Create(testAttr.Description ?? method.CSharpMember.Name, testAttr.Category, testAttr.IsAsync, testAttr.ExpectedAssertionCount >= 0 ? (int?)testAttr.ExpectedAssertionCount : null, method.Definition));
}
else
{
instanceMethods.Add(method);
}
}
var testInvocations = new List <JsExpression>();
foreach (var category in tests.GroupBy(t => t.Item2).Select(g => new { Category = g.Key, Tests = g.Select(x => new { Description = x.Item1, IsAsync = x.Item3, ExpectedAssertionCount = x.Item4, Function = x.Item5 }) }).OrderBy(x => x.Category))
{
if (category.Category != null)
{
testInvocations.Add(JsExpression.Invocation(JsExpression.Member(JsExpression.Identifier("QUnit"), "module"), JsExpression.String(category.Category)));
}
testInvocations.AddRange(category.Tests.Select(t => JsExpression.Invocation(JsExpression.Identifier(t.IsAsync ? "asyncTest" : "test"), t.ExpectedAssertionCount != null ? new JsExpression[] { JsExpression.String(t.Description), JsExpression.Number(t.ExpectedAssertionCount.Value), _runtimeLibrary.Bind(t.Function, JsExpression.This, this) } : new JsExpression[] { JsExpression.String(t.Description), _runtimeLibrary.Bind(t.Function, JsExpression.This, this) })));
}
instanceMethods.Add(new JsMethod(null, "runTests", null, JsExpression.FunctionDefinition(new string[0], new JsBlockStatement(testInvocations.Select(t => new JsExpressionStatement(t))))));
var result = type.Clone();
result.InstanceMethods.Clear();
foreach (var m in instanceMethods)
{
result.InstanceMethods.Add(m);
}
return(result);
}
private IEnumerable<XAttribute> ReadAttributes(int skip = 0)
{
var textBlock = _currentText.ToString().Substring(skip);
var attrReader = new AttributeReader();
foreach (var c in textBlock)
{
switch (c)
{
case '=':
if (attrReader.State == ReadState.ReadName)
{
attrReader.BeginReadText();
}
else
{
attrReader.Text.Append(c);
}
break;
case '\'':
if (attrReader.State == ReadState.ReadText)
{
attrReader.State = ReadState.AposOpen;
}
else
{
if (attrReader.State == ReadState.AposOpen)
{
attrReader.State = ReadState.None;
if (attrReader.SplitIndex > 0)
{
yield return attrReader.ReadAttribute();
}
}
else
{
attrReader.Text.Append(c);
}
}
break;
case '"':
if (attrReader.State == ReadState.ReadText)
{
attrReader.State = ReadState.QuoteOpen;
}
else
{
if (attrReader.State == ReadState.QuoteOpen)
{
attrReader.State = ReadState.None;
if (attrReader.SplitIndex > 0)
{
yield return attrReader.ReadAttribute();
}
}
else
{
attrReader.Text.Append(c);
}
}
break;
case ' ':
if (attrReader.State == ReadState.QuoteOpen || attrReader.State == ReadState.AposOpen)
{
attrReader.Text.Append(c);
}
else
{
if (attrReader.SplitIndex > 0)
{
yield return attrReader.ReadAttribute();
}
}
break;
case '>':
if (attrReader.State == ReadState.QuoteOpen || attrReader.State == ReadState.AposOpen)
{
attrReader.Text.Append(c);
}
else
{
if (attrReader.State == ReadState.ReadText)
{
attrReader.State = ReadState.None;
if (attrReader.SplitIndex > 0)
{
yield return attrReader.ReadAttribute();
}
}
}
break;
default:
if (attrReader.State == ReadState.None) attrReader.State = ReadState.ReadName;
attrReader.Text.Append(c);
break;
}
}
yield break;
}
