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