int main()
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&lock, &attr);
pthread_mutex_lock(&lock);
pthread_mutex_unlock(&lock);
if (emscripten_has_threading_support()) {
// Create new threads in parallel.
for(int i = 0; i < NUM_THREADS; ++i)
CreateThread(i, threadNum++);
emscripten_set_main_loop(WaitToJoin, 0, 0);
} else {
#ifdef REPORT_RESULT
REPORT_RESULT(50);
#endif
}
}
runall_result test_main()
{
accelerator::set_default(require_device().device_path);
runall_result result;
result &= REPORT_RESULT(test_array_type<int>());
result &= REPORT_RESULT(test_array_type<unsigned>());
result &= REPORT_RESULT(test_array_type<unsigned int>());
result &= REPORT_RESULT(test_array_type<long>());
result &= REPORT_RESULT(test_array_type<unsigned long>());
result &= REPORT_RESULT(test_array_type<float>());
accelerator device;
if (device.supports_double_precision)
{
result &= REPORT_RESULT(test_array_type<double>());
}
return result;
}
int main(int argc, char **argv) {
SDL_Init(SDL_INIT_AUDIO);
Mix_Init(MIX_INIT_OGG);
int ret = Mix_OpenAudio(0, 0, 0, 0); // we ignore all these..
assert(ret == 0);
Mix_AllocateChannels(kNumChannels);
sound = Mix_LoadWAV("sound.ogg");
// allocate all the channels
for ( int i = 0; i < kNumChannels; i++ )
{
assert(loadAndPlay() != -1);
}
// This point, we should have exhausted our channels
int lastChannel = loadAndPlay();
#if EMSCRIPTEN
int result = (lastChannel == -1);
REPORT_RESULT();
#endif
assert(lastChannel == -1);
// force a quit
while(Mix_Init(0))
Mix_Quit();
Mix_CloseAudio();
return 0;
}
int main() {
SDL_Init(SDL_INIT_VIDEO);
SDL_Surface *screen = SDL_SetVideoMode(600, 450, 32, SDL_SWSURFACE);
int result = 0;
result |= testImage(screen, SCREENSHOT_DIRNAME "/" SCREENSHOT_BASENAME); // absolute path
assert(result != 0);
chdir(SCREENSHOT_DIRNAME);
result = testImage(screen, "./" SCREENSHOT_BASENAME); // relative path
assert(result != 0);
SDL_Flip(screen);
printf("you should see an image.\n");
SDL_Quit();
REPORT_RESULT();
return 0;
}
void next(const char *x) {
lib_handle = dlopen("themodule.js", RTLD_NOW);
assert(lib_handle != NULL);
onefunc = (voidfunc)dlsym(lib_handle, "one");
twofunc = (intfunc)dlsym(lib_handle, "two");
assert(onefunc && twofunc);
assert(twofunc() == 0);
onefunc();
assert(twofunc() == 1);
onefunc();
onefunc();
assert(twofunc() == 3);
onefunc();
onefunc();
onefunc();
onefunc();
assert(twofunc() == 7);
onefunc();
int result = twofunc();
REPORT_RESULT();
}
void MainThreadRender()
{
static double color = 0;
color += 0.01;
glClearColor(0, color, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
#ifdef TEST_MAIN_THREAD_EXPLICIT_COMMIT
EMSCRIPTEN_RESULT r = emscripten_webgl_commit_frame();
assert(r == EMSCRIPTEN_RESULT_SUCCESS);
// In explicit swap control mode, whatever we draw here shouldn't show up.
glClearColor(1, 0, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
#endif
#
if (color >= 1.0)
{
printf("Test finished.\n");
emscripten_cancel_main_loop();
#ifdef REPORT_RESULT
REPORT_RESULT(0);
#endif
}
}
int main(int argc, char *argv[])
{
EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
EGLint major, minor;
eglInitialize(display, &major, &minor);
EGLint numConfigs;
eglGetConfigs(display, NULL, 0, &numConfigs);
EGLint attribs[] = {
EGL_RED_SIZE, 5,
EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5,
EGL_NONE
};
EGLConfig config;
eglChooseConfig(display, attribs, &config, 1, &numConfigs);
EGLNativeWindowType dummyWindow;
EGLSurface surface = eglCreateWindowSurface(display, config, dummyWindow, NULL);
EGLint width, height;
eglQuerySurface(display, surface, EGL_WIDTH, &width);
eglQuerySurface(display, surface, EGL_HEIGHT, &height);
printf("(%d, %d)\n", width, height);
#ifdef REPORT_RESULT
int result = 0;
if(width == 300 && height == 150)
{
result = 1;
}
REPORT_RESULT(result);
#endif
}
int main()
{
for(int i = 0; i < NUM_KEYS; ++i)
pthread_key_create(&keys[i], NULL);
// Create initial threads.
for(int i = 0; i < NUM_THREADS; ++i)
CreateThread(i);
// Join all threads and create more.
if (emscripten_has_threading_support())
{
for(int i = 0; i < NUM_THREADS; ++i)
{
if (thread[i])
{
int status;
int rc = pthread_join(thread[i], (void**)&status);
assert(rc == 0);
EM_ASM(Module['printErr']('Main: Joined thread idx ' + $0 + ' with status ' + $1), i, (int)status);
assert(status == 0);
thread[i] = 0;
if (numThreadsToCreate > 0)
{
--numThreadsToCreate;
CreateThread(i);
}
}
}
}
#ifdef REPORT_RESULT
REPORT_RESULT(0);
#endif
for(int i = 0; i < NUM_KEYS; ++i)
pthread_key_delete(keys[i]);
}
void looper() {
static double frame0 = emscripten_get_now();
double start = emscripten_get_now();
++numFrames;
printf("Frame %d\n", numFrames);
if (numFrames == 10) {
double now = emscripten_get_now();
double msecsPerFrame = (now - frame0) / (numFrames-1); // Sub one to account for intervals vs endpoints
printf("Avg. msecs/frame: %f\n", msecsPerFrame);
#ifdef REPORT_RESULT
int result = (msecsPerFrame > 350 && msecsPerFrame < 650); // Expecting 500msecs/frame, but allow a lot of leeway. Bad value would be 900msecs/frame (400msecs of processing below and 500msecs of delay)
REPORT_RESULT();
#endif
emscripten_cancel_main_loop();
}
// Busy wait 400 msecs.
double now = start;
while (now - start < 400) {
now = emscripten_get_now();
}
}
void one() {
SDL_Event event;
while (SDL_PollEvent(&event)) {
switch(event.type) {
case SDL_MOUSEMOTION: {
SDL_MouseMotionEvent *m = (SDL_MouseMotionEvent*)&event;
assert(m->state == 0);
int x, y;
SDL_GetMouseState(&x, &y);
assert(x == m->x && y == m->y);
printf("motion: %d,%d %d,%d\n", m->x, m->y, m->xrel, m->yrel);
result += 2 * (m->x + m->y + m->xrel + m->yrel);
break;
}
case SDL_MOUSEBUTTONDOWN: {
SDL_MouseButtonEvent *m = (SDL_MouseButtonEvent*)&event;
if (m->button == 2) {
REPORT_RESULT();
emscripten_run_script("throw 'done'");
}
printf("button down: %d,%d %d,%d\n", m->button, m->state, m->x, m->y);
result += 3 * (m->button + m->state + m->x + m->y);
break;
}
case SDL_MOUSEBUTTONUP: {
SDL_MouseButtonEvent *m = (SDL_MouseButtonEvent*)&event;
printf("button up: %d,%d %d,%d\n", m->button, m->state, m->x, m->y);
result += 5 * (m->button + m->state + m->x + m->y);
// Remove another click we want to ignore
assert(SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONDOWN) == 1);
assert(SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_MOUSEBUTTONUP, SDL_MOUSEBUTTONUP) == 1);
break;
}
}
}
}
int main() {
checkContextAttributesSupport();
glfwInit();
#ifdef AA_ACTIVATED
antiAliasingActivated = true;
nbSamples = 4;
#endif
#ifdef DEPTH_ACTIVATED
depthActivated = true;
nbDepthBits = 16;
#endif
#ifdef STENCIL_ACTIVATED
stencilActivated = true;
nbStencilBits = 8;
#endif
glfwOpenWindowHint(GLFW_FSAA_SAMPLES, nbSamples);
glfwOpenWindow(WINDOWS_SIZE, WINDOWS_SIZE, 8, 8, 8, 8, nbDepthBits, nbStencilBits, GLFW_WINDOW);
glewInit();
initGlObjects();
draw();
glfwTerminate();
REPORT_RESULT();
return 0;
}
int main() {
int f = open(".", O_RDONLY);
int ret = fsync(f);
printf("fsync(opened): %d\n", ret);
printf("errno: %d\n", errno);
assert(ret == 0);
assert(errno == 0);
errno = 0;
ret = close(f);
printf("close(opened): %d\n", ret);
printf("errno: %d\n", errno);
assert(ret == 0);
assert(errno == 0);
errno = 0;
ret = fsync(f);
printf("fsync(closed): %d\n", ret);
printf("errno: %d\n", errno);
assert(ret == -1);
assert(errno == EBADF);
errno = 0;
ret = close(f);
printf("close(closed): %d\n", ret);
printf("errno: %d\n", errno);
assert(ret == -1);
assert(errno == EBADF);
errno = 0;
#ifdef REPORT_RESULT
REPORT_RESULT(0);
#endif
return 0;
}
runall_result test_main()
{
// Test is using doubles therefore we have to make sure that it is not executed
// on devices that does not support double types.
accelerator::set_default(require_device_with_double().get_device_path());
runall_result result;
result &= REPORT_RESULT((test_feature<int, 1>()));
result &= REPORT_RESULT((test_feature<int, 2>()));
result &= REPORT_RESULT((test_feature<int, 3>()));
result &= REPORT_RESULT((test_feature<int, 5>()));
result &= REPORT_RESULT((test_feature<unsigned int, 1>()));
result &= REPORT_RESULT((test_feature<unsigned int, 2>()));
result &= REPORT_RESULT((test_feature<unsigned int, 3>()));
result &= REPORT_RESULT((test_feature<unsigned int, 5>()));
result &= REPORT_RESULT((test_feature<float, 1>()));
result &= REPORT_RESULT((test_feature<float, 2>()));
result &= REPORT_RESULT((test_feature<float, 3>()));
result &= REPORT_RESULT((test_feature<float, 5>()));
result &= REPORT_RESULT((test_feature<double, 1>()));
result &= REPORT_RESULT((test_feature<double, 2>()));
result &= REPORT_RESULT((test_feature<double, 3>()));
result &= REPORT_RESULT((test_feature<double, 5>()));
return result;
}
int main()
{
emscripten_set_canvas_size( 100, 100 );
EmscriptenWebGLContextAttributes attrs;
emscripten_webgl_init_context_attributes(&attrs);
attrs.enableExtensionsByDefault = 1;
attrs.majorVersion = 2;
attrs.minorVersion = 0;
EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context( 0, &attrs );
if (!context)
{
attrs.majorVersion = 1;
context = emscripten_webgl_create_context( 0, &attrs );
if (context) printf("Skipping test: WebGL 2.0 is not available.\n");
else printf("Test failed: WebGL is not available!\n");
#ifdef REPORT_RESULT
// We did not have WebGL 2, but were able to init WebGL 1? In that case, gracefully skip this test with the current browser not supporting this one.
int result = context ? 0 : 12365;
REPORT_RESULT();
#endif
return 0;
}
emscripten_webgl_make_context_current(context);
// Textures
//
int mips = 10;
int sizeO = 512;
unsigned short* data = new unsigned short[ 512 * 512 * 4 ];
//memset( data, 0, 512 * 512 * 4 );
// Create texture 1
GLuint tex1;
GL_CALL( glGenTextures( 1, &tex1 ) );
GL_CALL( glBindTexture( GL_TEXTURE_CUBE_MAP, tex1 ) );
for( int i=0; i<6; ++i )
{
GL_CALL( glTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, 0, GL_RGBA16F, sizeO, sizeO, 0, GL_RGBA, GL_HALF_FLOAT, NULL ) );
}
GL_CALL( glGenerateMipmap( GL_TEXTURE_CUBE_MAP ) );
for( int i=0; i<6; ++i )
GL_CALL( glTexSubImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, 0, 0, 0, sizeO, sizeO, GL_RGBA, GL_HALF_FLOAT, data ) );
delete [] data;
// Create texture 2
GLuint tex2;
GL_CALL( glGenTextures( 1, &tex2 ) );
GL_CALL( glBindTexture( GL_TEXTURE_CUBE_MAP, tex2 ) );
for( int i=0; i<6; ++i )
{
GL_CALL( glTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, 0, GL_RGBA16F, sizeO, sizeO, 0, GL_RGBA, GL_HALF_FLOAT, NULL ) );
}
GL_CALL( glGenerateMipmap( GL_TEXTURE_CUBE_MAP ) );
// FBOs
//
// Create FBO 1
GLuint fbo1;
GL_CALL( glGenFramebuffers( 1, &fbo1 ) );
GL_CALL( glBindFramebuffer( GL_FRAMEBUFFER, fbo1 ) );
for( int level=0; level<mips; ++level )
{
for( int i=0; i<6; ++i )
{
GL_CALL( glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, tex1, level ) );
}
}
IsFramebufferValid( GL_FRAMEBUFFER );
// Create FBO 2
GLuint fbo2;
GL_CALL( glGenFramebuffers( 1, &fbo2 ) );
GL_CALL( glBindFramebuffer( GL_FRAMEBUFFER, fbo2 ) );
for( int level=0; level<mips; ++level )
{
for( int i=0; i<6; ++i )
{
GL_CALL( glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, tex2, level ) );
glViewport( 0, 0, sizeO, sizeO );
}
}
IsFramebufferValid( GL_FRAMEBUFFER );
// Copy FBO 1 to 2
int nw = sizeO;
GL_CALL( glBindFramebuffer( GL_READ_FRAMEBUFFER, fbo1 ) );
GL_CALL( glBindFramebuffer( GL_DRAW_FRAMEBUFFER, fbo2 ) );
for( int level=0; level<mips; ++level )
{
for( int i=0; i<6; ++i )
{
GL_CALL( glFramebufferTexture2D( GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, tex1, level ) );
GL_CALL( glFramebufferTexture2D( GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, tex2, level ) );
glViewport( 0, 0, nw, nw );
GL_CALL( glBlitFramebuffer( 0, 0, nw, nw, 0, 0, nw, nw, GL_COLOR_BUFFER_BIT, GL_NEAREST ) );
}
nw /= 2;
}
GL_CALL( glBindFramebuffer( GL_READ_FRAMEBUFFER, 0 ) );
GL_CALL( glBindFramebuffer( GL_DRAW_FRAMEBUFFER, 0 ) );
#ifdef REPORT_RESULT
int result = 0;
REPORT_RESULT();
#endif
return 0;
}
void never() {
int result = 0;
REPORT_RESULT();
}
void one() {
SDL_Event event;
while (SDL_PollEvent(&event)) {
printf("got event %d\n", event.type);
switch(event.type) {
case SDL_KEYDOWN:
break;
case SDL_KEYUP:
// don't handle the modifier key events
if (event.key.keysym.sym == SDLK_LCTRL ||
event.key.keysym.sym == SDLK_LSHIFT ||
event.key.keysym.sym == SDLK_LALT) {
return;
}
if ((event.key.keysym.mod & KMOD_LCTRL) || (event.key.keysym.mod & KMOD_RCTRL)) {
result *= 2;
}
if ((event.key.keysym.mod & KMOD_LSHIFT) || (event.key.keysym.mod & KMOD_RSHIFT)) {
result *= 3;
}
if ((event.key.keysym.mod & KMOD_LALT) || (event.key.keysym.mod & KMOD_RALT)) {
result *= 5;
}
switch (event.key.keysym.sym) {
case SDLK_RIGHT:
printf("right\n");
result *= 7;
break;
case SDLK_LEFT:
printf("left\n");
result *= 11;
break;
case SDLK_DOWN:
printf("down\n");
result *= 13;
break;
case SDLK_UP:
printf("up\n");
result *= 17;
break;
case SDLK_a:
printf("a\n");
result *= 19;
break;
default: {
if (event.key.keysym.scancode == SDL_SCANCODE_B) {
printf("b scancode\n");
result *= 23;
break;
}
printf("unknown key: sym %d scancode %d\n", event.key.keysym.sym, event.key.keysym.scancode);
REPORT_RESULT();
emscripten_run_script("throw 'done'"); // comment this out to leave event handling active. Use the following to log DOM keys:
// addEventListener('keyup', function(event) { console.log(event.keyCode) }, true)
}
}
break;
default: /* Report an unhandled event */
printf("I don't know what this event is!\n");
}
}
}
int main()
{
EmscriptenWebGLContextAttributes attrs;
emscripten_webgl_init_context_attributes(&attrs);
attrs.enableExtensionsByDefault = 1;
attrs.majorVersion = 2;
attrs.minorVersion = 0;
EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context( 0, &attrs );
if (!context)
{
printf("Skipped: WebGL 2 is not supported.\n");
#ifdef REPORT_RESULT
REPORT_RESULT();
#endif
return 0;
}
emscripten_webgl_make_context_current(context);
const char *vertexShader =
"#version 300 es\n"
"uniform Block1a {\n"
" uniform mat4 var1;\n"
" uniform vec4 variable2;\n"
"} block1bb;\n"
"uniform Block2ccc {\n"
" uniform mat4 var1;\n"
" uniform vec4 variable2;\n"
"} block2dddd;\n"
"void main() {\n"
" gl_Position = block1bb.var1*block1bb.variable2 + block2dddd.var1*block2dddd.variable2;\n"
"}\n";
const char *fragmentShader =
"#version 300 es\n"
"precision lowp float;\n"
" uniform Block3eeeee {\n"
" uniform vec4 var1;\n"
" uniform vec4 variable2;\n"
"} block3ffffff;\n" // Append characters of different lengths to test name string lengths.
"out vec4 outColor;\n"
"void main() {\n"
" outColor = block3ffffff.var1 + block3ffffff.variable2;\n"
"}\n";
GLuint vs = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vs, 1, &vertexShader, NULL);
glCompileShader(vs);
int ok = 0;
glGetShaderiv(vs, GL_COMPILE_STATUS, &ok);
if (!ok) {
printf("Shader compilation error with vertex\n");
GLint infoLen = 0;
glGetShaderiv (vs, GL_INFO_LOG_LENGTH, &infoLen);
if (infoLen > 1)
{
char* infoLog = (char *)malloc(sizeof(char) * infoLen+1);
glGetShaderInfoLog(vs, infoLen, NULL, infoLog);
printf("Error compiling shader:\n%s\n", infoLog);
}
}
GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fs, 1, &fragmentShader, NULL);
glCompileShader(fs);
glGetShaderiv(fs, GL_COMPILE_STATUS, &ok);
if (!ok) {
printf("Shader compilation error with fragment\n");
GLint infoLen = 0;
glGetShaderiv (vs, GL_INFO_LOG_LENGTH, &infoLen);
if (infoLen > 1)
{
char* infoLog = (char *)malloc(sizeof(char) * infoLen+1);
glGetShaderInfoLog(vs, infoLen, NULL, infoLog);
printf("Error compiling shader:\n%s\n", infoLog);
}
}
GLuint program = glCreateProgram();
glAttachShader(program, vs);
glAttachShader(program, fs);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &ok);
assert(ok);
int maxLength = 0;
glGetProgramiv(program, GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, &maxLength);
printf("GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH: %d\n", maxLength);
assert(maxLength == 12);
GLint numActiveUniformBlocks = -1;
glGetProgramiv(program, GL_ACTIVE_UNIFORM_BLOCKS, &numActiveUniformBlocks);
assert(numActiveUniformBlocks == 3);
// Dump all active uniform buffer blocks of the current program.
for(int i = 0; i < numActiveUniformBlocks; ++i)
{
char str[256] = {};
GLsizei length = -1;
glGetActiveUniformBlockName(program, i, 255, &length, str);
assert(length > 0);
printf("Active uniform block at index %d: %s\n", i, str);
GLint param = -1;
#define DUMPUNIFORMBLOCKSTATUS(stat) glGetActiveUniformBlockiv(program, i, stat, ¶m); printf("%s: %d\n", #stat, param);
DUMPUNIFORMBLOCKSTATUS(GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER);
DUMPUNIFORMBLOCKSTATUS(GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER);
DUMPUNIFORMBLOCKSTATUS(GL_UNIFORM_BLOCK_BINDING);
DUMPUNIFORMBLOCKSTATUS(GL_UNIFORM_BLOCK_DATA_SIZE);
DUMPUNIFORMBLOCKSTATUS(GL_UNIFORM_BLOCK_NAME_LENGTH);
DUMPUNIFORMBLOCKSTATUS(GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS);
GLint indices[16] = {};
glGetActiveUniformBlockiv(program, i, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, indices);
for(size_t i = 0; i < param; ++i)
printf("offset for index %d: %d\n", i, indices[i]);
}
#ifdef REPORT_RESULT
REPORT_RESULT();
#endif
return 0;
}
int main()
{
{
T x = HILO(5, 3);
T y = __sync_add_and_fetch(&x, DUP(1));
assert(y == HILO(6, 4));
assert(x == HILO(6, 4));
volatile T n = HILO(2, 1);
if (emscripten_has_threading_support())
{
for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_add_and_fetch, (void*)&n);
for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
printf("n: %llx\n", n);
assert(n == HILO(NUM_THREADS*10000ULL+2ULL, NUM_THREADS*10000ULL+1ULL));
}
}
{
T x = HILO(15, 13);
T y = __sync_sub_and_fetch(&x, HILO(10, 10));
assert(y == HILO(5, 3));
assert(x == HILO(5, 3));
volatile T n = HILO(NUM_THREADS*10000ULL+5ULL, NUM_THREADS*10000ULL+3ULL);
if (emscripten_has_threading_support())
{
for(int i = 0; i < NUM_THREADS; ++i) pthread_create(&thread[i], NULL, thread_sub_and_fetch, (void*)&n);
for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
printf("n: %llx\n", n);
assert(n == HILO(5,3));
}
}
{
T x = HILO(32768 + 5, 5);
T y = __sync_or_and_fetch(&x, HILO(65536 + 9, 9));
assert(y == HILO(32768 + 65536 + 13, 13));
assert(x == HILO(32768 + 65536 + 13, 13));
for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
{
or_and_fetch_data = HILO(65536 + (1<<NUM_THREADS), 1<<NUM_THREADS);
if (emscripten_has_threading_support())
{
for(int i = 0; i < NUM_THREADS; ++i)
{
threadArg[i] = DUP(1 << i);
pthread_create(&thread[i], NULL, thread_or_and_fetch, (void*)&threadArg[i]);
}
for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
assert(or_and_fetch_data == HILO(65536 + (1<<(NUM_THREADS+1))-1, (1<<(NUM_THREADS+1))-1));
}
}
}
{
T x = HILO(32768 + 5, 5);
T y = __sync_and_and_fetch(&x, HILO(32768 + 9, 9));
assert(y == HILO(32768 + 1, 1));
assert(x == HILO(32768 + 1, 1));
if (emscripten_has_threading_support())
{
for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
{
and_and_fetch_data = HILO(65536 + (1<<(NUM_THREADS+1))-1, (1<<(NUM_THREADS+1))-1);
for(int i = 0; i < NUM_THREADS; ++i)
{
threadArg[i] = DUP(~(1UL<<i));
pthread_create(&thread[i], NULL, thread_and_and_fetch, (void*)&threadArg[i]);
}
for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
assert(and_and_fetch_data == HILO(65536 + (1<<NUM_THREADS), 1<<NUM_THREADS));
}
}
}
{
T x = HILO(32768 + 5, 5);
T y = __sync_xor_and_fetch(&x, HILO(16384 + 9, 9));
assert(y == HILO(32768 + 16384 + 12, 12));
assert(x == HILO(32768 + 16384 + 12, 12));
if (emscripten_has_threading_support())
{
for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
{
xor_and_fetch_data = HILO(32768 + (1<<NUM_THREADS), 1<<NUM_THREADS);
for(int i = 0; i < NUM_THREADS; ++i)
{
threadArg[i] = DUP(~(1UL<<i));
pthread_create(&thread[i], NULL, thread_xor_and_fetch, (void*)&threadArg[i]);
}
for(int i = 0; i < NUM_THREADS; ++i) pthread_join(thread[i], NULL);
assert(xor_and_fetch_data == HILO(32768 + ((1<<(NUM_THREADS+1))-1), (1<<(NUM_THREADS+1))-1));
}
}
}
// XXX NAND support does not exist in Atomics API.
#if 0
{
T x = 5;
T y = __sync_nand_and_fetch(&x, 9);
assert(y == 5);
assert(x == -2);
const int oddNThreads = NUM_THREADS-1;
for(int x = 0; x < 100; ++x) // Test a few times for robustness, since this test is so short-lived.
{
nand_and_fetch_data = 0;
for(int i = 0; i < oddNThreads; ++i) pthread_create(&thread[i], NULL, thread_nand_and_fetch, (void*)-1);
for(int i = 0; i < oddNThreads; ++i) pthread_join(thread[i], NULL);
assert(nand_and_fetch_data == -1);
}
}
#endif
#ifdef REPORT_RESULT
REPORT_RESULT(0);
#endif
}
void PullInfo(){
printf("================================================================================\n");
int major, minor, rev;
glfwGetVersion(&major, &minor, &rev);
printf("GLFW version is %i.%i.%i\n", major, minor, rev);
int width, height;
glfwGetWindowSize(&width, &height);
printf("Window size is %i %i\n", width, height);
int status = glfwGetKey(GLFW_KEY_LCTRL);
if(status == GLFW_PRESS)
printf("Left control is pressed\n");
else
printf("Left control is released\n");
status = glfwGetMouseButton(GLFW_MOUSE_BUTTON_1);
if(status == GLFW_PRESS)
printf("Mouse button 1 is pressed\n");
else
printf("Mouse button 1 is released\n");
int x, y;
glfwGetMousePos(&x, &y);
printf("Mouse position is %i %i\n", x, y);
int wheel = glfwGetMouseWheel();
printf("Mouse wheel pos is %i\n", wheel);
double time = glfwGetTime();
printf("Time is %f\n", time);
glfwGetGLVersion(&major, &minor, &rev);
printf("GL version is %i.%i.%i\n", major, minor, rev);
int proc = glfwGetNumberOfProcessors();
printf("%i processors are available\n", proc);
unsigned int i;
for(i = 0; i<nb_params; i++)
printf(" - %-27s : %i\n", GetParamName(params[i]), glfwGetWindowParam(params[i]));
const char* extension = "MOZ_WEBGL_compressed_texture_s3tc";
printf("'%s' extension is %s.\n", extension, glfwExtensionSupported(extension) ? "supported" : "not supported");
extension = "GL_EXT_framebuffer_object";
printf("'%s' extension is %s.\n", extension, glfwExtensionSupported(extension) ? "supported" : "not supported");
extension = "glBindBuffer";
void* proc_addr = glfwGetProcAddress(extension);
printf("'%s' extension proc address is %p.\n", extension, proc_addr);
printf("Sleeping 1 sec...\n");
glfwSleep(1);
printf("...Done.\n");
printf("================================================================================\n");
#ifdef REPORT_RESULT
int result = 1;
REPORT_RESULT();
#endif
}
void done(int channel) {
assert(channel == 1);
int result = 1;
REPORT_RESULT();
}
void main_2(void* arg) {
// TODO: At the moment, we only support joystick support through polling.
emscripten_run_script("window.addNewGamepad('Pad Thai', 4, 16)");
emscripten_run_script("window.addNewGamepad('Pad Kee Mao', 0, 4)");
// Check that the joysticks exist properly.
assert(SDL_NumJoysticks() == 2);
assert(!SDL_JoystickOpened(0));
assert(!SDL_JoystickOpened(1));
SDL_Joystick* pad1 = SDL_JoystickOpen(0);
assert(SDL_JoystickOpened(0));
assert(SDL_JoystickIndex(pad1) == 0);
assert(strncmp(SDL_JoystickName(0), "Pad Thai", 9) == 0);
assert(strncmp(SDL_JoystickName(1), "Pad Kee Mao", 12) == 0);
assert(SDL_JoystickNumAxes(pad1) == 4);
assert(SDL_JoystickNumButtons(pad1) == 16);
// Button events.
emscripten_run_script("window.simulateGamepadButtonDown(0, 1)");
// We didn't tell SDL to automatically update this joystick's state.
assertNoJoystickEvent();
SDL_JoystickUpdate();
assertJoystickEvent(0, SDL_JOYBUTTONDOWN, 1, SDL_PRESSED);
assert(SDL_JoystickGetButton(pad1, 1) == 1);
// Enable automatic updates.
SDL_JoystickEventState(SDL_ENABLE);
assert(SDL_JoystickEventState(SDL_QUERY) == SDL_ENABLE);
emscripten_run_script("window.simulateGamepadButtonUp(0, 1)");
assertJoystickEvent(0, SDL_JOYBUTTONUP, 1, SDL_RELEASED);
assert(SDL_JoystickGetButton(pad1, 1) == 0);
// No button change: Should not result in a new event.
emscripten_run_script("window.simulateGamepadButtonUp(0, 1)");
assertNoJoystickEvent();
// Joystick 1 is not opened; should not result in a new event.
emscripten_run_script("window.simulateGamepadButtonDown(1, 1)");
assertNoJoystickEvent();
// Joystick wiggling
emscripten_run_script("window.simulateAxisMotion(0, 0, 1)");
assertJoystickEvent(0, SDL_JOYAXISMOTION, 0, 32767);
assert(SDL_JoystickGetAxis(pad1, 0) == 32767);
emscripten_run_script("window.simulateAxisMotion(0, 0, 0)");
assertJoystickEvent(0, SDL_JOYAXISMOTION, 0, 0);
assert(SDL_JoystickGetAxis(pad1, 0) == 0);
emscripten_run_script("window.simulateAxisMotion(0, 1, -1)");
assertJoystickEvent(0, SDL_JOYAXISMOTION, 1, -32768);
assert(SDL_JoystickGetAxis(pad1, 1) == -32768);
emscripten_run_script("window.simulateAxisMotion(0, 1, -1)");
// No joystick change: Should not result in a new event.
assertNoJoystickEvent();
// Joystick 1 is not opened; should not result in a new event.
emscripten_run_script("window.simulateAxisMotion(1, 1, -1)");
assertNoJoystickEvent();
SDL_JoystickClose(pad1);
assert(!SDL_JoystickOpened(0));
// Joystick 0 is closed; we should not process any new gamepad events from it.
emscripten_run_script("window.simulateGamepadButtonDown(0, 1)");
assertNoJoystickEvent();
// End test.
result = 2;
printf("Test passed!\n");
REPORT_RESULT();
}
int main() {
printf("main() called.\n");
int result = emscripten_run_script_int("Module.okk");
REPORT_RESULT(result);
return 1;
}
void onerror(void* arg)
{
assert(expected == (int)arg);
result = 999;
REPORT_RESULT();
}
void success()
{
REPORT_RESULT();
}
int main()
{
GLFWwindow *window;
char *userptr = "userptr";
glfwSetErrorCallback(errorcb);
assert(glfwInit() == GL_TRUE);
assert(!strcmp(glfwGetVersionString(), "3.2.1 JS WebGL Emscripten"));
assert(glfwGetCurrentContext() == NULL);
{
int major, minor, rev;
glfwGetVersion(&major, &minor, &rev);
assert(major == 3);
assert(minor == 2);
assert(rev == 1);
}
{
int count, x, y, w, h;
GLFWmonitor **monitors = glfwGetMonitors(&count);
assert(count == 1);
for (int i = 0; i < count; ++i) {
assert(monitors[i] != NULL);
}
assert(glfwGetPrimaryMonitor() != NULL);
glfwGetMonitorPos(monitors[0], &x, &y);
glfwGetMonitorPhysicalSize(monitors[0], &w, &h);
assert(glfwGetMonitorName(monitors[0]) != NULL);
glfwSetMonitorCallback(monitcb);
// XXX: not implemented
// assert(glfwGetVideoModes(monitors[0], &count) != NULL);
// assert(glfwGetVideoMode(monitors[0]) != NULL);
// glfwSetGamma(monitors[0], 1.0f);
// assert(glfwGetGammaRamp(monitors[0]) != NULL);
// glfwSetGammaRamp(monitors[0], ramp);
}
{
int x, y, w, h;
glfwDefaultWindowHints();
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
window = glfwCreateWindow(640, 480, "glfw3.c", NULL, NULL);
assert(window != NULL);
glfwSetWindowPosCallback(window, wposicb);
glfwSetWindowSizeCallback(window, wsizecb);
glfwSetWindowCloseCallback(window, wcloscb);
glfwSetWindowRefreshCallback(window, wrfrscb);
glfwSetWindowFocusCallback(window, wfocucb);
glfwSetWindowIconifyCallback(window, wiconcb);
glfwSetFramebufferSizeCallback(window, wfsizcb);
assert(glfwWindowShouldClose(window) == 0);
glfwSetWindowShouldClose(window, 1);
assert(glfwWindowShouldClose(window) == 1);
glfwSetWindowTitle(window, "test");
glfwSetWindowTitle(window, "glfw3.c");
// XXX: not implemented
// glfwSetWindowPos(window, 1, 1);
glfwGetWindowPos(window, &x, &y); // stub
glfwGetWindowSize(window, &w, &h);
assert(w == 640 && h == 480);
glfwSetWindowSize(window, 1, 1);
glfwGetWindowSize(window, &w, &h);
assert(w == 1 && h == 1);
glfwSetWindowSize(window, 640, 480);
glfwGetFramebufferSize(window, &w, &h);
// XXX: not implemented
// glfwIconifyWindow(window);
// glfwRestoreWindow(window);
// glfwShowWindow(window);
// glfwHideWindow(window);
assert(glfwGetWindowMonitor(window) == NULL);
glfwDestroyWindow(window);
window = glfwCreateWindow(640, 480, "glfw3.c", glfwGetPrimaryMonitor(), NULL);
assert(window != NULL);
assert(glfwGetWindowMonitor(window) == glfwGetPrimaryMonitor());
glfwDestroyWindow(window);
window = glfwCreateWindow(640, 480, "glfw3.c", NULL, NULL);
assert(window != NULL);
assert(glfwGetWindowAttrib(window, GLFW_CLIENT_API) == GLFW_OPENGL_ES_API);
assert(glfwGetWindowUserPointer(window) == NULL);
glfwSetWindowUserPointer(window, userptr);
assert(glfwGetWindowUserPointer(window) == userptr);
}
{
double x, y;
glfwSetKeyCallback(window, wkeypcb);
glfwSetCharCallback(window, wcharcb);
glfwSetMouseButtonCallback(window, wmbutcb);
glfwSetCursorPosCallback(window, wcurpcb);
glfwSetCursorEnterCallback(window, wcurecb);
glfwSetScrollCallback(window, wscrocb);
// XXX: stub, events come immediatly
// glfwPollEvents();
// glfwWaitEvents();
assert(glfwGetInputMode(window, GLFW_CURSOR) == GLFW_CURSOR_NORMAL);
// XXX: not implemented
// glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
glfwGetKey(window, GLFW_KEY_A);
glfwGetMouseButton(window, 0);
glfwGetCursorPos(window, &x, &y);
// XXX: not implemented
// glfwSetCursorPos(window, 0, 0);
}
{
// XXX: not implemented
// glfwJoystickPresent(joy);
// glfwGetJoystickAxes(joy, &count);
// glfwGetJoystickButtons(joy, &count);
// glfwGetJoystickName(joy);
}
{
// XXX: not implemented
// glfwSetClipboardString(window, "string");
// glfwGetClipboardString(window);
}
{
glfwGetTime();
glfwSetTime(0);
}
{
glfwMakeContextCurrent(window); // stub
assert(glfwGetCurrentContext() == window);
glfwSwapBuffers(window); // stub
glfwSwapInterval(0); // stub
}
{
assert(glfwExtensionSupported("nonexistant") == 0);
assert(glfwGetProcAddress("nonexistant") == NULL);
}
glfwTerminate();
#ifdef REPORT_RESULT
REPORT_RESULT(1);
#endif
return 0;
}
runall_result test_main()
{
accelerator::set_default(require_device_with_double().device_path);
runall_result result;
result &= REPORT_RESULT((test_feature<int, 1>()));
result &= REPORT_RESULT((test_feature<int, 2>()));
result &= REPORT_RESULT((test_feature<int, 3>()));
result &= REPORT_RESULT((test_feature<int, 5>()));
result &= REPORT_RESULT((test_feature<unsigned, 1>()));
result &= REPORT_RESULT((test_feature<unsigned, 2>()));
result &= REPORT_RESULT((test_feature<unsigned, 3>()));
result &= REPORT_RESULT((test_feature<unsigned, 5>()));
result &= REPORT_RESULT((test_feature<float, 1>()));
result &= REPORT_RESULT((test_feature<float, 2>()));
result &= REPORT_RESULT((test_feature<float, 3>()));
result &= REPORT_RESULT((test_feature<float, 5>()));
result &= REPORT_RESULT((test_feature<double, 1>()));
result &= REPORT_RESULT((test_feature<double, 2>()));
result &= REPORT_RESULT((test_feature<double, 3>()));
result &= REPORT_RESULT((test_feature<double, 5>()));
return result;
}
void ok(void* arg)
{
assert(expected == (int)arg);
REPORT_RESULT();
}
void EMSCRIPTEN_KEEPALIVE report(int result) {
REPORT_RESULT();
}
void onbadload(void* arg, void* ptr, int num)
{
printf("load failed, surprising\n");
result = 999;
REPORT_RESULT();
}
void EMSCRIPTEN_KEEPALIVE finish(int result) {
REPORT_RESULT();
}
