void wasmint::TestCaseGenerator::mutateSource() {
if (finalSource_.empty())
return;
std::size_t start = randomInRange(finalSource_.size());
std::size_t length = randomInRange(finalSource_.size());
finalSource_.erase(start, length);
}
/*
快速排序
分类函数
*/
int partition(int data[], int length, int start, int end)
{
if (data == NULL || length <= 0 || start < 0 || end >= length)
{
throw new std::exception("Invalid parameters");
}
int index = randomInRange(start, end);
Swap(&data[index], &data[end]); // 只是在第一步随机交换一下，即改变了取最后一个值，处理已排序序列的尴尬！
int small = start - 1;
for (index = start; index < end; index++)
{
if (data[index] < data[end])
{
small++;
if (small != index)
{
// 把前面大的，和后面小的交换！小的再后面才发现，small就是小的一边的边界！ 非常巧妙
Swap(&data[index], &data[small]);
}
}
}
small;
Swap(&data[small], &data[end]);
return small;
}
int partition(int *data,int length,int start,int end)
{
if(data==NULL || start<0 || length<0 || end>=length)
return -1;
int index=randomInRange(start,end);
int temp;
temp=data[end];
data[end]=data[index];
data[index]=temp;
int small=start-1;
int i=start;
for(;i<end;i++){
if(data[i]<data[end]){
small++;
if(i>small){
temp=data[i];
data[i]=data[small];
data[small]=temp;
}
}
}
temp=data[end];
data[end]=data[small+1];
data[small+1]=temp;
return (small+1);
}
/* ********************************************************************************************* */
VectorXd RRT::getRandomConfig() {
// Samples a random point for qtmp in the configuration space, bounded by the provided
// configuration vectors (and returns ref to it)
VectorXd config(ndim);
for (int i = 0; i < ndim; ++i) {
config[i] = randomInRange(robot->getGenCoord(dofs[i])->getConfigMin(), robot->getGenCoord(dofs[i])->getConfigMax());
}
return config;
}
/* ********************************************************************************************* */
VectorXd RRT::getRandomConfig() {
// Samples a random point for qtmp in the configuration space, bounded by the provided
// configuration vectors (and returns ref to it)
VectorXd config(ndim);
for (int i = 0; i < ndim; ++i) {
config[i] = randomInRange(robot->getPositionLowerLimit(dofs[i]), robot->getPositionUpperLimit(dofs[i]));
}
return config;
}
/**
* @function getRandomConfig
* @brief Samples a random point for qtmp in the configuration space,
* bounded by the provided configuration vectors (and returns ref to it)
*/
Eigen::VectorXd B1RRT::getRandomConfig() {
Eigen::VectorXd config( ndim );
for( unsigned int i = 0; i < ndim; i++ ) {
double minVal = world->mRobots[robotId]->getDof(links[i])->getMin();
double maxVal = world->mRobots[robotId]->getDof(links[i])->getMax();
config[i] = randomInRange( minVal, maxVal );
}
return config;
}
// -------------------------------------
// Main function
// -------------------------------------
void appMain(void)
{
uint16_t i;
// timers (used to get an extra interrupt context)
alarmInit(&timer, onTimer, NULL);
alarmSchedule(&timer, 1000);
// radio
radioSetReceiveHandle(radioRecvCb);
radioOn();
for (i = 0; i < BUFFER_SIZE; i++) {
buffer[i] = i;
}
randomInit();
// SELECT_FLASH;
// extFlashBulkErase();
// UNSELECT_FLASH;
for (i = 0; ; i++) {
uint32_t address = i * 64ul;
SELECT_FLASH;
if (IS_ALIGNED(address, EXT_FLASH_SECTOR_SIZE)) {
PRINTF("erase address %lu\n", address);
flashErase(address);
}
PRINTF("write address %lu\n", address);
flashWrite(address);
if (address > 0) {
PRINTF("verify...\n");
flashRead(address - 64);
}
UNSELECT_FLASH;
msleep(randomInRange(400, 1000));
PRINTF("send smth to radio...\n");
radioSend("hello world", sizeof("hello world"));
greenLedToggle();
}
}
static uint32_t calcNextForwardTime(uint8_t moteToProcess)
{
uint16_t rnd = randomInRange(200, 400);
if (moteToProcess == 0) {
return timeToNextFrame() + 4000 + rnd
+ (IS_ODD_COLLECTOR ? MAX_MOTES * MOTE_TIME_FULL : 0);
}
uint32_t passedTime = timeSinceFrameStart();
uint32_t requiredTime = 4000ul + (IS_ODD_COLLECTOR ? MAX_MOTES * MOTE_TIME_FULL : 0)
+ MOTE_TIME_FULL * moteToProcess + rnd;
if (passedTime >= requiredTime) return 0;
return requiredTime - passedTime;
}
static void TestMonkey(void)
{
int32_t scale;
UErrorCode status = U_ZERO_ERROR;
for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) {
int64_t fromMin = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_FROM_MIN_VALUE, &status);
int64_t fromMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_FROM_MAX_VALUE, &status);
int32_t i;
initRandom(fromMin, fromMax);
for (i = 0; i < LOOP_COUNT; i += 1) {
int64_t value = randomInRange();
roundTripTest(value, (UDateTimeScale)scale);
}
}
}
void routingInit(void)
{
socketOpen(&roSocket, routingReceive);
socketBind(&roSocket, ROUTING_PROTOCOL_PORT);
alarmInit(&roCheckTimer, roCheckTimerCb, NULL);
alarmInit(&roForwardTimer, roForwardTimerCb, NULL);
alarmInit(&roOutOfOrderForwardTimer, roOutOfOrderForwardTimerCb, NULL);
alarmInit(&roRequestTimer, roRequestTimerCb, NULL);
alarmInit(&roStopListeningTimer, roStopListeningTimerCb, NULL);
alarmInit(&roStartListeningTimer, roStartListeningTimerCb, NULL);
alarmInit(&roGreenLedTimer, roGreenLedTimerCb, NULL);
alarmInit(&watchdogTimer, watchdogTimerCb, NULL);
alarmSchedule(&roCheckTimer, randomInRange(1000, 3000));
alarmSchedule(&roForwardTimer, calcNextForwardTime(0));
alarmSchedule(&roStartListeningTimer, 110);
alarmSchedule(&roGreenLedTimer, 10000);
// alarmSchedule(&watchdogTimer, 1000);
}
CParticle* CParticleSystem::createParticle(){
if(mParticles.size() >= mDef->mBudget)
return 0;
CParticle *p = new CParticle();
p->mPosition = CVector3::ZERO;
p->mVelocity = CVector3(0.0, 0.0, 0.0);
if(mDef->mEmitterShape == PARTICLE_EMITTER_SPHERE){
CVector3 dir = CVector3(randomInRange(-1.0, 1.0), randomInRange(-1.0, 1.0), randomInRange(-1.0, 1.0)).normalized();
p->mPosition = dir * mDef->mEmitterDimensions.x;
if(mDef->mSpawnDirection == PARTICLE_SPAWN_DIRECTION_NATURAL){
p->mVelocity = dir * randomInRange(mDef->mSpawnVelocityMin, mDef->mSpawnVelocityMax);
} else {
p->mVelocity = CVector3(0.0, 0.0, 1.0) * randomInRange(mDef->mSpawnVelocityMin, mDef->mSpawnVelocityMax);
}
}
CVector3 var = CVector3(randomInRange(-1.0, 1.0), randomInRange(-1.0, 1.0), randomInRange(-1.0, 1.0));
p->mVelocity += var * mDef->mSpawnDirectionVariation;
if(mEmitter){
p->mPosition += mEmitter->getDerivedPosition();
p->mVelocity = mEmitter->getDerivedOrientation() * p->mVelocity;
}
if(mDef->mRotation != 0.0)
p->mRotation = mDef->mRotation;
else
p->mRotation = 2 * PI * random();
p->mRotationSpeed = mDef->mRotationSpeed;
p->mTimeLived = 0.0;
p->mLifetime = mDef->mLifeTime;
p->mSizeX = 10.0;
p->mSizeY = 10.0;
mParticles.push_back(p);
return p;
}
void ParticalEffect::updateFire(float dt, const int scount, int type) {
count = scount;
for (int x = 0; x < count; x ++) {
if(!partsA[x].active)
{
int mouseX, mouseY;
Core::Input::GetMousePos( mouseX, mouseY );
Vector2D mouse((float)mouseX, (float)mouseY);
partsA[x] = Partical();
float randInt = randomInRange(1,10);
Vector2D rand;
if(type == 1) {
rand = RandomUnitVector() * randInt;
} else {
}
Vector2D newPath = mouse + rand;
partsA[x].updateFire(dt, mouse, newPath);
}
}
}
void Orbs::makeOrbs() {
unsigned maxOrbs = gdata->getXmlInt("orbsNumber");
unsigned minX = gdata->getXmlInt("orbsMinX");
unsigned maxX = gdata->getXmlInt("orbsMaxX");
unsigned minY = gdata->getXmlInt("orbsMinY");
unsigned maxY = gdata->getXmlInt("orbsMaxY");
unsigned minXspeed = gdata->getXmlInt("orbsMinXspeed");
unsigned maxXspeed = gdata->getXmlInt("orbsMaxXspeed");
unsigned minYspeed = gdata->getXmlInt("orbsMinYspeed");
unsigned maxYspeed = gdata->getXmlInt("orbsMaxYspeed");
orbs.push_back( new Sprite(
Vector2f(randomInRange(minX, maxX), randomInRange(minY, maxY)),
Vector2f(randomInRange(maxXspeed, maxXspeed+100),
randomInRange(minYspeed, maxYspeed)),
SpriteFrameFactory::getInstance()->getFrame("orb", "cyanOrb")));
orbs.push_back( new Sprite(
Vector2f(randomInRange(minX, maxX), randomInRange(minY, maxY)),
Vector2f(randomInRange(maxXspeed, 2*maxXspeed+200),
randomInRange(minYspeed, maxYspeed)),
SpriteFrameFactory::getInstance()->getFrame("orb", "greenOrb")));
for (unsigned i = 0; i < maxOrbs; ++i) {
orbs.push_back( new Sprite(
Vector2f(randomInRange(minX, maxX), randomInRange(minY, maxY)),
Vector2f(randomInRange(minXspeed, maxXspeed),
randomInRange(minYspeed, maxYspeed)),
SpriteFrameFactory::getInstance()->getFrame("orb", "yellowOrb")));
}
for (unsigned i = 0; i < maxOrbs; ++i) {
orbs1.push_back( new Sprite(
Vector2f(randomInRange(minX, maxX), randomInRange(minY, maxY)),
Vector2f(randomInRange(minXspeed, maxXspeed),
randomInRange(minYspeed, maxYspeed)),
SpriteFrameFactory::getInstance()->getFrame("orb", "yellowOrb1")));
}
}
void wasmint::TestCaseGenerator::generateInstruction(const wasm_module::Type* expectedReturnType) {
instructions++;
TestCaseInstruction* instruction;
if (instructions < instructionLimit) {
while(true) {
std::size_t index = randomInRange(testInstructions.size());
instruction = &testInstructions.at(index);
if (expectedReturnType == nullptr)
break;
if (instruction->returnType == expectedReturnType)
break;
}
} else {
if (expectedReturnType == Int32::instance()) {
instruction = &leafTestInstructions.at(0);
} else if (expectedReturnType == Int64::instance()) {
instruction = &leafTestInstructions.at(1);
} else if (expectedReturnType == Float32::instance()) {
instruction = &leafTestInstructions.at(2);
} else if (expectedReturnType == Float64::instance()) {
instruction = &leafTestInstructions.at(3);
} else {
instruction = &leafTestInstructions.at(4);
}
}
source_ << " (" << instruction->name << " ";
if (instruction->special) {
if (instruction->name == "i32.const") {
source_ << randomInRange(1000);
} else if (instruction->name == "i64.const") {
source_ << randomInRange(1000);
} else if (instruction->name == "f32.const") {
source_ << randomInRange(1000);
} else if (instruction->name == "f64.const") {
source_ << randomInRange(1000);
} else if (instruction->name == "has_feature") {
generateRandomString();
} else if (instruction->name == "get_local") {
generateRandomString();
} else if (instruction->name == "set_local") {
generateRandomString();
} else if (instruction->name == "label") {
generateRandomString();
} else if (instruction->name == "block") {
generateRandomString();
} else if (instruction->name == "loop") {
generateRandomString();
} else if (instruction->name == "call_import") {
generateRandomString();
} else if (instruction->name == "call") {
generateRandomString();
} else if (instruction->name == "call_indirect") {
generateRandomString();
} else if (instruction->name == "br") {
generateRandomString();
} else if (instruction->name == "br_if") {
generateRandomString();
} else {
std::cerr << "Unknown special instruction during generation " << instruction->name << std::endl;
exit(1);
}
}
source_ << " ";
if (instructions < instructionLimit) {
for (std::size_t i = 0; i < instruction->children.size(); i++) {
const Type *expectedChildType = nullptr;
if (i < instruction->children.size()) {
expectedChildType = instruction->children.at(i);
}
generateInstruction(expectedChildType);
}
}
source_ << ") ";
}
Edge getRandomMoveFromList(Edge * edges, short numEdges) {
return edges[randomInRange(0, numEdges-1)];
}
Edge getRandomMove(UnscoredState * state) {
Edge freeEdges[NUM_EDGES];
short numFreeEdges = getFreeEdges(state, freeEdges);
return freeEdges[randomInRange(0, numFreeEdges-1)];
}
