Package com.crawljax.fragmentation

Class FragmentManager

java.lang.Object

com.crawljax.fragmentation.FragmentManager

public class FragmentManager
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	FragmentManager.ACCESS

Field Summary

Fields

Modifier and Type	Field	Description
(package private) ArrayList<Fragment>	fragments	Global list of unique fragments
(package private) HashMap<Integer,Double>	hops
private static org.slf4j.Logger	LOG
(package private) List<Set<StateVertex>>	nearDuplicates	Global map that maintains clusters of states.
private HashMap<Integer,Double>	numNonSelections
private javax.inject.Provider<InMemoryStateFlowGraph>	sfg
(package private) HashMap<StatePair,StatePair>	stateComparisionCache
static FragmentRules	USEFUL_FRAGMENT_RULES

Constructor Summary

Constructors

Constructor	Description
FragmentManager(javax.inject.Provider<InMemoryStateFlowGraph> graphProvider)

Method Summary

Modifier and Type	Method	Description
void	addFragment(Fragment fragment, boolean fast)	Every fragment that is discovered during the crawl will be compared with the global map of unique fragments
private void	addToNearDuplicates(StateVertex state)
private void	addToNearDuplicates(StateVertex newState, StateVertex expectedState)
StatePair.StateComparision	areND2(StateVertex newState, StateVertex expectedState)	Uses mapping of leaf fragments to determine if given two states are near-duplicates
boolean	areRelated(Fragment frag, Fragment frag2)
void	cacheStateComparision(StatePair statePair, boolean assignDynamic)
StatePair.StateComparision	cacheStateComparision(StateVertex newState, StateVertex expectedState, boolean assignDynamic)	The main function that compares two given states and outputs a classification [clone, near-duplicates (ND-data ND-struct), different]
void	cacheStateComparisions(StateVertex newState)
double	calculateCandidateInfluence(CandidateElement candidate)
double	calculateDuplicationFactor(CandidateElement element, StateVertex state)
private double	calculateFragmentCandidateInfluence(Fragment fragment)
private double	calculateHops(Fragment fragment, StateVertex currentState, List<StateVertex> onURLSet)
boolean	compareImages(BufferedImage image1, BufferedImage image2)	Color histogram comparison
private List<Fragment>	getAffectedFragments(List<Node> changedNodes, StateVertex state)	Computes which fragments contain the changed nodes.
List<Fragment>	getAllFragments()
StatePair	getCachedComparision(StateVertex state1, StateVertex state2)
StateVertex	getClosestUnexploredState(StateVertex currentState, List<StateVertex> onURLSet, BlockingQueue<Integer> statesWithCandidates, boolean applyNonSelAdvantage)	Computes the influences of the states based on the influence of candidates and returns the state that has the highest priority Also takes into consideration the back-tracking effort required to reach the state
ArrayList<Fragment>	getDuplicateFragments(Fragment fragment)
ArrayList<Fragment>	getEquivalentFragments(Fragment fragment)
private static int	getFragmentWidth(Fragment fragment)
HashMap<Integer,Integer>	getLeafFragmentMapping(StateVertex state1, StateVertex state2)
static List<Fragment>	getLeafFragments(List<Fragment> fragments)	Leaf fragments are fragments that do not have any useful child fragments
List<Set<StateVertex>>	getNearDuplicates()
private Set<StateVertex>	getNearDuplicates(StateVertex state)
ArrayList<Fragment>	getRelatedFragments(Fragment fragment)
Set<StatePair>	getStateComparisionCache()
private boolean	hasExploredNearDuplicate(StateVertex state)
boolean	recordAccess(CandidateElement element, StateVertex state)	Called after a crawl action is performed.
boolean	recordCoverage(Node node, StateVertex state, VipsUtils.Coverage coverage)	Can be invoked from a coverage plugin to determine how much of the state DOM is covered by test suites
private void	recordDuplicateAccess(CandidateElement element, ArrayList<CandidateElement> coveredCandidates, Fragment closestFragment)
private void	recordEquivalentAccess(CandidateElement element, ArrayList<CandidateElement> coveredCandidates, Fragment closestFragment)
private void	recordNearDuplicateAccess(CandidateElement element, StateVertex state)
void	seenState(StateVertex currentState)	Updates no of times state has not been polled during crawl (Helps prevent crawler getting stuck in similar states)
void	setAccess(StateVertex state)
void	setAccess(Fragment newFragment)	Used to transfer information regarding already performed actions that can have duplicates in this new-fragment
void	setCoverage(Fragment newFragment)
private void	setDynamic(Fragment dyn)
static void	setThresholds(FragmentRules fragRules)
void	stopCrawling()
void	updateInfluence(Fragment fragment, FragmentManager.ACCESS access)	After every action is performed, the priority score or influence is adjusted
static boolean	usefulFragment(Fragment fragment)	To decide if the fragment is large enough to be a functional entity This is an approximation and can be configured using FragmentRules

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

USEFUL_FRAGMENT_RULES

public static FragmentRules USEFUL_FRAGMENT_RULES

LOG

private static final org.slf4j.Logger LOG

fragments

ArrayList<Fragment> fragments

Global list of unique fragments

nearDuplicates

List<Set<StateVertex>> nearDuplicates

Global map that maintains clusters of states. Each entry in the list is a set of states that are near-duplicates to each other

stateComparisionCache

HashMap<StatePair,StatePair> stateComparisionCache

hops

HashMap<Integer,Double> hops

sfg

private javax.inject.Provider<InMemoryStateFlowGraph> sfg

numNonSelections

private final HashMap<Integer,Double> numNonSelections

Constructor Detail

FragmentManager

public FragmentManager(javax.inject.Provider<InMemoryStateFlowGraph> graphProvider)

Method Detail

getFragmentWidth

private static int getFragmentWidth(Fragment fragment)
                             throws XPathExpressionException

Throws:

XPathExpressionException

usefulFragment

public static boolean usefulFragment(Fragment fragment)

To decide if the fragment is large enough to be a functional entity This is an approximation and can be configured using FragmentRules

Parameters:

fragment -

Returns:

getLeafFragments

public static List<Fragment> getLeafFragments(List<Fragment> fragments)

Leaf fragments are fragments that do not have any useful child fragments

Parameters:

fragments -

Returns:

setThresholds

public static void setThresholds(FragmentRules fragRules)

getStateComparisionCache

public Set<StatePair> getStateComparisionCache()

getNearDuplicates

public List<Set<StateVertex>> getNearDuplicates()

getCachedComparision

public StatePair getCachedComparision(StateVertex state1,
                                      StateVertex state2)

cacheStateComparision

public void cacheStateComparision(StatePair statePair,
                                  boolean assignDynamic)

setDynamic

private void setDynamic(Fragment dyn)

setCoverage

public void setCoverage(Fragment newFragment)

setAccess

public void setAccess(Fragment newFragment)

Used to transfer information regarding already performed actions that can have duplicates in this new-fragment

Parameters:

newFragment - a fragment that is being added to the graph

addFragment

public void addFragment(Fragment fragment,
                        boolean fast)

Every fragment that is discovered during the crawl will be compared with the global map of unique fragments

Parameters:

fragment - the fragment to be added

fast - if true, the comparison will be done using the fast comparison algorithm

updateInfluence

public void updateInfluence(Fragment fragment,
                            FragmentManager.ACCESS access)

After every action is performed, the priority score or influence is adjusted

Parameters:

fragment - the fragment that was just visited

access - the type of access that was performed

recordCoverage

public boolean recordCoverage(Node node,
                              StateVertex state,
                              VipsUtils.Coverage coverage)

Can be invoked from a coverage plugin to determine how much of the state DOM is covered by test suites

Parameters:

node - the node to be checked

state - the state to be checked

coverage - the coverage type

Returns:

true if the coverage was recorded, false otherwise

recordAccess

public boolean recordAccess(CandidateElement element,
                            StateVertex state)

Called after a crawl action is performed. Priority of the remaining candidate elements is updated based on their relationship with the action perfomed.

Parameters:

element -

state -

Returns:

recordNearDuplicateAccess

private void recordNearDuplicateAccess(CandidateElement element,
                                       StateVertex state)

recordEquivalentAccess

private void recordEquivalentAccess(CandidateElement element,
                                    ArrayList<CandidateElement> coveredCandidates,
                                    Fragment closestFragment)

recordDuplicateAccess

private void recordDuplicateAccess(CandidateElement element,
                                   ArrayList<CandidateElement> coveredCandidates,
                                   Fragment closestFragment)

getNearDuplicates

private Set<StateVertex> getNearDuplicates(StateVertex state)

setAccess

public void setAccess(StateVertex state)

getDuplicateFragments

public ArrayList<Fragment> getDuplicateFragments(Fragment fragment)

getEquivalentFragments

public ArrayList<Fragment> getEquivalentFragments(Fragment fragment)

getRelatedFragments

public ArrayList<Fragment> getRelatedFragments(Fragment fragment)

getClosestUnexploredState

public StateVertex getClosestUnexploredState(StateVertex currentState,
                                             List<StateVertex> onURLSet,
                                             BlockingQueue<Integer> statesWithCandidates,
                                             boolean applyNonSelAdvantage)

Computes the influences of the states based on the influence of candidates and returns the state that has the highest priority Also takes into consideration the back-tracking effort required to reach the state

Parameters:

currentState -

onURLSet -

statesWithCandidates -

applyNonSelAdvantage -

Returns:

calculateHops

private double calculateHops(Fragment fragment,
                             StateVertex currentState,
                             List<StateVertex> onURLSet)

calculateCandidateInfluence

public double calculateCandidateInfluence(CandidateElement candidate)

calculateFragmentCandidateInfluence

private double calculateFragmentCandidateInfluence(Fragment fragment)

calculateDuplicationFactor

public double calculateDuplicationFactor(CandidateElement element,
                                         StateVertex state)

getLeafFragmentMapping

public HashMap<Integer,Integer> getLeafFragmentMapping(StateVertex state1,
                                                             StateVertex state2)

areND2

public StatePair.StateComparision areND2(StateVertex newState,
                                         StateVertex expectedState)

Uses mapping of leaf fragments to determine if given two states are near-duplicates

Parameters:

newState -

expectedState -

Returns:

compareImages

public boolean compareImages(BufferedImage image1,
                             BufferedImage image2)

Color histogram comparison

Parameters:

image1 -

image2 -

Returns:

cacheStateComparision

public StatePair.StateComparision cacheStateComparision(StateVertex newState,
                                                        StateVertex expectedState,
                                                        boolean assignDynamic)

The main function that compares two given states and outputs a classification [clone, near-duplicates (ND-data ND-struct), different]

Parameters:

newState -

expectedState -

assignDynamic -

Returns:

getAffectedFragments

private List<Fragment> getAffectedFragments(List<Node> changedNodes,
                                            StateVertex state)

Computes which fragments contain the changed nodes. Changed nodes are the result of DOM differencing between two states being compared.

Parameters:

changedNodes -

state -

Returns:

addToNearDuplicates

private void addToNearDuplicates(StateVertex state)

hasExploredNearDuplicate

private boolean hasExploredNearDuplicate(StateVertex state)

addToNearDuplicates

private void addToNearDuplicates(StateVertex newState,
                                 StateVertex expectedState)

getAllFragments

public List<Fragment> getAllFragments()

stopCrawling

public void stopCrawling()

cacheStateComparisions

public void cacheStateComparisions(StateVertex newState)

seenState

public void seenState(StateVertex currentState)

Updates no of times state has not been polled during crawl (Helps prevent crawler getting stuck in similar states)

Parameters:

currentState -

areRelated

public boolean areRelated(Fragment frag,
                          Fragment frag2)