public FieldMatcher(String name, String type, String role) { super(name, SignatureUtil.createFieldSignature(type), role); }
public MethodMatcher(String name, String params, String returns) { super(name, SignatureUtil.createMethodSignature(params, returns)); }
private static String typeToSignature(String type) { if (type.endsWith("[]")) { return "[" + typeToSignature(type.substring(0, type.length() - 2)); } else { return scalarTypeToSignature(type); } }
public static String createFieldSignature(String type) { if (type == null) { return null; } return typeToSignature(type); }
private static String typeToSignature(String type) { if (type.endsWith("[]")) { return "[" + typeToSignature(type.substring(0, type.length() - 2)); } else { return scalarTypeToSiganture(type); } }
public static String createMethodSignature(String params, String returns) { if (params == null && returns == null) { return null; } String pString, rString; if (params == null) { pString = ".*"; } else { StringBuilder buf = new StringBuilder(); StringTokenizer tok = new StringTokenizer(params, " \t\n\r\f,"); while (tok.hasMoreTokens()) { String param = typeToSignature(tok.nextToken()); buf.append(param); } pString = buf.toString(); } if (returns == null) { rString = ".*"; } else { rString = typeToSignature(returns); } if (params == null || returns == null) { String result = "~\\(" + pString + "\\)" + rString; assert Pattern.compile(result.substring(1)) != null; return result; } else { return "(" + pString + ")" + rString; } }
public MethodMatcher(String name, String params, String returns, String role) { super(name, SignatureUtil.createMethodSignature(params, returns), role); }
public FieldMatcher(String name, String type) { this(name, SignatureUtil.createFieldSignature(type), null); }
public static String createFieldSignature(String type) { if (type == null) { return null; } return typeToSignature(type); }
/** * First parameter is comma-separated value. It is possible to contain space, tab, line-break or line-feed around * comma. Even though first parameter contains multiple values, generated signature does not separate them by comma. */ @Test public void testCreateMethodSignature() { assertThat(SignatureUtil.createMethodSignature("", "void"), is("()V")); assertThat(SignatureUtil.createMethodSignature("byte,\r\nchar, \tboolean", "void"), is("(BCZ)V")); assertThat(SignatureUtil.createMethodSignature("float", "java.lang.String[]"), is("(F)[Ljava/lang/String;")); }
/** * Return {@code null} if given parameter is null, otherwise signature of given type. */ @Test public void testCreateFieldSignature() { assertThat(SignatureUtil.createFieldSignature(null), is(nullValue())); assertThat(SignatureUtil.createFieldSignature("int"), is("I")); assertThat(SignatureUtil.createFieldSignature("double[]"), is("[D")); assertThat(SignatureUtil.createFieldSignature("short[][]"), is("[[S")); }
public static String createMethodSignature(String params, String returns) { if (params == null && returns == null) { return null; } String pString, rString; if (params == null) { pString = ".*"; } else { StringBuilder buf = new StringBuilder(); StringTokenizer tok = new StringTokenizer(params, " \t\n\r\f,"); while (tok.hasMoreTokens()) { String param = typeToSignature(tok.nextToken()); buf.append(param); } pString = buf.toString(); } if (returns == null) { rString = ".*"; } else { rString = typeToSignature(returns); } if (params == null || returns == null) { String result = "~\\(" + pString + "\\)" + rString; assert Pattern.compile(result.substring(1)) != null; return result; } else { return "(" + pString + ")" + rString; } }
/** * If both parameter is null, {@link SignatureUtil#createMethodSignature(String, String)} returns null. However, its * return value should start with {@code ~}, which means regexp. * * @see NameMatch This class uses {@code ~} to judge signature is regexp or not. */ @Test public void testCreateMethodSignatureWithNull() { assertThat(SignatureUtil.createMethodSignature(null, null), is(nullValue())); assertThat(SignatureUtil.createMethodSignature(null, "long"), is("~\\(.*\\)J")); assertThat(SignatureUtil.createMethodSignature("", null), is("~\\(\\).*")); } }
public FieldMatcher(String name, String type) { this(name, SignatureUtil.createFieldSignature(type), null); }
@Test public void testExactMatch() { NameMatch match = new NameMatch(SignatureUtil.createMethodSignature("", "void")); assertTrue(match.match("()V")); assertFalse(match.match("(I)V")); assertFalse(match.match("()J")); }
public FieldMatcher(String name, String type, String role) { super(name, SignatureUtil.createFieldSignature(type), role); }
@Test public void testReturnValuePatternMatch() { NameMatch anyParamReturnVoid = new NameMatch(SignatureUtil.createMethodSignature("", null)); assertTrue(anyParamReturnVoid.match("()V")); assertTrue(anyParamReturnVoid.match("()I")); assertTrue(anyParamReturnVoid.match("()Ljava/lang/String;")); assertFalse(anyParamReturnVoid.match("(B)J")); } }
@Test public void testParameterPatternMatch() { NameMatch anyParamReturnVoid = new NameMatch(SignatureUtil.createMethodSignature(null, "void")); assertTrue(anyParamReturnVoid.match("()V")); assertTrue(anyParamReturnVoid.match("(I)V")); assertTrue(anyParamReturnVoid.match("(Ljava/lang/String;)V")); assertFalse(anyParamReturnVoid.match("()J")); }
public MethodMatcher(String name, String params, String returns) { super(name, SignatureUtil.createMethodSignature(params, returns)); }
public MethodMatcher(String name, String params, String returns, String role) { super(name, SignatureUtil.createMethodSignature(params, returns), role); }