public void ArrayNestedGeneric(string input, string className, int arrayRank1, string genericClassName1, int arrayRank2, string genericClassName2, int arrayRank3)
{
var lexer = new DescriptorLexer(input.AsMemory());
var parser = new FieldDescriptorParser(lexer.Lex());
var descriptor = parser.Parse();
Assert.Equal(arrayRank1, descriptor.ArrayRank);
Assert.IsType <NonPrimitiveFieldDescriptor>(descriptor);
var nonPrimitive = (NonPrimitiveFieldDescriptor)descriptor;
Assert.Equal(className, nonPrimitive.ClassName);
Assert.Equal(1, nonPrimitive.GenericParameters.Count);
Assert.IsType <NonPrimitiveFieldDescriptor>(nonPrimitive.GenericParameters[0]);
Assert.Equal(arrayRank2, nonPrimitive.GenericParameters[0].ArrayRank);
var genericParameter = (NonPrimitiveFieldDescriptor)nonPrimitive.GenericParameters[0];
Assert.Equal(genericClassName1, genericParameter.ClassName);
Assert.Equal(1, genericParameter.GenericParameters.Count);
Assert.IsType <NonPrimitiveFieldDescriptor>(genericParameter.GenericParameters[0]);
Assert.Equal(arrayRank3, genericParameter.GenericParameters[0].ArrayRank);
var genericParameter2 = (NonPrimitiveFieldDescriptor)genericParameter.GenericParameters[0];
Assert.Equal(genericClassName2, genericParameter2.ClassName);
Assert.Empty(genericParameter2.GenericParameters);
}
public void MissingSemicolon()
{
var lexer = new DescriptorLexer("Ljava/lang/Object".AsMemory());
var parser = new FieldDescriptorParser(lexer.Lex());
Assert.Throws <DescriptorParserException>(() => parser.Parse());
}
public void NoGenericParameters()
{
var lexer = new DescriptorLexer("Ljava/util/List<>;".AsMemory());
var parser = new FieldDescriptorParser(lexer.Lex());
Assert.Throws <DescriptorParserException>(() => parser.Parse());
}
public void MissingParameters()
{
var lexer = new DescriptorLexer("V".AsMemory());
var parser = new MethodDescriptorParser(lexer.Lex());
Assert.Throws <DescriptorParserException>(() => parser.Parse());
}
public void ArrayGeneric()
{
var lexer = new DescriptorLexer("([[Ljava/util/Pair<[Lcom/company/CustomStuff;[[[Ljava/lang/String;>;)[[[[Ljava/util/HashMap<Ljava/lang/Integer;Ljava/lang/String;>;".AsMemory());
var parser = new MethodDescriptorParser(lexer.Lex());
var descriptor = parser.Parse();
Assert.Equal(1, descriptor.Parameters.Count);
Assert.IsType <NonPrimitiveFieldDescriptor>(descriptor.Parameters[0]);
Assert.Equal(2, descriptor.Parameters[0].ArrayRank);
var pair = (NonPrimitiveFieldDescriptor)descriptor.Parameters[0];
Assert.Equal("java/util/Pair", pair.ClassName);
Assert.Equal(2, pair.GenericParameters.Count);
Assert.Equal(1, pair.GenericParameters[0].ArrayRank);
Assert.Equal("com/company/CustomStuff", Assert.IsType <NonPrimitiveFieldDescriptor>(pair.GenericParameters[0]).ClassName);
Assert.Equal(3, pair.GenericParameters[1].ArrayRank);
Assert.Equal("java/lang/String", Assert.IsType <NonPrimitiveFieldDescriptor>(pair.GenericParameters[1]).ClassName);
Assert.IsType <NonPrimitiveFieldDescriptor>(descriptor.ReturnType);
var returnType = (NonPrimitiveFieldDescriptor)descriptor.ReturnType;
Assert.Equal(4, returnType.ArrayRank);
Assert.Equal("java/util/HashMap", returnType.ClassName);
Assert.Equal(2, returnType.GenericParameters.Count);
Assert.Equal("java/lang/Integer", Assert.IsType <NonPrimitiveFieldDescriptor>(returnType.GenericParameters[0]).ClassName);
Assert.Equal("java/lang/String", Assert.IsType <NonPrimitiveFieldDescriptor>(returnType.GenericParameters[1]).ClassName);
}
private static void Commence(string input, DescriptorTokenKind tokenKind)
{
var lexer = new DescriptorLexer(input.AsMemory());
var tokens = Utils.GetAllTokens(lexer.Lex());
Assert.Equal(2, tokens.Count);
Assert.True(tokens[0].Kind == tokenKind, $"Expected <{tokenKind}>, but got <{tokens[0].Kind}>.");
}
public void Array(string input, int arrayDimension, DescriptorTokenKind tokenKind)
{
var lexer = new DescriptorLexer(input.AsMemory());
var tokens = Utils.GetAllTokens(lexer.Lex());
Assert.Equal(2 + arrayDimension, tokens.Count);
Assert.Equal(tokenKind, tokens[arrayDimension].Kind);
}
public void Array(string input, int arrayRank, PrimitiveKind primitiveKind)
{
var lexer = new DescriptorLexer(input.AsMemory());
var parser = new FieldDescriptorParser(lexer.Lex());
var descriptor = parser.Parse();
Assert.Equal(arrayRank, descriptor.ArrayRank);
Assert.Equal(primitiveKind, Assert.IsType <PrimitiveFieldDescriptor>(descriptor).Kind);
}
public void ValidIdentifier(string input)
{
var lexer = new DescriptorLexer(input.AsMemory());
var tokens = Utils.GetAllTokens(lexer.Lex());
Assert.Equal(2, tokens.Count);
Assert.Equal(DescriptorTokenKind.Identifier, tokens[0].Kind);
Assert.Equal(input, tokens[0].Value.ToString());
}
public void ValidIdentifierButContainsAngledBrackets()
{
var lexer = new DescriptorLexer("<init>".AsMemory());
var tokens = Utils.GetAllTokens(lexer.Lex());
Assert.Equal(4, tokens.Count);
Assert.True(tokens[0].Kind == DescriptorTokenKind.LeftAngledBracket);
Assert.True(tokens[1].Kind == DescriptorTokenKind.Identifier);
Assert.True(tokens[2].Kind == DescriptorTokenKind.RightAngledBracket);
}
public void Array(string input, string className, int arrayRank)
{
var lexer = new DescriptorLexer(input.AsMemory());
var parser = new FieldDescriptorParser(lexer.Lex());
var descriptor = parser.Parse();
Assert.Equal(arrayRank, descriptor.ArrayRank);
Assert.Equal(className, Assert.IsType <NonPrimitiveFieldDescriptor>(descriptor).ClassName);
Assert.Empty(((NonPrimitiveFieldDescriptor)descriptor).GenericParameters);
}
private static void Commence(string input, DescriptorTokenKind tokenKind, int tokenKindCount)
{
var lexer = new DescriptorLexer(input.AsMemory());
var tokens = Utils.GetAllTokens(lexer.Lex());
Assert.Equal(1 + tokenKindCount, tokens.Count);
Assert.All(tokens, token =>
{
var type = token.Kind;
Assert.True(type == tokenKind || type == DescriptorTokenKind.EndOfFile);
});
}
public void AllNonPrimitive(string input, string[] parameters, string returnType)
{
var lexer = new DescriptorLexer(input.AsMemory());
var parser = new MethodDescriptorParser(lexer.Lex());
var descriptor = parser.Parse();
for (int i = 0; i < descriptor.Parameters.Count; i++)
{
Assert.Equal(parameters[i], Assert.IsType <NonPrimitiveFieldDescriptor>(descriptor.Parameters[i]).ClassName);
}
Assert.Equal(returnType, Assert.IsType <NonPrimitiveFieldDescriptor>(descriptor.ReturnType).ClassName);
}
public void ArrayAllPrimitive(string input, PrimitiveKind[] parameterTypes, int[] parameterArrayRanks, PrimitiveKind returnType, int returnArrayRank)
{
var lexer = new DescriptorLexer(input.AsMemory());
var parser = new MethodDescriptorParser(lexer.Lex());
var descriptor = parser.Parse();
for (int i = 0; i < descriptor.Parameters.Count; i++)
{
Assert.Equal(parameterTypes[i], Assert.IsType <PrimitiveFieldDescriptor>(descriptor.Parameters[i]).Kind);
Assert.Equal(parameterArrayRanks[i], descriptor.Parameters[i].ArrayRank);
}
Assert.Equal(returnType, Assert.IsType <PrimitiveFieldDescriptor>(descriptor.ReturnType).Kind);
Assert.Equal(returnArrayRank, descriptor.ReturnType.ArrayRank);
}
public void Generic(string input, string className, string genericClassName)
{
var lexer = new DescriptorLexer(input.AsMemory());
var parser = new FieldDescriptorParser(lexer.Lex());
var descriptor = parser.Parse();
Assert.Equal(0, descriptor.ArrayRank);
Assert.IsType <NonPrimitiveFieldDescriptor>(descriptor);
var nonPrimitive = (NonPrimitiveFieldDescriptor)descriptor;
Assert.Equal(className, nonPrimitive.ClassName);
Assert.Equal(1, nonPrimitive.GenericParameters.Count);
Assert.IsType <NonPrimitiveFieldDescriptor>(nonPrimitive.GenericParameters[0]);
var genericParameter = (NonPrimitiveFieldDescriptor)nonPrimitive.GenericParameters[0];
Assert.Equal(genericClassName, genericParameter.ClassName);
}
public void EmptyInput()
{
var lexer = new DescriptorLexer("".AsMemory());
Assert.Throws <ArgumentException>(() => lexer.Lex());
}
