@Test @Ignore public void findTestMethod_2() { List<String> methods = MethodFinder.findTestMethod(User.class, "getUser"); want.collection(methods).sizeEq(1); want.collection(methods).hasAllItems("org.jtester.fortest.hibernate.UserServiceImpl.getUser"); }
private MethodInformation findMatching(String fqn, ArgumentList al, MethodFinder mf) throws IOException { Deque<String> typesToCheck = new ArrayDeque<>(); typesToCheck.addLast(fqn); Set<String> visitedTypes = new HashSet<>(); while (!typesToCheck.isEmpty()) { String clz = typesToCheck.removeFirst(); if (visitedTypes.contains(clz)) continue; visitedTypes.add(clz); List<MethodInformation> ls = mf.getAlternatives(clz); if (ls != null) { for (MethodInformation mi : ls) if (match(al, mi)) return mi; } // not found in current class, try super class Optional<List<String>> o = cip.getSuperTypes(clz); if (o.isPresent() && mf.mayUseSuperclassMethods()) typesToCheck.addAll(o.get()); } return null; }
/** * Creates a new entity of the specified type with the optionally specified initial parameters. * This method actually inserts a row into the table represented by the entity type and returns * the entity instance which corresponds to that row. * * <p>The {@link DBParam} object parameters are designed to allow the creation of entities which * have non-null fields which have no defalut or auto-generated value. Insertion of a row without * such field values would of course fail, thus the need for db params. The db params can also be * used to set the values for any field in the row, leading to more compact code under certain * circumstances. * * <p>Unless within a transaction, this method will commit to the database immediately and exactly * once per call. Thus, care should be taken in the creation of large numbers of entities. There * doesn't seem to be a more efficient way to create large numbers of entities, however one should * still be aware of the performance implications. * * <p>This method delegates the action INSERT action to {@link * DatabaseProvider#insertReturningKey(EntityManager, Connection, Class, String, boolean, String, * DBParam...)}. This is necessary because not all databases support the JDBC <code> * RETURN_GENERATED_KEYS</code> constant (e.g. PostgreSQL and HSQLDB). Thus, the database provider * itself is responsible for handling INSERTion and retrieval of the correct primary key value. * * @param type The type of the entity to INSERT. * @param params An optional varargs array of initial values for the fields in the row. These * values will be passed to the database within the INSERT statement. * @return The new entity instance corresponding to the INSERTed row. * @see net.java.ao.DBParam * @see net.java.ao.DatabaseProvider#insertReturningKey(EntityManager, Connection, Class, String, * boolean, String, DBParam...) */ public <T extends RawEntity<K>, K> T create(Class<T> type, DBParam... params) throws SQLException { T back = null; String table = null; tableNameConverterLock.readLock().lock(); try { table = tableNameConverter.getName(type); } finally { tableNameConverterLock.readLock().unlock(); } Set<DBParam> listParams = new HashSet<DBParam>(); listParams.addAll(Arrays.asList(params)); fieldNameConverterLock.readLock().lock(); try { for (Method method : MethodFinder.getInstance().findAnnotation(Generator.class, type)) { Generator genAnno = method.getAnnotation(Generator.class); String field = fieldNameConverter.getName(method); ValueGenerator<?> generator; valGenCacheLock.writeLock().lock(); try { if (valGenCache.containsKey(genAnno.value())) { generator = valGenCache.get(genAnno.value()); } else { generator = genAnno.value().newInstance(); valGenCache.put(genAnno.value(), generator); } } catch (InstantiationException e) { continue; } catch (IllegalAccessException e) { continue; } finally { valGenCacheLock.writeLock().unlock(); } listParams.add(new DBParam(field, generator.generateValue(this))); } // <ian> Version version = type.getAnnotation(Version.class); if (version != null) { // Initialize version upon creation. String field = version.value(); int initial = version.initial(); listParams.add(new DBParam(field, initial)); } // </ian> } finally { fieldNameConverterLock.readLock().unlock(); } Connection conn = getProvider().getConnection(); try { Method pkMethod = Common.getPrimaryKeyMethod(type); back = peer( type, provider.insertReturningKey( this, conn, Common.getPrimaryKeyClassType(type), Common.getPrimaryKeyField(type, getFieldNameConverter()), pkMethod.getAnnotation(AutoIncrement.class) != null, table, listParams.toArray(new DBParam[listParams.size()]))); } finally { conn.close(); } relationsCache.remove(type); back.init(); return back; }