def main():				
	global ntests,start
	while time.time()-start < timeout:
		
		for ts in xrange(0,width):
			sut.restart()
			ntests += 1
			if (Stest != None ) and (r.random() > 0.6):
				sut.backtrack(Stest)
		
			randomAction()
		
		for b in sut.currBranches():
			if b not in covCount:
				covCount[b] = 0
			covCount[b] += 1
			sortedCov = sorted(covCount.keys(), key = lambda x: covCount[x]) 
			LCov = sortedCov[0]
		
    		if time.time()-start > timeout:
        		print "THE TEST IS STOPPED SINCE TIMEOUT"
        		break 

	sortedCov = sorted(covCount.keys(), key = lambda x: covCount[x])		

	if coverage:
		print"Show Coverage"
        	sut.internalReport()
	
	print ntests,"TOTAL TESTS"    
	print "TOTAL BUGS",bugs
	print "TOTAL ACTIONS",actCount
	print "TOTAL RUNTIME",time.time()-start

def action():
    global actCount, bugs, failPool
    act = sut.randomEnabled(rgen)
    actCount += 1
    ok = sut.safely(act)
    if running == 1:
            if len(sut.newBranches()) > 0:
                print "ACTION:", act[0]
                for b in sut.newBranches():
                    print time.time() - start, len(sut.allBranches()), "New branch", b
                for s in sut.newStatements():
                    print time.time() - start, len(sut.allStatements()),"New statement",s
    
    if not ok:
        if faults:
            bugs += 1
            print "FOUND A FAILURE"
            print sut.failure()
            print "REDUCING"
            failPool.append(sut.test())
            collectCoverage()
            R = sut.reduce(sut.test(),sut.fails, True, True)
            sut.prettyPrintTest(R)
            print sut.failure()
            fname="failure" + str(bugs) + ".test"
            sut.saveTest(sut.test(),fname)
            errorSeqs.append(sut.currStatements())
            sut.restart()
    else: 
        expand()

    return ok

def randomAction():   
	global actCount,bugs,j,running,actCount,r
    
	test = False
	for b in xrange(0,depth):
		act = sut.randomEnabled(r)   
#		actCount += 1
		ok = sut.safely(act)
		Scheck = sut.check()
		if len(sut.newBranches()) > 0:
			Stest = sut.state()
			test = True
			
		if (not test) and (LCov != None) and (LCov in sut.currBranches()):
			Stest = sut.start()
			test = True
		actCount += 1
		
		if running == 1:
	        	if sut.newBranches() != set([]):
				print "ACTIONS:", act[0]
            			for b in sut.newBranches():
                			print time.time()-start,len(sut.allBranches()),"New branch",b
				
                if faults == 1:    
			if not ok: 
				print "FOUND A FAILURE"
				j += 1
				bugs += 1
				fault = sut.failure()
				failurename = 'failure' + str(bugs) + '.test'
				sut.saveTest(sut.test(), failurename)
				print"the bugs is ",j
				sut.restart()

def phase1(timeLimit):
    global ntest
    BUDGET = timeLimit
    DEPTH = opts.depth
    print "-------------------------------------------"
    print "PHASE 1: Starting\t(BUDGET:",BUDGET,"seconds,","DEPTH:",DEPTH,"tests)"
    phase_start = time.time()
    phase_test = ntest

    pool = Pool("randomPool")
    
    elapsed = time.time()-phase_start
    while elapsed < BUDGET and (time.time() - start) < opts.timeout:
        sut.restart()
        ntest += 1
        if opts.progress and ntest % 300:
            update_progress(elapsed/BUDGET)
        for s in xrange(0,DEPTH):
            if not randomAction(pool):
                break
        collectCoverage() # collecting coverage at the end of each test
        elapsed = time.time()-phase_start
    if opts.progress:
        update_progress(1.0)
    
    interval = time.time()-phase_start
    print "PHASE 1: Ending\t\t(EXECUTED:",(ntest - phase_test),"tests, USED:",round(interval,5),"seconds)"
    print "-------------------------------------------"
    return pool

def randomAction():
    global actCount, bugs, coverageCount, belowMean,lastAddCoverage

    act = sut.randomEnabled(random.Random())
    actCount += 1
    ok = sut.safely(act)

    if running:
        if len(sut.newBranches()) > 0:
            print "ACTION:",sut.randomEnabled(random.Random(seed))[0]
            for b in sut.newBranches():
                print time.time() - start, len(sut.allBranches()),"New branch",b
            for s1 in sut.newStatements():
                print time.time() - start, len(sut.allStatements()),"New statement",b

    if not ok or not sut.check():
        bugs += 1
        print "FOUND A FAILURE"
        if faults:
            print("SHOW FAULT")
            print sut.failure()
            error.append(sut.test())
            R = sut.reduce(sut.test(),sut.fails, True, True)
            sut.prettyPrintTest(R)
            print sut.failure()
            sut.restart()

    return ok

def main():
    global ntests
    while time.time()-start < timeout:
        for ts in xrange(0,width):
            sut.restart()
            ntests += 1
              
            loopBug()
          
            for s in sut.currBranches():
                if s not in covCount:
                    covCount[s] = 0
                covCount[s] += 1    
                sortedCov = sorted(covCount.keys(), key=lambda x: covCount[x])
                LCov= sortedCov[0]
        
            if (time.time() - start > timeout):
				print "THE TEST IS STOPPED SINCE TIMEOUT"
                                break
				
    sortedCov = sorted(covCount.keys(), key=lambda x: covCount[x])
    if coverage == 1:
	print "SHOW COVERAGE"
        sut.internalReport()
	
	print ntests, "TOTAL TESTS"
    print "TOTAL BUGS",bugs
    print "TOTAL ACTIONS",actCount
    print "TOTAL RUNNINGTIME",time.time()-start

def randomAction():   
    global actCount, bugs, fails, errCount, newCount
    sawNew = False
    act = sut.randomEnabled(seeds)
    actCount += 1
    ok = sut.safely(act)
    propok = sut.check()
   
    if running:
        if sut.newBranches() != set([]):
            for b in sut.newBranches():
                print time.time()-start,len(sut.allBranches()),"New branch",b
            sawNew = True
            newCount += 1
        else:
            sawNew = False    

    if not ok or not propok:
        if faults:
            bugs += 1
            fail.append(sut.test())
            saveCover()
            sut.restart()
            print "FAILURE FOUND.....FAILURES ARE STORING IN FILES"
            errCount += 1
            fault = sut.failure()
            fname = 'failure' + str(bugs) + '.test'
            sut.saveTest(sut.test(), fname)
            sut.restart() 

    else:
        expandPool()
    return ok 

def action():
    global actCount, bugs, failPool
    act = sut.randomEnabled(rgen)
    actCount += 1
    ok = sut.safely(act)
    if running == 1:
            if len(sut.newBranches()) > 0:
                print "ACTION:", act[0]
                for b in sut.newBranches():
                    print time.time() - start, len(sut.allBranches()), "New branch", b
    if faults:
        if not ok:
            bugs += 1
            print "FOUND A FAILURE"
            print sut.failure()
            print "REDUCING"
            failPool.append(sut.test())
            collectCoverage()
            R = sut.reduce(sut.test(),sut.fails, True, True)
            sut.prettyPrintTest(R)
            print sut.failure()
            
            f = open(("failure" + str(bugs) + ".test"),"w")
            f.writelines(str(sut.failure()))
            f.close()
            
            sut.restart()
        else:
            expand()
    
    return ok

def phase2(randomPool, selectPool):
    global ntest
    DEPTH = opts.depth
    print "PHASE 2: Starting\t(FILTER SET:", len(selectStatements),"DEPTH:",DEPTH,"tests)"
    phase_start = time.time()
    phase_test = ntest

    mean = calculateMean(selectStatements)
    initialMean = mean

    while mean < threshold and (time.time() - start) < opts.timeout:
        sut.restart()
        test = selectPool.getRandom()
        #sut.replay(test[0])
        sut.backtrack(test[1])
        ntest += 1
        if opts.progress and ntest % 10:
            update_progress((mean - initialMean)/threshold)
        for s in xrange(0,DEPTH):
            if not randomAction(selectPool):
                break
        mean = calculateMean(selectStatements)
        collectCoverage() # collecting coverage at the end of each test
    if opts.progress:
        update_progress(1.0)
    
    interval = time.time()-phase_start
    print "PHASE 2: Ending\t\t(EXECUTED:",(ntest - phase_test),"tests, USED:",round(interval,5),"seconds)"
    print "-------------------------------------------"

def main():
    global flag,timeout,sut,test,para,currStatements,coverageNum,sortedCov,weight,weightedCov,coverageWBM,bugs,actNum,start
    while time.time()-start < timeout:
        sut.restart()
        if (test != None):
            if (rgen.random() > exp):
                sut.backtrack(test)
        para = False
        for s in xrange(0,lenth):
            tester()
            if flag == 1:
                break
        for s in sut.currStatements():
            if s not in coverageNum:
                coverageNum[s] = 0
            coverageNum[s] += 1
        sortedCov = sorted(coverageNum.keys(), key=lambda x: coverageNum[x])
        for c in sortedCov:
            weightedCov = c * (lenth - coverageNum[c])
            if weightedCov > 20:
                coverageWBM.append(weightedCov)
                print c
    sut.internalReport()
    for s in sortedCov:
        print s, coverageNum[s]


    print bugs,"Failures have been found"
    print "TOTAL ACTIONS",actNum
    print "TOTAL RUNTIME",time.time()-start

def main():
    global flag,timeout,sut,test,para,currStatements,coverageNum,sortedCov,weight,weightedCov,coverageWeightedBelowMean,bugs,actNum,start
    while time.time()-start < timeout:
        sut.restart()
        if (test != None):
            if (rgen.random() > 0.4):
                sut.backtrack(test)
        para = False

        print "Testing"
        for s in xrange(0,100):
            tester()
            if flag == 1:
                break
        for s in sut.currStatements():
            if s not in coverageNum:
                coverageNum[s] = 0
            coverageNum[s] += 1
        sortedCov = sorted(coverageNum.keys(), key=lambda x: coverageNum[x])
        print "Coverage"
        for c in sortedCov:
            weight = (100 - coverageNum[c])
            weightedCov = c * weight
            if weightedCov > 25:
                coverageWeightedBelowMean.append(weightedCov)
                print c

    sut.internalReport()
    for s in sortedCov:
        print s, coverageNum[s]

    print bugs,"BUGS"
    print "TOTAL ACTIONS",actNum
    print "TOTAL RUNTIME",time.time()-start

def randomAction():
    global actCount, bugs,newseq,currseq
    act = sut.randomEnabled(R)
    actCount += 1
    ok = sut.safely(act)

    if running:
        if len(sut.newBranches()) > 0:
            print "ACTION:",sut.randomEnabled(random.Random(seed))[0]
            for b in sut.newBranches():
                print time.time() - start, len(sut.allBranches()),"New branch",b
            for s1 in sut.newStatements():
                print time.time() - start, len(sut.allStatements()),"New statement",s1

    if not ok:
        bugs += 1
        print "FOUND A FAILURE"

        if faults:
            f = sut.reduce(sut.test(), sut.fails, True, True)
            sut.prettyPrintTest(f)
            currseq.append((f,set(sut.currStatements())))
            print("SHOW FAULT")
            file = 'failure' + str(actCount) + '.test'
            sut.saveTest(sut.test(), file)
            sut.restart()
            print sut.failure()

    return ok

def main():
	global config, R, sut, bugs, actCount, branchCount, statementCount, ntest, start

	parsed_args, parser = parse_args()
	config = make_config(parsed_args, parser)
	print('Testing using config={}'.format(config))

	R = random.Random(config.seed)
	sut = sut.sut()

	sut.silenceCoverage()
	
	bugs = 0
	actCount = 0
	coverageCount = {}
	branchCount = {}
	statementCount = {}
	ntest = 0

	start = time.time()
	elapsed = time.time() - start
	
	print "Starting Test"
	while elapsed < config.timeout:
		sut.restart()
		ntest += 1
		for i in xrange(0, config.depth):
			if not randomAct():
				break
			elapsed = time.time() - start
			if config.running:
				showRunning()
			elapsed = time.time() - start
			if elapsed > config.timeout:
				print "Stopping test [TIMEOUT]"
				break
		collectCoverage()
		elapsed = time.time() - start
	print "Finishing Test"

	if time.time() - start > config.timeout:
		print "[TIMEOUT]"

	printCoverage()

	if config.coverage:
		sut.internalReport()

	print "Covered", len(sut.allBranches()), "branches"
	print "Covered", len(sut.allStatements()), "statements"
	
	print "Failed", bugs, "times"
	print "Total tests", ntest
	print "Total actions", actCount
	print "Total runtime", time.time() - start

def failures():
	bugs += 1
	print "FOUND A FAILURE"
	print sut.failure()
	print "REDUCING"
	failPool.append(sut.test())
	collectCoverage()
	R = sut.reduce(sut.test(),sut.fails, True, True)
	sut.prettyPrintTest(R)
	print sut.failure()
	sut.restart()

def main():
	global config,rgen,actCount,failCount,ntests,coverageCount

	parsed_args, parser = parse_args()
	config = make_config(parsed_args, parser)
	rgen = random.Random(config.seed)

	actCount = 0
	failCount = 0
	coverageCount = {}

	start = time.time()
	ntests = 0
	while True:
		elapsed = time.time() - start
		if elapsed > config.timeout:
			print "STOPPING TEST DUE TO TIMEOUT, TERMINATED AT LENGTH",ntests
			break

		for i in xrange(0, config.depth):
			sut.restart()
			ntests += 1
			for j in xrange(0, config.width):
				act = sut.randomEnabled(rgen)
				actCount += 1
				ok = sut.safely(act)
				if not ok:
					failCount += 1
					print "FOUND A FAILURE"
					collectCoverage()
					R = sut.reduce(sut.test(),sut.fails, True, True)
					sut.prettyPrintTest(R)
					print sut.failure()
					break

				if config.running:
					if sut.newBranches() != set([]):
						for b in sut.newBranches():
							print time.time()-start, len(sut.allBranches()), "New branch", b
					if sut.newStatements() != set([]):
						for s in sut.newStatements():
							print time.time()-start,len(sut.allStatements()),"New statement",s

		collectCoverage()	

	if config.faults:
		print "TOTAL FAULTS", failCount

	if config.coverage:
		print len(sut.allBranches()),"BRANCHES COVERED"
		print len(sut.allStatements()),"STATEMENTS COVERED"
	
	print "TOTAL ACTIONS",actCount
	print "TOTAL RUNTIME",time.time()-start

def failure():
	global bugs
	bugs += 1
	collectCoverage()
	R = sut.reduce(sut.test(), sut.fails, True, True)
	if config.faults :
		filename = 'failure%d.test'%bugs
		sut.saveTest(sut.test(), filename)
	sut.prettyPrintTest(R)
	sut.restart()
	return

def execute(statement):
    ok = sut.safely(statement)
    if not ok:
        if (opts.fault):
            captureFault()
        else:
            print "FAILURE LOCATED"
        sut.restart()
    if opts.plotting:
        capturePlotData()
    if opts.running:
        runtimeCoverage()

def main():
	global config,rgen,actCount,failCount,ntests,fullPool

	parsed_args, parser = parse_args()
	config = make_config(parsed_args, parser)
	rgen = random.Random(config.seed)

	actCount = 0
	failCount = 0
	fullPool = []

	start = time.time()
	ntests = 0
	while time.time() - start < config.timeout:
		ntests += 1
		sut.restart()
		for d in xrange(0, config.depth):
			act = sut.randomEnabled(rgen)
			actCount += 1

			ok = sut.safely(act)
			expandPool()
			if config.running:
				if sut.newBranches() != set([]):
					for b in sut.newBranches():
						print time.time()-start, len(sut.allBranches()), "New branch", b
				if sut.newStatements() != set([]):
					for s in sut.newStatements():
						print time.time()-start, len(sut.allStatements()),"New statement",s

			if not ok:
				failCount += 1
				if config.faults:
					failureHandle(failCount)
				print "FOUND A FAILURE"
				R = sut.reduce(sut.test(),sut.fails, True, True)
				sut.prettyPrintTest(R)
				print sut.failure()
				sut.restart()
				break

			if time.time() - start > config.timeout:
				print "STOPPING TEST DUE TO TIMEOUT, TERMINATED AT LENGTH",ntests
				break

	if config.faults:
		print "TOTAL FAULTS", failCount

	if config.coverage:
		sut.internalReport()
	
	print "TOTAL ACTIONS",actCount
	print "TOTAL RUNTIME",time.time()-start

def mutate(test, r, bugs):
    tcopy = list(test)
    i = r.randint(0,len(tcopy))
    act = sut.randomEnabled(r)
    isGood = sut.safely(act)
    if not isGood:
        bugs += 1
        failures(sut)
        sut.restart()
    else:
        trest = [act]
        for s in tcopy[i+1:]:
            if s[1]():
                trest.append(s)
                sut.safely(s)
                tcopy = test[:i]+trest
    return tcopy

def failure():
    global bugs, failPool
    bugs += 1
    print "FOUND A FAILURE"
    print sut.failure()
    print "REDUCING"
    failPool.append(sut.test())
    collectCoverage()
    R = sut.reduce(sut.test(),sut.fails, True, True)
    sut.prettyPrintTest(R)
    print sut.failure()

    fname="failure" + str(bugs) + ".test"
    sut.saveTest(sut.test(), fname)

    sut.restart()
    return