TEST(collectonspace,sdbCreateCollection)
{
sdbConnectionHandle connection = 0 ;
sdbCSHandle collectionspace = 0 ;
sdbCollectionHandle collection = 0 ;
INT32 rc = SDB_OK ;
rc = initEnv( HOST, SERVER, USER, PASSWD ) ;
ASSERT_EQ( SDB_OK, rc ) ;
rc = sdbConnect ( HOST, SERVER, USER, PASSWD, &connection ) ;
ASSERT_EQ( SDB_OK, rc ) ;
rc = getCollectionSpace ( connection,
COLLECTION_SPACE_NAME,
&collectionspace ) ;
ASSERT_EQ( SDB_OK, rc ) ;
rc = sdbDropCollection ( collectionspace,
COLLECTION_NAME ) ;
ASSERT_EQ( SDB_OK, rc ) ;
rc = sdbCreateCollection ( collectionspace, COLLECTION_NAME,
&collection ) ;
ASSERT_EQ( SDB_OK, rc ) ;
sdbDisconnect ( connection ) ;
sdbReleaseCollection ( collection ) ;
sdbReleaseCS ( collectionspace ) ;
sdbReleaseConnection ( connection ) ;
}
int main(int argc, char *argv[])
{
printHello();
initEnv();
char *line = new char[MAX_LINE_SIZE + 1];
for (;;) {
int lineLen;
assert(write(1, "% ", 2) > 0);
lineLen = read(0, line, MAX_LINE_SIZE * sizeof(char));
if (lineLen == 0)
break;
line[lineLen] = '\0';
try {
parseLine((const char **)&line);
}
catch (const std::string &func) {
closePrevPipe();
assert(write(2, func.c_str(), func.size() * sizeof(char)) > 0);
assert(write(2, "\n", 1) > 0);
}
}
delete [] line;
return 0;
}
TEST(collectonspace,sdbCreateCollection1_without_options)
{
sdbConnectionHandle connection = 0 ;
sdbCSHandle collectionspace = 0 ;
sdbCollectionHandle collection = 0 ;
INT32 rc = SDB_OK ;
bson option ;
rc = initEnv( HOST, SERVER, USER, PASSWD ) ;
ASSERT_EQ( SDB_OK, rc ) ;
rc = sdbConnect ( HOST, SERVER, USER, PASSWD, &connection ) ;
ASSERT_EQ( SDB_OK, rc ) ;
rc = getCollectionSpace ( connection,
COLLECTION_SPACE_NAME,
&collectionspace ) ;
ASSERT_EQ( SDB_OK, rc ) ;
rc = sdbDropCollection ( collectionspace, COLLECTION_NAME ) ;
ASSERT_EQ( SDB_OK, rc ) ;
bson_init( &option );
bson_append_int( &option, "ReplSize", 0 );
bson_finish( &option ) ;
rc = sdbCreateCollection1 ( collectionspace,
COLLECTION_NAME,
&option,
&collection ) ;
ASSERT_EQ( SDB_OK, rc ) ;
bson_destroy( &option ) ;
sdbDisconnect ( connection ) ;
sdbReleaseCollection ( collection ) ;
sdbReleaseCS ( collectionspace ) ;
sdbReleaseConnection ( connection ) ;
}
void init()
{
logm("Initializing..");
initEnv();
initTokens();
initSignalHandlers();
}
ParseContext::ParseContext(const std::vector<std::pair<std::string , InputError::Action>>& initial) {
initDefault();
for (const auto& pair : initial)
update( pair.first , pair.second );
initEnv();
}
int
main(int argc, char **argv)
{
int sock, nserver0;
int errfd;
pthread_t th;
pthread_create(&th, NULL, response_to_search, NULL);
parseArgv(argc, argv);
if (Daemonize) {
if (fork()) {
exit(0);
}
else {
close(2);
errfd = open(LogFileName, O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR);
if (errfd < 0) {
perror("open:");
}
close(0);
close(1);
}
}
initEnv();
sock = create_daemon_socket(RC_DAEMON_IP_PORT, NBACKLOG);
if (sock == -1) {
WARN(0, "create_daemon_socket() failed\n");
exit(1);
}
nserver0 = Nserver;
while (1) {
if (Nserver < RC_NSERVERMAX) {
spawn_server(sock);
if (nserver0 != Nserver) {
if (Nserver < RC_NSERVERMAX) {
WARN(0, "%d servers active (%d max possible).\n", Nserver, RC_NSERVERMAX);
}
else {
WARN(0, "%d servers active. reached the limit.\n", Nserver);
}
}
}
sleep(1);
nserver0 = Nserver;
}
WARN(0, "%s: cannot be reached.\n", __FILE__);
pthread_join(th, NULL);
exit(1);
}
TEST(cursor,sdbCursor_get_over_then_close)
{
INT32 rc = SDB_OK ;
rc = initEnv( HOST, SERVER, USER, PASSWD ) ;
ASSERT_EQ( SDB_OK, rc ) ;
sdbConnectionHandle connection = 0 ;
sdbCollectionHandle collection = 0 ;
sdbCursorHandle cursor = 0 ;
INT32 NUM = 1 ;
bson obj ;
bson obj1 ;
bson obj2 ;
rc = sdbConnect ( HOST, SERVER, USER, PASSWD, &connection ) ;
ASSERT_EQ( SDB_OK, rc ) ;
rc = getCollection ( connection,
COLLECTION_FULL_NAME,
&collection ) ;
ASSERT_EQ( SDB_OK, rc ) ;
insertRecords ( collection, NUM ) ;
rc = sdbQuery( collection, NULL, NULL, NULL, NULL, 0, -1, &cursor ) ;
ASSERT_EQ( SDB_OK, rc ) ;
bson_init(&obj);
bson_init(&obj1);
bson_init(&obj2);
rc = sdbNext ( cursor, &obj ) ;
CHECK_MSG("%s%d\n","rc = ",rc) ;
ASSERT_EQ( SDB_OK, rc ) ;
printf( "SdbNext record is:\n" ) ;
bson_print( &obj ) ;
printf("\n") ;
rc = sdbNext ( cursor, &obj1 ) ;
CHECK_MSG("%s%d\n","rc = ",rc) ;
ASSERT_EQ( SDB_DMS_EOC, rc ) ;
rc = sdbNext ( cursor, &obj1 ) ;
CHECK_MSG("%s%d\n","rc = ",rc) ;
ASSERT_EQ( SDB_DMS_CONTEXT_IS_CLOSE, rc ) ;
bson_destroy( &obj ) ;
bson_destroy( &obj1 ) ;
bson_destroy( &obj2 ) ;
rc = sdbCloseCursor( cursor ) ;
CHECK_MSG("%s%d\n","rc = ",rc) ;
ASSERT_EQ( SDB_OK, rc ) ;
sdbDisconnect ( connection ) ;
sdbReleaseCursor ( cursor ) ;
sdbReleaseCollection ( collection ) ;
sdbReleaseConnection ( connection ) ;
}
int
main(int argc, char **argv)
{
int sock, nserver0;
int errfd;
parseArgv(argc, argv);
if (Daemonize) {
if (fork()) {
exit(0);
}
else {
close(2);
errfd = open(LogFileName, O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR);
if (errfd < 0) {
perror("open:");
}
close(0);
close(1);
}
}
initEnv();
sock = create_daemon_socket(RC_DAEMON_IP_PORT, NSERVERMAX);
if (sock == -1) {
WARN(0, "create_daemon_socket() failed\n");
exit(1);
}
nserver0 = Nserver;
while (1) {
if (Nserver < NSERVERMAX) {
spawn_server(sock);
}
else {
if (nserver0 != Nserver) {
WARN(0, "already max possible clients (=%d) active.\n", Nserver);
}
sleep(1);
}
nserver0 = Nserver;
}
WARN(0, "%s: cannot be reached.\n", __FILE__);
exit(1);
}
TEST(cursor,sdbNext)
{
INT32 rc = SDB_OK ;
rc = initEnv( HOST, SERVER, USER, PASSWD ) ;
ASSERT_EQ( SDB_OK, rc ) ;
sdbConnectionHandle connection = 0 ;
sdbCollectionHandle collection = 0 ;
sdbCursorHandle cursor = 0 ;
INT32 NUM = 10 ;
SINT64 count = 0 ;
bson obj ;
rc = sdbConnect ( HOST, SERVER, USER, PASSWD, &connection ) ;
ASSERT_EQ( SDB_OK, rc ) ;
rc = getCollection ( connection,
COLLECTION_FULL_NAME,
&collection ) ;
ASSERT_EQ( SDB_OK, rc ) ;
insertRecords( collection, NUM ) ;
rc = sdbQuery ( collection, NULL, NULL, NULL, NULL, 0, -1, &cursor ) ;
ASSERT_EQ( SDB_OK, rc ) ;
bson_init(&obj);
rc = sdbCurrent( cursor, &obj ) ;
printf( "Current record is:\n" ) ;
bson_print( &obj ) ;
printf("\n") ;
bson_destroy( &obj ) ;
bson_init(&obj);
rc = sdbNext( cursor, &obj ) ;
ASSERT_EQ( SDB_OK, rc ) ;
printf( "Next record is:\n" ) ;
bson_print( &obj ) ;
printf("\n") ;
bson_destroy(&obj);
rc = sdbGetCount( collection, NULL, &count ) ;
CHECK_MSG("%s%d\n","rc = ",rc) ;
CHECK_MSG("%s%d%s%lld\n", "NUM = ", NUM, " count = ", count) ;
ASSERT_EQ ( NUM, count ) ;
sdbDisconnect ( connection ) ;
sdbReleaseCursor ( cursor ) ;
sdbReleaseCollection ( collection ) ;
sdbReleaseConnection ( connection ) ;
}
void Calculs::compile_gradient(int nnn)
{
if(nnn==0)
{
initEnv();
}
Env();
Biomasse();
if(nnn==0)
{
init_temoin();
}
initmat();
construction_dGdU();
construction_dGdX();
construction_dFdU();
construction_dSdX();
construction_dFdX();
construction_adjoints();
construction_gradient();
}
int main(int argc, char** argv) {
real_min=imag_min=-2.0;
real_max=imag_max=2.0;
real_scale = (real_max-real_min)/(double)W;
imag_scale = (imag_max-imag_min)/(double)H;
mans = (int*)malloc((W+1)*sizeof(int));/* to store the mandelbrot number of the points of a line. the last number
is used to indicate the line number;*/
initEnv(argc, argv); //init the environment;
id ? slave() : master(np); //if id is 0, then execute the master process, else the slave process;
/* Close the graphics window */
MPE_Close_graphics (&graph);
/* Free storage */
free(mans);
/* Exit */
MPI_Finalize();
exit(0);
}
void main()
{
int row, col;
initEnv();//初始化环境
int i = 0;
while(i < Total_Generations)
{
printf("\nGeneration %d\n", i+1);
i++;
outputMap();
for(row = 0; row < MAXROW; row++)//计算下一代
{
for(col = 0; col < MAXCOL; col++)
{
switch(neighbors(row,col))
{
//周围有0，1，4，5，6，7，8个细胞时 该细胞都会死亡
case 0:newMap[row][col] = DEAD;break;
case 1:newMap[row][col] = DEAD;break;
case 4:newMap[row][col] = DEAD;break;
case 5:newMap[row][col] = DEAD;break;
case 6:newMap[row][col] = DEAD;break;
case 7:newMap[row][col] = DEAD;break;
case 8:newMap[row][col] = DEAD;break;
//周围有两个细胞 保持不变
case 2:newMap[row][col] = newMap[row][col];break;
//周围有3个细胞 变为存活
case 3:newMap[row][col] = ALIVE;break;
}
}
}
}
}
TEST(cursor,sdbCloseCursor)
{
INT32 rc = SDB_OK ;
rc = initEnv( HOST, SERVER, USER, PASSWD ) ;
ASSERT_EQ( SDB_OK, rc ) ;
sdbConnectionHandle connection = 0 ;
sdbCollectionHandle collection = 0 ;
sdbCursorHandle cursor = 0 ;
INT32 NUM = 10 ;
bson obj ;
bson obj1 ;
rc = sdbConnect ( HOST, SERVER, USER, PASSWD, &connection ) ;
ASSERT_EQ( SDB_OK, rc ) ;
rc = getCollection ( connection,
COLLECTION_FULL_NAME,
&collection ) ;
ASSERT_EQ( SDB_OK, rc ) ;
insertRecords ( collection, NUM ) ;
rc = sdbQuery( collection, NULL, NULL, NULL, NULL, 0, -1, &cursor ) ;
bson_init(&obj);
rc = sdbCurrent( cursor, &obj ) ;
ASSERT_EQ( SDB_OK, rc ) ;
printf( "Current record is:\n" ) ;
bson_print( &obj ) ;
printf("\n") ;
bson_destroy( &obj ) ;
rc = sdbCloseCursor( cursor ) ;
ASSERT_EQ( SDB_OK, rc ) ;
bson_init( &obj1 ) ;
rc = sdbCurrent( cursor, &obj1 ) ;
ASSERT_EQ( rc, SDB_DMS_CONTEXT_IS_CLOSE ) ;
sdbDisconnect ( connection ) ;
sdbReleaseCursor ( cursor ) ;
sdbReleaseCollection ( collection ) ;
sdbReleaseConnection ( connection ) ;
}
int main(int argc, char * argv[]) {
// Lets find the bundle first
// All this jazz simply deals with loading the bundle
LOAD_API_BUNDLE;
RETAIN_API_BUNDLE_VAR;
initEnvFunc initEnv = set_initEnvFunc(API_BUNDLE_VAR);
destroyEnvFunc destroyEnv = set_destroyEnvFunc(API_BUNDLE_VAR);
startJuceFunc startJuce = set_startJuceFunc(API_BUNDLE_VAR);
stopJuceFunc stopJuce = set_stopJuceFunc(API_BUNDLE_VAR);
addSoundToRendererBankFunc addSound = set_addSoundToRendererBankFunc(API_BUNDLE_VAR);
deactivateSoundInRendererBankFunc deactivateSoundInRendererBank = set_deactivateSoundInRendererBankFunc(API_BUNDLE_VAR);
std::string asset_path(TEST_ASSET_PATH);
std::string asset_one(asset_path + std::string("/ad-demo.wav"));
std::string asset_two(asset_path + std::string("/cat.wav"));
std::vector<char> asset_one_str(asset_one.begin(), asset_one.end());
asset_one_str.push_back('\0');
std::vector<char> asset_two_str(asset_two.begin(), asset_two.end());
asset_two_str.push_back('\0');
// ---------------------------------------------------------------------- //
// ---------------------------------------------------------------------- //
// ---------------------------------------------------------------------- //
#define TESTING_JUCE_PLAYBACK
#ifdef TESTING_JUCE_PLAYBACK
initEnv();
addSound(&asset_one_str[0]);
addSound(&asset_two_str[0]);
startJuce();
sleep(6);
// Go away cat!
deactivateSoundInRendererBank(&asset_two_str[0]);
sleep(6);
addSound(&asset_two_str[0]);
sleep(3);
stopJuce();
deactivateSoundInRendererBank(&asset_one_str[0]);
deactivateSoundInRendererBank(&asset_two_str[0]);
destroyEnv();
#else
initEnv();
addSound(&asset_one_str[0]);
sleep(2);
removeSoundFromRendererBank(&asset_one_str[0]);
destroyEnv();
#endif
// ---------------------------------------------------------------------- //
// ---------------------------------------------------------------------- //
// ---------------------------------------------------------------------- //
printf("Releasing the bundle\n");
RELEASE_API_BUNDLE_VAR;
printf("Calling it a day\n");
return 0;
}
sdbDisconnect ( connection ) ;
sdbReleaseCollection ( collection ) ;
sdbReleaseCS ( collectionspace ) ;
sdbReleaseConnection ( connection ) ;
}
TEST(collectonspace,sdbCreateCollection1_with_options)
{
printf("The test work in cluster environment\
with at least 2 data notes.\n") ;
sdbConnectionHandle connection = 0 ;
sdbCSHandle collectionspace = 0 ;
sdbCollectionHandle collection = 0 ;
INT32 rc = SDB_OK ;
bson options ;
rc = initEnv( HOST, SERVER, USER, PASSWD ) ;
ASSERT_EQ( SDB_OK, rc ) ;
rc = sdbConnect ( HOST, SERVER, USER, PASSWD, &connection ) ;
ASSERT_EQ( SDB_OK, rc ) ;
rc = getCollectionSpace ( connection,
COLLECTION_SPACE_NAME,
&collectionspace ) ;
ASSERT_EQ( SDB_OK, rc ) ;
rc = sdbDropCollection ( collectionspace, COLLECTION_NAME ) ;
ASSERT_EQ( SDB_OK, rc ) ;
bson_init ( &options ) ;
bson_append_start_object ( &options, "ShardingKey" ) ;
bson_append_int ( &options, "age", 1 ) ;
bson_append_int ( &options, "name", -1 ) ;
bson_append_finish_object ( &options ) ;
/*
* Main Game Loop
*/
int main()
{
// Use the name of your pixel buffer DMA core
pixel_buffer =alt_up_pixel_buffer_dma_open_dev("/dev/pixel_buffer_dma_0");
initVGA();
usleep(5000000);
ps2 = alt_up_ps2_open_dev("/dev/ps2_0");
ps2->timeout = 2000000;
alt_up_ps2_clear_fifo(ps2);
alt_up_ps2_init(ps2);
unsigned char byte1;
while(alt_up_ps2_read_data_byte(ps2, &byte1)!=0);
char_lcd_dev = alt_up_character_lcd_open_dev ("/dev/character_lcd_0");
alt_up_character_lcd_init (char_lcd_dev);
char_buffer = alt_up_char_buffer_open_dev("/dev/char_drawer");
alt_up_char_buffer_init(char_buffer);
alt_up_sd_card_dev *device_reference = NULL;
struct Env* p = initEnv();
initGameInfo();
struct Collidable* collisionChecker = initCollidable();
addCollisionToEnv(p, collisionChecker);
promptSDcard(p, device_reference);
usleep(1000);
alt_up_char_buffer_string(char_buffer, "Loading ", 40, 30);
unsigned end_time, start_time;
int count = 0; lock = 0;
struct animation* starAnimation = loadSDImageSeq("ST0.BMP", 2, 8);
struct animation* star2Animation = loadSDImageSeq("ST00.BMP", 3, 7);
struct animation* alien0 = loadSDImageSeq("A100.BMP", 2, 2); //2 images where first 2 characters are prefix
struct animation* alien1 = loadSDImageSeq("A000.BMP", 2, 15);
struct animation* ship0 = loadSDImageSeq("S00.BMP", 2, 16);
struct animation* ship1 = loadSDImageSeq("S10.BMP", 2, 27);
struct animation* bossAnimate = loadSDImageSeq("BO00.BMP", 2, 28);
struct animation* ship2 = loadSDImageSeq("S20.BMP", 2, 35);
struct animation* ship3 = loadSDImageSeq("S30.BMP", 2, 30);
struct animation* ship4 = loadSDImageSeq("S40.BMP", 2, 10);
struct animation* explode1 = initAnimation((int*)explode01, 1);
addImage(explode1, initAnimation((int*)explode02, 0));
addImage(explode1, initAnimation((int*)explode03, 0));
addImage(explode1, initAnimation((int*)explode04, 0));
addImage(explode1, initAnimation((int*)explode05, 0));
struct animation** shipAnimationCollection = (struct animation**)malloc(sizeof(struct animation*)*5);
shipAnimationCollection[0] = ship0;
shipAnimationCollection[1] = ship1;
shipAnimationCollection[2] = ship2;
shipAnimationCollection[3] = ship3;
shipAnimationCollection[4] = ship4;
initWeapon(collisionChecker, p);
struct Cursor* mouse = initCursor(p, collisionChecker);
addToEnv(p, mouse->super);
addObjToCollide(collisionChecker, mouse->super);
setCursor(p, mouse);
struct KeyController* keyController = initKeyController();
struct SwitchController* switchController = initSwitchController();
struct CursorController* ctrl = initCursorController(mouse->super, switchController, keyController);
alt_up_char_buffer_string(char_buffer, "Loading Sounds ", 30, 30);
audioController = initAudioController();
loadSound( audioController, LOOP_ONE );
loadSound( audioController, LASER_SOUND );
alt_irq_register(AUDIO_IRQ, audioController, (void*) audio_ISR);
alt_irq_enable(AUDIO_IRQ);
play_background_loop( audioController, LOOP_ONE );
enableAudioController( audioController );
printhex(info.score);
mainMenu(mouse, ctrl, p);
disableAudioController(audioController);
stop_background_loop(audioController);
unloadSoundById(audioController, LASER_SOUND);
unloadSoundById(audioController, LOOP_ONE);
alt_up_char_buffer_string(char_buffer, "Loading Sounds ", 30, 30);
//loadSound(audioController, WIN_SOUND);
//loadSound(audioController, LOSE_SOUND);
loadSound( audioController, TOWER_UPGRADE_SOUND );
loadSound( audioController, LOOP_TWO );
play_background_loop(audioController, LOOP_TWO);
enableAudioController( audioController );
alt_up_char_buffer_clear(char_buffer);
//usleep(1000);
struct Alien* testAlienCollection[60];
gameSetup(p, shipAnimationCollection, mouse, starAnimation, star2Animation);
usleep(500000); //time delay for panel to be drawn
//
char LPS[50]; float lps_;
int n = 0;
for(n = 0; n < 20; n++) {
testAlienCollection[n] =initAlien(n, 10*n, 10, alien0, explode1, "IdontKnow", 1.4, 150, 500, collisionChecker);
addToEnvNR(p, testAlienCollection[n]->super);
}
for(n = 0; n < 20; n++) {
testAlienCollection[n+20] =initAlien(10*n, n, 10, alien1, explode1, "whatName", 1.4, 190, 850, collisionChecker);
addToEnvNR(p, testAlienCollection[n+20]->super);
}
for(n = 0; n < 20; n++) {
testAlienCollection[n+40] =initAlien(10*n, n, 20, bossAnimate, explode1, "IamBoss", 1.6, 800, 1500, collisionChecker);
testAlienCollection[n+40]->score = 300;
addToEnvNR(p, testAlienCollection[n+40]->super);
}
int stage = 0;
/*
* Game Starts!!!!!!
*/
alt_alarm_start (&alarm,alt_ticks_per_second(),my_alarm_callback,(void*)p);
int startTimer = 0;
char second_row1[15];
alt_up_character_lcd_set_cursor_pos(char_lcd_dev, 0, 1);
sprintf(second_row1, "wave# %d ", stage);
alt_up_character_lcd_string(char_lcd_dev, second_row1);
while(1) {
alt_timestamp_start();
start_time = (unsigned)alt_timestamp();
/*-----------------------------------------------------------------------------------------------*/
checkCollision(collisionChecker); //a major function that check each collision happen between each object
updateCursorController(ctrl, 1);
count++;
if (startTimer > count)
info.startButton = false;
else {
if(stage == 7)
info.isWin = true;
else if(startTimer == count){
//play_background_loop(audioController, LOOP_TWO);
enableAudioController( audioController );
}
}
if (info.startButton){
disableAudioController(audioController);
//stop_background_loop(audioController);
startTimer = count + 15000;
checkStages(testAlienCollection, stage%7, collisionChecker);
stage++;
//if(stage > 6) stage = 0;
info.startButton = false;
alt_up_character_lcd_set_cursor_pos(char_lcd_dev, 0, 1);
sprintf(second_row1, "wave# %d ", stage);
alt_up_character_lcd_string(char_lcd_dev, second_row1);
}
if(info.isEnd || info.isWin) {
disableAudioController(audioController);
stop_background_loop(audioController);
endGame(testAlienCollection, collisionChecker, p, mouse, ctrl, keyController);
}
/*-----------------------------------------------------------------------------------------------*/
end_time = (unsigned)alt_timestamp();
lps_ = (float)alt_timestamp_freq()/(float)(end_time - start_time);
sprintf(LPS, "The current LPS is %.2f", lps_);
alt_up_char_buffer_string(char_buffer, LPS, 3, 2);
}
return 0;
}
ParseContext::ParseContext(InputError::Action default_action) {
initDefault();
update(default_action);
initEnv();
}
ParseContext::ParseContext() {
initDefault();
initEnv();
}
