public void testLabelMiner() throws IOException, JSONException, ParseException {
LabelHandler handler = new LabelHandler();
Miner miner = new Miner(handler);
miner.setStartDate(new FdaDate("20140808"));
miner.processDay();
}
public void testEventMiner() throws IOException, JSONException, ParseException {
EventHandler handler = new EventHandler();
Miner miner = new Miner(handler);
miner.setStartDate(new FdaDate("20140115"));
miner.processDay();
}
/**
* Create a concrete miner to extract the informations of evolution. Each supported system have to
* have your own miner, IPROJECT, REDMINE, SIGPRoject, etc...
*
* @param systemName
* @return
*/
public Miner getMiner(
String minerName,
String workDirectoryPath,
MergeSide mergeSide,
boolean systemOnLineModel,
boolean repositoryOnlineModel) {
if (StringUtils.isEmpty(minerName)) return null; // support half side miner
Properties prop = new Properties();
try {
// I think that this also should be in the config file, this is hardcode
URL url = new URL("platform:/plugin/br.ufrn.spl.ev/src/br/ufrn/spl/ev/miners.properties");
InputStream inputStream = url.openConnection().getInputStream();
prop.load(inputStream);
Miner miner = (Miner) Class.forName(prop.getProperty(minerName)).newInstance();
// OBSERVATION.: RepositoryConnector is always "true" in the miner, we don't find out a way to
// do this offline
if (miner instanceof IprojectMiner) {
miner.setSystemConnector(
new ConnectorFactory()
.getSystemConnector("IPROJECT", workDirectoryPath, mergeSide, systemOnLineModel));
miner.setRepositoryConnector(
new ConnectorFactory().getRepositoryConnector(mergeSide, repositoryOnlineModel));
}
if (miner instanceof RedmineMiner) {
miner.setSystemConnector(
new ConnectorFactory()
.getSystemConnector("REDMINE", workDirectoryPath, mergeSide, systemOnLineModel));
miner.setRepositoryConnector(
new ConnectorFactory().getRepositoryConnector(mergeSide, repositoryOnlineModel));
}
if (miner instanceof SIGProjectMiner) {
miner.setSystemConnector(
new ConnectorFactory()
.getSystemConnector("SIGPROJECT", workDirectoryPath, mergeSide, systemOnLineModel));
miner.setRepositoryConnector(
new ConnectorFactory().getRepositoryConnector(mergeSide, repositoryOnlineModel));
}
if (miner instanceof GithubMiner) {
miner.setSystemConnector(
new ConnectorFactory()
.getSystemConnector("GITHUB", workDirectoryPath, mergeSide, systemOnLineModel));
miner.setRepositoryConnector(
new ConnectorFactory().getRepositoryConnector(mergeSide, repositoryOnlineModel));
}
return miner;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
@SuppressWarnings("unused")
public static void main(String[] args) throws UnknownExpressionException {
String rootPath = args[0];
File rootFile = new File(rootPath);
Miner miner = new Miner();
miner.mine(rootFile);
for (Type type : miner.getMinedTypes()) {
if (!type.toString().equals("HttpRoute")) {
logger.debug("Skipping type: {}", type);
continue;
}
logger.debug("Analyzing uses of: {}", type);
Set<ClassDeclaration> decs = miner.getClassDecs(type);
List<ConcreteUse> concreteUses = new LinkedList<>();
for (ClassDeclaration dec : decs) {
List<ConcreteUse> uses = ConcreteUse.extractUses(type, dec);
/*
* for(ConcreteUse c: uses){ if(c.getCFG().asList().size() >0)
* concreteUses.add(c); }
*/
concreteUses.addAll(uses);
}
logger.debug("Analyzing uses of: {} concrete uses", concreteUses.size());
for (ConcreteUse use : concreteUses) {
logger.debug("{}", use);
}
// if more than n, then cluster them
List<List<ConcreteUse>> clusters = ConcreteUseClusterer.cluster(concreteUses);
// abstract each cluster, then print it
List<AbstractUse> abstractUses = new LinkedList<>();
for (List<ConcreteUse> cluster : clusters) {
AbstractUse use = AbstractUse.abstractUse(cluster);
logger.debug("{}", use);
}
return;
}
}
private static MinedCounter runStrategy(
BlockMap blockMap, int mineLength, List<Vector> starts, int branchOffset, int branches) {
MinedCounter mined = new MinedCounter();
for (Vector start : starts) {
Miner miner = new Miner(blockMap.clone());
for (int x = 0; x < branches; x++) {
Vector currentStart =
new Vector(start.getX() + x * branchOffset, start.getY(), start.getZ());
miner.run(currentStart, new Point(0, 1), mineLength);
}
// System.out.println(String.format("Iteration %d", i + 1));
// System.out.println(miner.getMined());
mined.addAll(miner.getMined());
}
mined.average(starts.size());
return mined;
}
public void render(Miner miner) {
Vector adjustedPosition = miner.position().add(viewPoint);
int x = (int) adjustedPosition.x();
int y = (int) adjustedPosition.y();
AffineTransform orig = graphics.getTransform();
AffineTransform rot =
AffineTransform.getRotateInstance(miner.heading().x(), miner.heading().y(), x, y);
graphics.transform(rot);
graphics.drawRect(
x - (int) miner.boundingRadius(),
y - ((int) miner.boundingRadius() / 2),
(int) miner.boundingRadius() * 2,
(int) miner.boundingRadius());
graphics.setTransform(orig);
renderHealthBar(miner, x, y);
renderEnergyBar(miner, x, y);
}
// @param turns the amount of turns that the budget was saved up for
// @param progress the progress that we are in the build order
public void updateBudgetingForBuildOrderProgress(int turns, int oreMined, int progress)
throws GameActionException {
int remainingOre = oreMined;
// check if we need to take some for the supply depots
if (progress >= this.civicRatios.length - 1) {
if (this.broadcaster.budgetForType(RobotType.SUPPLYDEPOT) < 250) {
this.broadcaster.incrementBudget(RobotType.SUPPLYDEPOT, (int) (remainingOre * 0.1));
remainingOre *= 0.9;
}
}
// firstly check the beavers
final int beavers = this.broadcaster.robotCountFor(Beaver.type());
int beaverOreAllocation = 0;
if (beavers == 0) {
beaverOreAllocation = 100;
}
// miners
final int minerFactories = this.broadcaster.robotCountFor(MinerFactory.type());
int minerOreAllocation = 0;
if (minerFactories > 0 && this.broadcaster.robotCountFor(Miner.type()) < 30) {
minerOreAllocation = (60 / (20 / turns));
if (this.broadcaster.budgetForType(Miner.type()) >= minerFactories * 60)
minerOreAllocation = 0;
}
// launchers
final int aerospaceLabs = this.broadcaster.robotCountFor(AerospaceLab.type());
int launcherOreAllocation = aerospaceLabs * (400 / (100 / turns));
if (this.broadcaster.budgetForType(Launcher.type()) >= aerospaceLabs * 400)
launcherOreAllocation = 0;
// drones
int droneOreAllocation = 0;
if (Clock.getRoundNum() > 600 && this.broadcaster.robotCountFor(Drone.type()) == 0) {
droneOreAllocation = 8;
}
int total =
beaverOreAllocation + minerOreAllocation + launcherOreAllocation + droneOreAllocation;
double multiplier = (total > remainingOre) ? remainingOre / (float) total : 1.0;
this.broadcaster.incrementBudget(Beaver.type(), (int) (beaverOreAllocation * multiplier));
this.broadcaster.incrementBudget(Miner.type(), (int) (minerOreAllocation * multiplier));
this.broadcaster.incrementBudget(Launcher.type(), (int) (launcherOreAllocation * multiplier));
this.broadcaster.incrementBudget(Drone.type(), (int) (droneOreAllocation * multiplier));
remainingOre -= total * multiplier;
if (remainingOre > 40 && oreMined < 500 /* first turn */) {
beaverOreAllocation = 10;
this.broadcaster.incrementBudget(Beaver.type(), beaverOreAllocation);
remainingOre -= beaverOreAllocation;
}
this.broadcaster.incrementCivicBudget(remainingOre);
}
@Test
public void test() {
SessionFactory.initializeForTest();
LabelHandler handler = new LabelHandler();
Miner miner = new Miner(handler);
try {
///////////////////////// test miner.query() ///////////////////////////
// Negative test of query()
String answer = Miner.query(FAIL_URL);
assertNull(answer); // Note that query date above must be set to future date.
// Positive test of query()
answer = Miner.query(GOOD_URL);
assertNotNull(answer);
// get dirty entry
JSONObject obj = new JSONObject(answer);
JSONArray results = obj.optJSONArray("results");
assertNotNull(results);
JSONObject dirty = results.optJSONObject(0);
assertNotNull(dirty);
///////////////////////// test miner.cleanEntries() ///////////////////////////
// get clean entry
JSONArray cleanList = miner.cleanEntries(answer);
assertNotNull(cleanList);
JSONObject clean = cleanList.optJSONObject(0);
assertNotNull(clean);
boolean fMissing =
TestLabelHandler.validateRequired(dirty, clean, LabelHandler.REQ_ROOT_KEYS);
if (fMissing) {
assertNull(clean);
return;
}
JSONObject fda = dirty.optJSONObject("openfda");
if (fda == null) {
assertNull(clean);
return;
}
fMissing = TestLabelHandler.validateRequired(fda, clean, LabelHandler.REQ_FDA_KEYS);
if (fMissing) {
assertNull(clean);
return;
}
assertNotNull(clean);
/*
///////////////////////// test miner.saveCleanList() ///////////////////////////
long startCount = miner.getCollection().count();
miner.saveCleanList( cleanList );
long count = miner.getCollection().count();
assertTrue( startCount < count );
*/
} catch (IOException e) {
e.printStackTrace();
} catch (JSONException e) {
e.printStackTrace();
}
}
