From ab8beedeb70c6941e0ff68014d8db64cee4ef15d Mon Sep 17 00:00:00 2001 From: The Android Open Source Project Date: Wed, 17 Dec 2008 18:08:09 -0800 Subject: [PATCH] Code drop from //branches/cupcake/...@124589 --- su/su.c | 7 +- tests/bionic/libc/Android.mk | 114 +++++++ tests/bionic/libc/MODULE_LICENSE_BSD_AND_GPL | 0 tests/bionic/libc/README.TXT | 32 ++ tests/bionic/libc/bionic/test_cond.c | 97 ++++++ tests/bionic/libc/bionic/test_getgrouplist.c | 58 ++++ tests/bionic/libc/bionic/test_mutex.c | 109 +++++++ tests/bionic/libc/bionic/test_netinet_icmp.c | 8 + tests/bionic/libc/bionic/test_pthread_cond.c | 83 +++++ tests/bionic/libc/bionic/test_pthread_create.c | 30 ++ tests/bionic/libc/common/test_gethostbyname.c | 53 +++ tests/bionic/libc/common/test_gethostname.c | 20 ++ tests/bionic/libc/common/test_libgen.c | 221 +++++++++++++ .../bionic/libc/common/test_pthread_cleanup_push.c | 134 ++++++++ .../libc/common/test_pthread_getcpuclockid.c | 86 +++++ tests/bionic/libc/common/test_pthread_join.c | 76 +++++ tests/bionic/libc/common/test_pthread_once.c | 82 +++++ tests/bionic/libc/common/test_semaphore.c | 129 ++++++++ tests/bionic/libc/common/test_seteuid.c | 57 ++++ tests/bionic/libc/common/test_static_cpp_mutex.cpp | 64 ++++ tests/bionic/libc/common/test_tm_zone.c | 55 ++++ tests/bionic/libc/common/test_udp.c | 121 +++++++ tests/bionic/libc/glibc/assert/test-assert.c | 88 +++++ tests/bionic/libc/other/bench_locks.c | 32 ++ tests/bionic/libc/other/test_aligned.c | 117 +++++++ tests/bionic/libc/other/test_arc4random.c | 40 +++ tests/bionic/libc/other/test_atomics.c | 17 + tests/bionic/libc/other/test_jpeg.c | 362 +++++++++++++++++++++ tests/bionic/libc/other/test_sysconf.c | 137 ++++++++ tests/bionic/libc/other/test_system.c | 28 ++ tests/bionic/libc/other/test_thread_max.c | 63 ++++ tests/bionic/libc/other/test_timer_create.c | 88 +++++ tests/bionic/libc/other/test_vfprintf_leak.c | 55 ++++ tests/bionic/libc/other/test_zlib.c | 267 +++++++++++++++ tests/cpueater/Android.mk | 8 + tests/cpueater/daemonize.c | 130 ++++++++ tests/framebuffer/Android.mk | 33 ++ tests/framebuffer/fb_test.c | 232 +++++++++++++ tests/framebuffer/minui.h | 56 ++++ tests/framebuffer/refresh.c | 169 ++++++++++ tests/fstest/perm_checker.conf | 61 ++-- 41 files changed, 3592 insertions(+), 27 deletions(-) create mode 100644 tests/bionic/libc/Android.mk create mode 100644 tests/bionic/libc/MODULE_LICENSE_BSD_AND_GPL create mode 100644 tests/bionic/libc/README.TXT create mode 100644 tests/bionic/libc/bionic/test_cond.c create mode 100644 tests/bionic/libc/bionic/test_getgrouplist.c create mode 100644 tests/bionic/libc/bionic/test_mutex.c create mode 100644 tests/bionic/libc/bionic/test_netinet_icmp.c create mode 100644 tests/bionic/libc/bionic/test_pthread_cond.c create mode 100644 tests/bionic/libc/bionic/test_pthread_create.c create mode 100644 tests/bionic/libc/common/test_gethostbyname.c create mode 100644 tests/bionic/libc/common/test_gethostname.c create mode 100644 tests/bionic/libc/common/test_libgen.c create mode 100644 tests/bionic/libc/common/test_pthread_cleanup_push.c create mode 100644 tests/bionic/libc/common/test_pthread_getcpuclockid.c create mode 100644 tests/bionic/libc/common/test_pthread_join.c create mode 100644 tests/bionic/libc/common/test_pthread_once.c create mode 100644 tests/bionic/libc/common/test_semaphore.c create mode 100644 tests/bionic/libc/common/test_seteuid.c create mode 100644 tests/bionic/libc/common/test_static_cpp_mutex.cpp create mode 100644 tests/bionic/libc/common/test_tm_zone.c create mode 100644 tests/bionic/libc/common/test_udp.c create mode 100644 tests/bionic/libc/glibc/assert/test-assert.c create mode 100644 tests/bionic/libc/other/bench_locks.c create mode 100644 tests/bionic/libc/other/test_aligned.c create mode 100644 tests/bionic/libc/other/test_arc4random.c create mode 100644 tests/bionic/libc/other/test_atomics.c create mode 100644 tests/bionic/libc/other/test_jpeg.c create mode 100644 tests/bionic/libc/other/test_sysconf.c create mode 100644 tests/bionic/libc/other/test_system.c create mode 100644 tests/bionic/libc/other/test_thread_max.c create mode 100644 tests/bionic/libc/other/test_timer_create.c create mode 100644 tests/bionic/libc/other/test_vfprintf_leak.c create mode 100644 tests/bionic/libc/other/test_zlib.c create mode 100644 tests/cpueater/daemonize.c create mode 100644 tests/framebuffer/Android.mk create mode 100644 tests/framebuffer/fb_test.c create mode 100644 tests/framebuffer/minui.h create mode 100644 tests/framebuffer/refresh.c diff --git a/su/su.c b/su/su.c index aac981ea..5c9ca106 100644 --- a/su/su.c +++ b/su/su.c @@ -29,11 +29,11 @@ /* * SU can be given a specific command to exec. UID _must_ be - * specified for this (ie argc => 3). Full path of file must be specified. + * specified for this (ie argc => 3). * * Usage: * su 1000 - * su 1000 /system/bin/ls -l + * su 1000 ls -l */ int main(int argc, char **argv) { @@ -70,7 +70,7 @@ int main(int argc, char **argv) char *exec_args[argc - 1]; memset(exec_args, 0, sizeof(exec_args)); memcpy(exec_args, &argv[2], sizeof(exec_args)); - if (execv(argv[2], exec_args) < 0) { + if (execvp(argv[2], exec_args) < 0) { fprintf(stderr, "su: exec failed for %s Error:%s\n", argv[2], strerror(errno)); return -errno; @@ -83,4 +83,3 @@ int main(int argc, char **argv) fprintf(stderr, "su: exec failed\n"); return 1; } - diff --git a/tests/bionic/libc/Android.mk b/tests/bionic/libc/Android.mk new file mode 100644 index 00000000..14ac0c0c --- /dev/null +++ b/tests/bionic/libc/Android.mk @@ -0,0 +1,114 @@ +# Copyright (C) 2008 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Build control file for Bionic's test programs +# define the BIONIC_TESTS environment variable to build the test programs +# +ifdef BIONIC_TESTS + +LOCAL_PATH:= $(call my-dir) + +# used to define a simple test program and build it as a standalone +# device executable. +# +# you can use EXTRA_CFLAGS to indicate additional CFLAGS to use +# in the build. the variable will be cleaned on exit +# +define device-test + $(foreach file,$(1), \ + $(eval include $(CLEAR_VARS)) \ + $(eval LOCAL_SRC_FILES := $(file)) \ + $(eval LOCAL_MODULE := $(notdir $(file:%.c=%))) \ + $(eval $(info LOCAL_MODULE=$(LOCAL_MODULE))) \ + $(eval LOCAL_CFLAGS += $(EXTRA_CFLAGS)) \ + $(eval LOCAL_MODULE_TAGS := tests) \ + $(eval include $(BUILD_EXECUTABLE)) \ + ) \ + $(eval EXTRA_CFLAGS :=) +endef + +# same as 'device-test' but builds a host executable instead +# you can use EXTRA_LDLIBS to indicate additional linker flags +# +define host-test + $(foreach file,$(1), \ + $(eval include $(CLEAR_VARS)) \ + $(eval LOCAL_SRC_FILES := $(file)) \ + $(eval LOCAL_MODULE := $(notdir $(file:%.c=%))) \ + $(eval $(info LOCAL_MODULE=$(LOCAL_MODULE) file=$(file))) \ + $(eval LOCAL_CFLAGS += $(EXTRA_CFLAGS)) \ + $(eval LOCAL_LDLIBS += $(EXTRA_LDLIBS)) \ + $(eval LOCAL_MODULE_TAGS := tests) \ + $(eval include $(BUILD_HOST_EXECUTABLE)) \ + ) \ + $(eval EXTRA_CFLAGS :=) \ + $(eval EXTRA_LDLIBS :=) +endef + +# First, the tests in 'common' + +sources := \ + common/test_gethostbyname.c \ + common/test_gethostname.c \ + common/test_pthread_cleanup_push.c \ + common/test_pthread_getcpuclockid.c \ + common/test_pthread_join.c \ + common/test_pthread_once.c \ + common/test_semaphore.c \ + common/test_seteuid.c \ + common/test_static_cpp_mutex.cpp \ + common/test_tm_zone.c \ + common/test_udp.c \ + +EXTRA_LDLIBS := -lpthread -lrt +$(call host-test, $(sources)) +$(call device-test, $(sources)) + +sources := \ + common/test_libgen.c \ + +EXTRA_CFLAGS := -DHOST +$(call host-test, $(sources)) +$(call device-test, $(sources)) + +# Second, the Bionic-specific tests + +sources := \ + bionic/test_mutex.c \ + bionic/test_cond.c \ + bionic/test_getgrouplist.c \ + bionic/test_netinet_icmp.c \ + bionic/test_pthread_cond.c \ + bionic/test_pthread_create.c \ + +$(call device-test, $(sources)) + +# Third, the other tests + +sources := \ + other/bench_locks.c \ + other/test_aligned.c \ + other/test_arc4random.c \ + other/test_atomics.c \ + other/test_sysconf.c \ + other/test_system.c \ + other/test_thread_max.c \ + other/test_timer_create.c \ + other/test_vfprintf_leak.c \ + +$(call device-test, $(sources)) + +# TODO: Add a variety of GLibc test programs too... + +endif # BIONIC_TESTS diff --git a/tests/bionic/libc/MODULE_LICENSE_BSD_AND_GPL b/tests/bionic/libc/MODULE_LICENSE_BSD_AND_GPL new file mode 100644 index 00000000..e69de29b diff --git a/tests/bionic/libc/README.TXT b/tests/bionic/libc/README.TXT new file mode 100644 index 00000000..5576b77b --- /dev/null +++ b/tests/bionic/libc/README.TXT @@ -0,0 +1,32 @@ +This directory contains a set of tests for Android's Bionic C library. + +These sources are not distributed with Bionic itself because some of +these tests come from the GNU C Library, and are licensed under the +GNU Lesser General Public License (LGPL) + +You must define the BIONIC_TESTS environment variable to build these +test programs. For example, do: + + cd system/bionic-tests/ + mm BIONIC_TESTS=1 + +All test programs, except those in the 'other' directory, should exit +with a status code of 0 in case of success, and 1 in case of failure. + +The directory layout is simple: + + common/ + Contains tests that can be compiled either with Bionic or another + C library. + + glibc/ + Contains tests that come from the GNU C Library. However, they can + be compiled with Bionic too. + + bionic/ + Contains tests that can *only* be compiled against Bionic + + other/ + Other unrelated tests. These are not run by the test runner + program but will be installed to your device nevertheless. + Put benchmarks and various debug/info stuff there. diff --git a/tests/bionic/libc/bionic/test_cond.c b/tests/bionic/libc/bionic/test_cond.c new file mode 100644 index 00000000..6a85f9b4 --- /dev/null +++ b/tests/bionic/libc/bionic/test_cond.c @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include +#include +#include +#include +#include +#include +#include + +static pthread_mutex_t lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER; +static pthread_cond_t wait = PTHREAD_COND_INITIALIZER; + +static void* _thread1(void *__u __attribute__((unused))) +{ + printf("1: obtaining mutex\n"); + pthread_mutex_lock(&lock); + printf("1: waiting on condition variable\n"); + pthread_cond_wait(&wait, &lock); + printf("1: releasing mutex\n"); + pthread_mutex_unlock(&lock); + printf("1: exiting\n"); + return NULL; +} + +static void* _thread2(void *__u __attribute__((unused))) +{ + int cnt = 2; + while(cnt--) { + printf("2: obtaining mutex\n"); + pthread_mutex_lock(&lock); + printf("2: signaling\n"); + pthread_cond_signal(&wait); + printf("2: releasing mutex\n"); + pthread_mutex_unlock(&lock); + } + + printf("2: exiting\n"); + return NULL; +} + +typedef void* (*thread_func)(void*); +static const thread_func thread_routines[] = +{ + &_thread1, + &_thread2, +}; + +int main(void) +{ + pthread_t t[2]; + int nn; + int count = (int)(sizeof t/sizeof t[0]); + + for (nn = 0; nn < count; nn++) { + printf("main: creating thread %d\n", nn+1); + if (pthread_create( &t[nn], NULL, thread_routines[nn], NULL) < 0) { + printf("main: could not create thread %d: %s\n", nn+1, strerror(errno)); + return -2; + } + } + + for (nn = 0; nn < count; nn++) { + printf("main: joining thread %d\n", nn+1); + if (pthread_join(t[nn], NULL)) { + printf("main: could not join thread %d: %s\n", nn+1, strerror(errno)); + return -2; + } + } + + return 0; +} diff --git a/tests/bionic/libc/bionic/test_getgrouplist.c b/tests/bionic/libc/bionic/test_getgrouplist.c new file mode 100644 index 00000000..e5b8ee26 --- /dev/null +++ b/tests/bionic/libc/bionic/test_getgrouplist.c @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include +#include + +#define MAX_GROUPS 100 +#define TEST_GROUP 1337 +#define TEST_USER "nobodyisreallyhere" + +int main(void) +{ + int count = MAX_GROUPS; + gid_t groups[MAX_GROUPS]; + int ret; + + /* this only tests the funky behaviour of our stubbed getgrouplist() + * implementation. which should only return TEST_GROUP, independent + * of the user + */ + ret = getgrouplist( TEST_USER, TEST_GROUP, groups, &count ); + if (ret != 1) { + fprintf(stderr, "getgrouplist() returned %d (expecting 1), ngroups=%d\n", + ret, count); + return 1; + } + if (groups[0] != TEST_GROUP) { + fprintf(stderr, "getgrouplist() returned group %d (expecting %d)\n", + groups[0], TEST_GROUP); + return 1; + } + printf ("ok\n"); + return 0; +} diff --git a/tests/bionic/libc/bionic/test_mutex.c b/tests/bionic/libc/bionic/test_mutex.c new file mode 100644 index 00000000..02257ba3 --- /dev/null +++ b/tests/bionic/libc/bionic/test_mutex.c @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#define __USE_UNIX98 1 /* necessary to define pthread_mutexattr_set/gettype in Linux GLIBC headers. doh ! */ +#include +#include +#include +#include +#include + +static void panic( const char* format, ... ) +{ + va_list args; + va_start(args, format); + vfprintf(stderr, format, args); + va_end(args); + exit(1); +} + +#define assert(cond) do { if ( !(cond) ) panic( "%s:%d: assertion failure: %s\n", __FILE__, __LINE__, #cond ); } while (0) + +#define expect(call,result) \ + do { \ + int ret = (call); \ + if (ret != (result)) { \ + panic( "%s:%d: call returned %d instead of %d: %s\n", \ + __FILE__, __LINE__, ret, (result), #call ); \ + } \ + } while (0) + + +int main( void ) +{ + pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; + pthread_mutexattr_t attr; + int attr_type; + + expect( pthread_mutexattr_init( &attr ), 0 ); + + expect( pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_NORMAL ), 0 ); + expect( pthread_mutexattr_gettype( &attr, &attr_type ), 0 ); + assert( attr_type == PTHREAD_MUTEX_NORMAL ); + + expect( pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_ERRORCHECK ), 0 ); + expect( pthread_mutexattr_gettype( &attr, &attr_type ), 0 ); + assert( attr_type == PTHREAD_MUTEX_ERRORCHECK ); + + expect( pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE ), 0 ); + expect( pthread_mutexattr_gettype( &attr, &attr_type ), 0 ); + assert( attr_type == PTHREAD_MUTEX_RECURSIVE ); + + /* standard mutexes */ + expect( pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_NORMAL ), 0 ); + expect( pthread_mutex_init( &lock, &attr ), 0 ); + expect( pthread_mutex_lock( &lock ), 0 ); + expect( pthread_mutex_unlock( &lock ), 0 ); + expect( pthread_mutex_destroy( &lock ), 0 ); + + /* error-check mutex */ + expect( pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_ERRORCHECK ), 0 ); + expect( pthread_mutex_init( &lock, &attr ), 0 ); + expect( pthread_mutex_lock( &lock ), 0 ); + expect( pthread_mutex_lock( &lock ), EDEADLK ); + expect( pthread_mutex_unlock( &lock ), 0 ); + expect( pthread_mutex_trylock( &lock ), 0 ); + expect( pthread_mutex_trylock( &lock ), EDEADLK ); + expect( pthread_mutex_unlock( &lock ), 0 ); + expect( pthread_mutex_unlock( &lock ), EPERM ); + expect( pthread_mutex_destroy( &lock ), 0 ); + + /* recursive mutex */ + expect( pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE ), 0 ); + expect( pthread_mutex_init( &lock, &attr ), 0 ); + expect( pthread_mutex_lock( &lock ), 0 ); + expect( pthread_mutex_lock( &lock ), 0 ); + expect( pthread_mutex_unlock( &lock ), 0 ); + expect( pthread_mutex_unlock( &lock ), 0 ); + expect( pthread_mutex_trylock( &lock ), 0 ); + expect( pthread_mutex_unlock( &lock ), 0 ); + expect( pthread_mutex_unlock( &lock ), EPERM ); + expect( pthread_mutex_destroy( &lock ), 0 ); + + printf( "ok\n" ); + return 0; +} diff --git a/tests/bionic/libc/bionic/test_netinet_icmp.c b/tests/bionic/libc/bionic/test_netinet_icmp.c new file mode 100644 index 00000000..308ccce9 --- /dev/null +++ b/tests/bionic/libc/bionic/test_netinet_icmp.c @@ -0,0 +1,8 @@ +/* this test simply checks that we can compile the header */ +#include + +int main( void ) +{ + return 0; +} + diff --git a/tests/bionic/libc/bionic/test_pthread_cond.c b/tests/bionic/libc/bionic/test_pthread_cond.c new file mode 100644 index 00000000..26746fa7 --- /dev/null +++ b/tests/bionic/libc/bionic/test_pthread_cond.c @@ -0,0 +1,83 @@ +#include +#include +#include +#include +#include + + +static pthread_cond_t cond1; +static pthread_cond_t cond2; +static pthread_mutex_t test_lock = PTHREAD_MUTEX_INITIALIZER; + +static void * +thread1_func(void* arg) +{ + printf("Thread 1 (arg=%d tid=%d) entered.\n", (unsigned)arg, gettid()); + printf("1 waiting for cond1\n"); + pthread_mutex_lock(&test_lock); + pthread_cond_wait(&cond1, &test_lock ); + pthread_mutex_unlock(&test_lock); + printf("Thread 1 done.\n"); + return 0; +} + +static void * +thread2_func(void* arg) +{ + printf("Thread 2 (arg=%d tid=%d) entered.\n", (unsigned)arg, gettid()); + printf("2 waiting for cond2\n"); + pthread_mutex_lock(&test_lock); + pthread_cond_wait(&cond2, &test_lock ); + pthread_mutex_unlock(&test_lock); + + printf("Thread 2 done.\n"); + return 0; +} + +static void * +thread3_func(void* arg) +{ + printf("Thread 3 (arg=%d tid=%d) entered.\n", (unsigned)arg, gettid()); + printf("3 waiting for cond1\n"); + pthread_mutex_lock(&test_lock); + pthread_cond_wait(&cond1, &test_lock ); + pthread_mutex_unlock(&test_lock); + printf("3 Sleeping\n"); + sleep(2); + printf("3 signal cond2\n"); + pthread_cond_signal(&cond2); + + printf("Thread 3 done.\n"); + return 0; +} + +static void * +thread4_func(void* arg) +{ + printf("Thread 4 (arg=%d tid=%d) entered.\n", (unsigned)arg, gettid()); + printf("4 Sleeping\n"); + sleep(5); + + printf("4 broadcast cond1\n"); + pthread_cond_broadcast(&cond1); + printf("Thread 4 done.\n"); + return 0; +} + +int main(int argc, const char *argv[]) +{ + pthread_t t[4]; + + pthread_cond_init(&cond1, NULL); + pthread_cond_init(&cond2, NULL); + pthread_create( &t[0], NULL, thread1_func, (void *)1 ); + pthread_create( &t[1], NULL, thread2_func, (void *)2 ); + pthread_create( &t[2], NULL, thread3_func, (void *)3 ); + pthread_create( &t[3], NULL, thread4_func, (void *)4 ); + + pthread_join(t[0], NULL); + pthread_join(t[1], NULL); + pthread_join(t[2], NULL); + pthread_join(t[3], NULL); + return 0; +} diff --git a/tests/bionic/libc/bionic/test_pthread_create.c b/tests/bionic/libc/bionic/test_pthread_create.c new file mode 100644 index 00000000..edac0ff1 --- /dev/null +++ b/tests/bionic/libc/bionic/test_pthread_create.c @@ -0,0 +1,30 @@ +#include +#include +#include + +static void * +thread1_func(void* arg) +{ + printf("Thread 1 (arg=%d tid=%d) entered.\n", (unsigned)arg, gettid()); + return 0; +} + +static void * +thread2_func(void* arg) +{ + printf("thread 2 (arg=%d tid=%d) entered.\n", (unsigned)arg, gettid()); + return 1; +} + + +int main( void ) +{ + pthread_t t1, t2; + + pthread_create( &t1, NULL, thread1_func, (void *)1 ); + + pthread_join(t1, NULL); + + printf("OK\n"); + return 0; +} diff --git a/tests/bionic/libc/common/test_gethostbyname.c b/tests/bionic/libc/common/test_gethostbyname.c new file mode 100644 index 00000000..1e932d60 --- /dev/null +++ b/tests/bionic/libc/common/test_gethostbyname.c @@ -0,0 +1,53 @@ +#include +#include +#include +#include +#include +#include + +int main( int argc, char** argv ) +{ + char* hostname = "localhost"; + struct hostent* hent; + int i, ret; + + if (argc > 1) + hostname = argv[1]; + + hent = gethostbyname(hostname); + if (hent == NULL) { + printf("gethostbyname(%s) returned NULL !!\n", hostname); + return 1; + } + printf( "gethostbyname(%s) returned:\n", hostname); + printf( " name: %s\n", hent->h_name ); + printf( " aliases:" ); + for (i = 0; hent->h_aliases[i] != NULL; i++) + printf( " %s", hent->h_aliases[i] ); + printf( "\n" ); + printf( " address type: " ); + switch (hent->h_addrtype) { + case AF_INET: printf( "AF_INET\n"); break; + case AF_INET6: printf( "AF_INET6\n"); break; + default: printf("UNKNOWN (%d)\n", hent->h_addrtype); + } + printf( " address: " ); + switch (hent->h_addrtype) { + case AF_INET: + { + const char* dot = ""; + for (i = 0; i < hent->h_length; i++) { + printf("%s%d", dot, ((unsigned char*)hent->h_addr)[i]); + dot = "."; + } + } + break; + + default: + for (i = 0; i < hent->h_length; i++) { + printf( "%02x", ((unsigned char*)hent->h_addr)[i] ); + } + } + printf("\n"); + return 0; +} diff --git a/tests/bionic/libc/common/test_gethostname.c b/tests/bionic/libc/common/test_gethostname.c new file mode 100644 index 00000000..b9dcbafc --- /dev/null +++ b/tests/bionic/libc/common/test_gethostname.c @@ -0,0 +1,20 @@ +#include +#include +#include +#include +#include + +int main( void ) +{ + char hostname[512]; + int ret; + + ret = gethostname(hostname, sizeof(hostname)); + if (ret < 0) { + printf("gethostname() returned error %d: %s\n", errno, strerror(errno)); + return 1; + } + + printf("gethostname() returned '%s'\n", hostname); + return 0; +} diff --git a/tests/bionic/libc/common/test_libgen.c b/tests/bionic/libc/common/test_libgen.c new file mode 100644 index 00000000..4a2c29e2 --- /dev/null +++ b/tests/bionic/libc/common/test_libgen.c @@ -0,0 +1,221 @@ +// test the basename, dirname, basename_r and dirname_r +#include +#include +#include +#include + +static int fail = 0; + +static void +test_basename(char* _input, const char* _expected, int _errno) +{ + char temp[256], *input = _input; + char* ret; +#if HOST + /* GLibc does modify the input string. bummer */ + if (_input) { + strcpy(temp, _input); + input = temp; + } +#endif + errno = 0; + ret = basename(input); + if (_expected == NULL) { + if (ret != NULL) { + fprintf(stderr, + "KO: basename(\"%s\") returned \"%s\", NULL expected)\n", + _input, ret); + fail += 1; + } else if (errno != _errno) { + fprintf(stderr, + "KO: basename(\"%s\") returned NULL with error: %d (%d expected)\n", + _input, errno, _errno); + fail += 1; + } else { + printf( "OK: basename(\"%s\") returned NULL with error %d\n", + _input, _errno ); + } + } else { + if (ret == NULL) { + fprintf(stderr, "KO: basename(\"%s\") returned NULL with error %d\n", + _input, errno); + fail += 1; + } + else if (strcmp(ret, _expected)) { + fprintf(stderr, "KO: basename(\"%s\") returned \"%s\", instead of \"%s\"\n", + _input, ret, _expected); + } + else { + printf( "OK: basename(\"%s\") returned \"%s\"\n", + _input, ret ); + } + } +} + + +#if !HOST +static void +test_basename_r(char* _input, const char* _expected_content, int _expected, char* _buff, size_t _bufflen, int _errno) +{ + int ret; + errno = 0; + ret = basename_r(_input, _buff, _bufflen ); + if (ret != _expected) { + fprintf(stderr, + "KO: basename_r(\"%s\", , %d) returned %d (expected %d)\n", + _input, _bufflen, ret, _expected); + fail += 1; + return; + } + if (ret == -1) { + if (errno != _errno) { + fprintf(stderr, + "KO: basename_r(\"%s\", , %d) returned -1 with errno=%d (expected %d)\n", + _input, _bufflen, errno, _errno); + fail += 1; + return; + } + } + else if ( memcmp( _buff, _expected_content, ret ) ) { + fprintf(stderr, + "KO: basename_r(\"%s\", , %d) returned \"%s\", expected \"%s\"\n", + _input, _bufflen, _buff, _expected_content ); + fail += 1; + return; + } + printf("OK: basename_r(\"%s\", , %d) returned \"%s\"\n", + _input, _bufflen, _expected_content ); +} + +static void +test_dirname_r(char* _input, const char* _expected_content, int _expected, char* _buff, size_t _bufflen, int _errno) +{ + int ret; + errno = 0; + ret = dirname_r(_input, _buff, _bufflen ); + if (ret != _expected) { + fprintf(stderr, + "KO: dirname_r(\"%s\", , %d) returned %d (expected %d)\n", + _input, _bufflen, ret, _expected); + fail += 1; + return; + } + if (ret == -1) { + if (errno != _errno) { + fprintf(stderr, + "KO: dirname_r(\"%s\", , %d) returned -1 with errno=%d (expected %d)\n", + _input, _bufflen, errno, _errno); + fail += 1; + return; + } + } + else if ( memcmp( _buff, _expected_content, ret ) ) { + fprintf(stderr, + "KO: dirname_r(\"%s\", , %d) returned \"%s\", expected \"%s\"\n", + _input, _bufflen, _buff, _expected_content ); + fail += 1; + return; + } + printf("OK: dirname_r(\"%s\", , %d) returned \"%s\"\n", + _input, _bufflen, _expected_content ); +} +#endif + + +static void +test_dirname(char* _input, const char* _expected, int _errno) +{ + char temp[256], *input = _input; + char* ret; +#if HOST + /* GLibc does modify the input string. bummer */ + if (_input) { + strcpy(temp, _input); + input = temp; + } +#endif + errno = 0; + ret = dirname(input); + if (_expected == NULL) { + if (ret != NULL) { + fprintf(stderr, + "KO: dirname(\"%s\") returned \"%s\", NULL expected)\n", + _input, ret); + fail += 1; + } else if (errno != _errno) { + fprintf(stderr, + "KO: dirname(\"%s\") returned NULL with error: %d (%d expected)\n", + _input, errno, _errno); + fail += 1; + } else { + printf( "OK: dirname(\"%s\") returned NULL with error %d\n", + _input, _errno ); + } + } else { + if (ret == NULL) { + fprintf(stderr, "KO: dirname(\"%s\") returned NULL with error %d\n", + _input, errno); + fail += 1; + } + else if (strcmp(ret, _expected)) { + fprintf(stderr, "KO: dirname(\"%s\") returned \"%s\", instead of \"%s\"\n", + _input, ret, _expected); + } + else { + printf( "OK: dirname(\"%s\") returned \"%s\"\n", + _input, ret ); + } + } +} + + + + +int main( void ) +{ + char buff[256]; + + test_basename( "", ".", 0 ); + test_basename( "/usr/lib", "lib", 0 ); + test_basename( "/usr/", "usr", 0 ); + test_basename( "usr", "usr", 0 ); + test_basename( "/", "/", 0 ); + test_basename( ".", ".", 0 ); + test_basename( "..", "..", 0 ); + +#if !HOST + test_basename_r( "", ".", 1, NULL, 0, 0 ); + test_basename_r( "", ".", -1, buff, 0, ERANGE ); + test_basename_r( "", ".", -1, buff, 1, ERANGE ); + test_basename_r( "", ".", 1, buff, 2, 0 ); + test_basename_r( "", ".", 1, buff, sizeof(buff), 0 ); + test_basename_r( "/usr/lib", "lib", 3, buff, sizeof(buff), 0 ); + test_basename_r( "/usr/", "usr", 3, buff, sizeof(buff), 0 ); + test_basename_r( "usr", "usr", 3, buff, sizeof(buff), 0 ); + test_basename_r( "/", "/", 1, buff, sizeof(buff), 0 ); + test_basename_r( ".", ".", 1, buff, sizeof(buff), 0 ); + test_basename_r( "..", "..", 2, buff, sizeof(buff), 0 ); +#endif + + test_dirname( "", ".", 0 ); + test_dirname( "/usr/lib", "/usr", 0 ); + test_dirname( "/usr/", "/", 0 ); + test_dirname( "usr", ".", 0 ); + test_dirname( ".", ".", 0 ); + test_dirname( "..", ".", 0 ); + +#if !HOST + test_dirname_r( "", ".", 1, NULL, 0, 0 ); + test_dirname_r( "", ".", -1, buff, 0, ERANGE ); + test_dirname_r( "", ".", -1, buff, 1, ERANGE ); + test_dirname_r( "", ".", 1, buff, 2, 0 ); + test_dirname_r( "/usr/lib", "/usr", 4, buff, sizeof(buff), 0 ); + test_dirname_r( "/usr/", "/", 1, buff, sizeof(buff), 0 ); + test_dirname_r( "usr", ".", 1, buff, sizeof(buff), 0 ); + test_dirname_r( ".", ".", 1, buff, sizeof(buff), 0 ); + test_dirname_r( "..", ".", 1, buff, sizeof(buff), 0 ); +#endif + + return (fail > 0); +} + diff --git a/tests/bionic/libc/common/test_pthread_cleanup_push.c b/tests/bionic/libc/common/test_pthread_cleanup_push.c new file mode 100644 index 00000000..87634adf --- /dev/null +++ b/tests/bionic/libc/common/test_pthread_cleanup_push.c @@ -0,0 +1,134 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include +#include +#include + + +#define MAGIC1 0xcafebabeU +#define MAGIC2 0x8badf00dU +#define MAGIC3 0x12345667U + +static int g_ok1 = 0; +static int g_ok2 = 0; +static int g_ok3 = 0; + +static void +cleanup1( void* arg ) +{ + if ((unsigned)arg != MAGIC1) + g_ok1 = -1; + else + g_ok1 = +1; +} + +static void +cleanup2( void* arg ) +{ + if ((unsigned)arg != MAGIC2) { + g_ok2 = -1; + } else + g_ok2 = +1; +} + +static void +cleanup3( void* arg ) +{ + if ((unsigned)arg != MAGIC3) + g_ok3 = -1; + else + g_ok3 = +1; +} + + +static void* +thread1_func( void* arg ) +{ + pthread_cleanup_push( cleanup1, (void*)MAGIC1 ); + pthread_cleanup_push( cleanup2, (void*)MAGIC2 ); + pthread_cleanup_push( cleanup3, (void*)MAGIC3 ); + + if (arg != NULL) + pthread_exit(0); + + pthread_cleanup_pop(0); + pthread_cleanup_pop(1); + pthread_cleanup_pop(1); + + return NULL; +} + +static int test( int do_exit ) +{ + pthread_t t; + + pthread_create( &t, NULL, thread1_func, (void*)do_exit ); + pthread_join( t, NULL ); + + if (g_ok1 != +1) { + if (g_ok1 == 0) { + fprintf(stderr, "cleanup1 not called !!\n"); + } else { + fprintf(stderr, "cleanup1 called with wrong argument\n" ); + } + exit(1); + } + else if (g_ok2 != +1) { + if (g_ok2 == 0) + fprintf(stderr, "cleanup2 not called !!\n"); + else + fprintf(stderr, "cleanup2 called with wrong argument\n"); + exit(2); + } + else if (do_exit && g_ok3 != +1) { + if (g_ok3 == 0) { + fprintf(stderr, "cleanup3 not called !!\n"); + } else { + fprintf(stderr, "cleanup3 called with bad argument !!\n"); + } + exit(3); + } + else if (!do_exit && g_ok3 != 0) { + if (g_ok3 == 1) { + fprintf(stderr, "cleanup3 wrongly called !!\n"); + } else { + fprintf(stderr, "cleanup3 wrongly called with bad argument !!\n"); + } + exit(3); + } + + return 0; +} + +int main( void ) +{ + test(0); + test(1); + printf("OK\n"); + return 0; +} diff --git a/tests/bionic/libc/common/test_pthread_getcpuclockid.c b/tests/bionic/libc/common/test_pthread_getcpuclockid.c new file mode 100644 index 00000000..2a828088 --- /dev/null +++ b/tests/bionic/libc/common/test_pthread_getcpuclockid.c @@ -0,0 +1,86 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +/* this is a small test for pthread_getcpuclockid() and clock_gettime() */ + +#include +#include +#include +#include +#include + +static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; + +static void* +thread_func( void* arg ) +{ + pthread_t self = pthread_self(); + struct timespec ts; + clockid_t clock; + int e; + + pthread_mutex_lock( &lock ); + + e = pthread_getcpuclockid( self, &clock ); + if (e != 0) { + fprintf(stderr, "pthread_getcpuclockid(%08lx,) returned error %d: %s\n", self, e, strerror(e)); + pthread_mutex_unlock( &lock ); + return NULL; + } + + ts.tv_sec = 0; + ts.tv_nsec = 300000000 + ((int)arg)*50000000; + nanosleep( &ts, &ts ); + + clock_gettime( clock, &ts ); + fprintf(stderr, "thread %08lx: clock_gettime() returned %g nsecs\n", self, ts.tv_sec*1e9 + ts.tv_nsec); + + pthread_mutex_unlock( &lock ); + + return NULL; +} + +#define MAX_THREADS 16 + +int main( void ) +{ + int nn; + pthread_attr_t attr; + pthread_t threads[MAX_THREADS]; + + pthread_attr_init(&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); + + for (nn = 0; nn < MAX_THREADS; nn++) { + pthread_create( &threads[nn], &attr, thread_func, (void*)nn ); + } + for (nn = 0; nn < MAX_THREADS; nn++) { + void* dummy; + pthread_join( threads[nn], &dummy ); + } + return 0; +} diff --git a/tests/bionic/libc/common/test_pthread_join.c b/tests/bionic/libc/common/test_pthread_join.c new file mode 100644 index 00000000..4fe2561a --- /dev/null +++ b/tests/bionic/libc/common/test_pthread_join.c @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include +#include +#include + +static void* +thread1_func(void* arg) +{ + usleep( 2000*1000 ); + printf("thread 1 exited\n"); + return (void*) 0x8badf00d; +} + +static void* +thread2_func(void* arg) +{ + pthread_t t1 = (pthread_t)arg; + void* result; + + pthread_join(t1, &result); + printf("thread2 received code %08x from thread1\n", (int)result); + return NULL; +} + + +static void* +thread3_func(void* arg) +{ + pthread_t t1 = (pthread_t)arg; + void* result; + + pthread_join(t1, &result); + printf("thread3 received code %08x from thread1\n", (int)result); + return NULL; +} + +int main( void ) +{ + pthread_t t1, t2, t3; + + pthread_create( &t1, NULL, thread1_func, NULL ); + pthread_create( &t2, NULL, thread2_func, (void*)t1 ); + pthread_create( &t3, NULL, thread3_func, (void*)t1 ); + + pthread_join(t2, NULL); + pthread_join(t3, NULL); + + printf("OK\n"); + return 0; +} diff --git a/tests/bionic/libc/common/test_pthread_once.c b/tests/bionic/libc/common/test_pthread_once.c new file mode 100644 index 00000000..3beda913 --- /dev/null +++ b/tests/bionic/libc/common/test_pthread_once.c @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include +#include +#include +#include + +#define N_THREADS 100 + +static pthread_once_t once = PTHREAD_ONCE_INIT; + +static int global_count = 0; + +static void +once_function( void ) +{ + struct timespec ts; + + global_count += 1; + + ts.tv_sec = 2; + ts.tv_nsec = 0; + nanosleep (&ts, NULL); +} + +static void* +thread_function(void* arg) +{ + pthread_once( &once, once_function ); + + if (global_count != 1) { + printf ("thread %ld: global == %d\n", (long int) arg, global_count); + exit (1); + } + return NULL; +} + +int main( void ) +{ + pthread_t threads[N_THREADS]; + int nn; + + for (nn = 0; nn < N_THREADS; nn++) { + if (pthread_create( &threads[nn], NULL, thread_function, (void*)(long int)nn) < 0) { + printf("creation of thread %d failed\n", nn); + return 1; + } + } + + for (nn = 0; nn < N_THREADS; nn++) { + if (pthread_join(threads[nn], NULL)) { + printf("joining thread %d failed\n", nn); + return 1; + } + } + return 0; +} diff --git a/tests/bionic/libc/common/test_semaphore.c b/tests/bionic/libc/common/test_semaphore.c new file mode 100644 index 00000000..6792d861 --- /dev/null +++ b/tests/bionic/libc/common/test_semaphore.c @@ -0,0 +1,129 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include +#include +#include +#include +#include +#include +#include + +/* a simple semaphore test, using three threads + * + * a semaphore is initialized with a value of 1 + * + * Thread 1, 2 and 3 start at the same time + * + * Thread 1 takes the semaphore, then sleeps for 2 seconds, then post the semaphore + * Thread 2 sleeps for 1 second, then waits the semaphore, sleeps for 2 seconds, then post the semaphoe + * Thread 3 sleeps 3 seconds, waits for the semaphore + */ + +static sem_t semaphore; + +static void* +_thread1( void* unused ) +{ + printf( "thread 1: waiting for semaphore\n" ); + if ( sem_wait( &semaphore ) < 0 ) { + printf( "thread 1: could not wait for semaphore: %s\n", strerror(errno) ); + return NULL; + } + printf( "thread 1: got the semaphore ! sleeping for 2 seconds\n" ); + sleep( 2 ); + printf( "thread 1: awake !! posting semaphore\n" ); + if ( sem_post( &semaphore ) < 0 ) { + printf( "thread 2: could not post semaphore: %s\n", strerror(errno) ); + } + printf( "thread 1: quitting\n" ); + return NULL; +} + +static void* +_thread2( void* unused ) +{ + printf( "thread 2: sleeping for 1 second\n" ); + sleep(1); + printf( "thread 2: awake !! waiting for semaphore\n" ); + if ( sem_wait( &semaphore ) < 0 ) { + printf( "thread 2: could not wait for semaphore: %s\n", strerror(errno) ); + return NULL; + } + printf( "thread 2: got the semaphore ! sleeping for 2 seconds\n" ); + sleep( 2 ); + printf( "thread 2: awake !! posting semaphore\n" ); + if ( sem_post( &semaphore ) < 0 ) { + printf( "thread 2: could not post semaphore: %s\n", strerror(errno) ); + } + printf( "thread 2: quitting\n" ); + return NULL; +} + + +static void* +_thread3( void* unused ) +{ + printf( "thread 3: sleeping for 3 seconds\n" ); + sleep(3); + printf( "thread 3: awake !! waiting for semaphore\n" ); + if ( sem_wait( &semaphore ) < 0 ) { + printf( "thread 3: could not wait for semaphore: %s\n", strerror(errno) ); + return NULL; + } + printf( "thread 3: got semaphore. quitting\n" ); + return NULL; +} + +typedef void* (*thread_func)(void*); + +static const thread_func thread_routines[] = +{ + &_thread1, + &_thread2, + &_thread3 +}; + +int main( void ) +{ + pthread_t t[3]; + int nn; + + if ( sem_init( &semaphore, 0, 1 ) < 0 ) { + printf( "could not initialize semaphore: %s\n", strerror(errno) ); + return -1; + } + + for ( nn = 0; nn < 3; nn++ ) { + if ( pthread_create( &t[nn], NULL, thread_routines[nn], NULL ) < 0 ) { + printf("could not create thread %d: %s\n", nn+1, strerror(errno) ); + return -2; + } + } + sleep( 5 ); + return 0; +} diff --git a/tests/bionic/libc/common/test_seteuid.c b/tests/bionic/libc/common/test_seteuid.c new file mode 100644 index 00000000..ac330cec --- /dev/null +++ b/tests/bionic/libc/common/test_seteuid.c @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include +#include +#include + +int main( void ) +{ + uid_t ruid, euid; + + printf( "sizeof(uid_t) = %d sizeof(gid_t) = %d\n", sizeof(uid_t), sizeof(gid_t) ); + + ruid = getuid(); + euid = geteuid(); + printf("Start: ruid=%d euid=%d\n", ruid, euid); + + if (seteuid(9999) != 0) + perror("seteuid(9999)"); + + ruid = getuid(); + euid = geteuid(); + printf("After set: ruid=%d euid=%d\n", ruid, euid); + + if (seteuid(0) != 0) + perror("seteuid(0)"); + + ruid = getuid(); + euid = geteuid(); + printf("After restore: ruid=%d euid=%d\n", ruid, euid); + + return 0; +} diff --git a/tests/bionic/libc/common/test_static_cpp_mutex.cpp b/tests/bionic/libc/common/test_static_cpp_mutex.cpp new file mode 100644 index 00000000..33a56ef4 --- /dev/null +++ b/tests/bionic/libc/common/test_static_cpp_mutex.cpp @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +/* this program is used to test the locking of a recursive mutex in a static C++ constructor + * this operation crashes on some + */ +#include +#include + +class Foo { +private: + pthread_mutex_t mMutex; +public: + virtual int getValue(); + Foo(); +}; + +Foo::Foo() +{ + pthread_mutexattr_t mattr; + + pthread_mutexattr_init(&mattr); + pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&mMutex, &mattr); + pthread_mutex_lock(&mMutex); + fprintf(stderr, "recursive lock initialized and locked\n" ); +} + +int Foo::getValue() +{ + return 0; +} + +static Foo f; + +int main(void) +{ + printf( "f.getValue() returned: %d\n", f.getValue() ); + return 0; +} diff --git a/tests/bionic/libc/common/test_tm_zone.c b/tests/bionic/libc/common/test_tm_zone.c new file mode 100644 index 00000000..63e06353 --- /dev/null +++ b/tests/bionic/libc/common/test_tm_zone.c @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +/* a small program to test the tm_zone setting in Bionic */ +#include +#include +#include + +int main( void ) +{ +#ifndef TM_ZONE + fprintf(stderr, "TM_ZONE is not defined in !!\n" ); + return 1; +#else + const char* tz = getenv("TZ"); + time_t now = time(NULL); + struct tm tm0; + struct tm* tm; + + if (tz) { + printf( "TZ set to '%s'\n", tz ); + } else + printf( "TZ is not defined\n" ); + + tm = localtime_r( &now, &tm0 ); + printf( "localtime_r() returns timezone abbreviation '%s'\n", tm->TM_ZONE ? tm->TM_ZONE : "" ); + printf( "tzname[0] is '%s'\n", tzname[0] ? tzname[0] : "" ); + printf( "tzname[1] is '%s'\n", tzname[1] ? tzname[1] : "" ); +#endif + return 0; +} diff --git a/tests/bionic/libc/common/test_udp.c b/tests/bionic/libc/common/test_udp.c new file mode 100644 index 00000000..3c9dd079 --- /dev/null +++ b/tests/bionic/libc/common/test_udp.c @@ -0,0 +1,121 @@ +/* this program is used to test UDP networking in Android. + * used to debug the emulator's networking implementation + */ +#define PROGNAME "test_udp" +#define DEFAULT_PORT 7000 + +#include +#include +#include +#include +#include +#include +#include +#include + +#define BUFLEN 512 +#define NPACK 10 + +void diep(char *s) +{ + perror(s); + exit(1); +} + +static void +usage(int code) +{ + printf("usage: %s [options]\n", PROGNAME); + printf("options:\n"); + printf(" -p use specific port (default %d)\n", DEFAULT_PORT); + printf(" -a use specific IP address\n"); + printf(" -s run server (default is client)\n"); + exit(code); +} + +int main(int argc, char** argv) +{ + int runServer = 0; + int udpPort = DEFAULT_PORT; + int useLocal = 0; + int address = htonl(INADDR_ANY); + + struct sockaddr_in si_me, si_other; + int s, i, slen=sizeof(si_other); + char buf[BUFLEN]; + + while (argc > 1 && argv[1][0] == '-') { + const char* optName = argv[1]+1; + argc--; + argv++; + + switch (optName[0]) { + case 'p': + udpPort = atoi(optName+1); + if (udpPort < 1024 || udpPort > 65535) { + fprintf(stderr, "UDP port must be between 1024 and 65535\n"); + exit(1); + } + break; + + case 's': + runServer = 1; + break; + + case 'a': + if (inet_aton(optName+1, &si_other.sin_addr) == 0) + diep("inet_aton"); + address = si_other.sin_addr.s_addr; + break; + + default: + usage(1); + } + } + + if (runServer) { + if ((s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1) + diep("socket"); + + memset((char *) &si_me, 0, sizeof(si_me)); + si_me.sin_family = AF_INET; + si_me.sin_port = htons(udpPort); + si_me.sin_addr.s_addr = address; + if (bind(s, (struct sockaddr*)&si_me, sizeof(si_me))==-1) + diep("bind"); + + printf("UDP server listening on %s:%d\n", inet_ntoa(si_me.sin_addr), udpPort); + for (i=0; i +#include +#include +#include +#include + +jmp_buf rec; +char buf[160]; + +static void +sigabrt (int unused) +{ + longjmp (rec, 1); /* recover control */ +} + +#undef NDEBUG +#include +static void +assert1 (void) +{ + assert (1 == 2); +} + +static void +assert2 (void) +{ + assert (1 == 1); +} + + +#define NDEBUG +#include +static void +assert3 (void) +{ + assert (2 == 3); +} + +int +main (void) +{ + + volatile int failed = 1; + + fclose (stderr); + stderr = tmpfile (); + if(!stderr) + abort (); + + signal (SIGABRT, sigabrt); + + if (!setjmp (rec)) + assert1 (); + else + failed = 0; /* should happen */ + + if (!setjmp (rec)) + assert2 (); + else + failed = 1; /* should not happen */ + + if (!setjmp (rec)) + assert3 (); + else + failed = 1; /* should not happen */ + + rewind (stderr); + fgets (buf, 160, stderr); + if (!strstr (buf, "1 == 2")) + failed = 1; + + fgets (buf, 160, stderr); + if (strstr (buf, "1 == 1")) + failed = 1; + + fgets (buf, 160, stderr); + if (strstr (buf, "2 == 3")) + failed = 1; + + return failed; +} diff --git a/tests/bionic/libc/other/bench_locks.c b/tests/bionic/libc/other/bench_locks.c new file mode 100644 index 00000000..87b1c4c1 --- /dev/null +++ b/tests/bionic/libc/other/bench_locks.c @@ -0,0 +1,32 @@ +/* a small program to benchmark locking primitives with different implementations */ + +#include +#include +#include + +static double now(void) +{ + struct timeval tv; + gettimeofday(&tv, NULL); + return tv.tv_sec + tv.tv_usec/1000000.0; +} + +int main( void ) +{ + double t0, t1; + pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER; + int volatile lock2 = 0; + long count; + const long ITERATIONS = 1000000; + + /* pthread_mutex_lock */ + t0 = now(); + for (count = ITERATIONS; count > 0; count--) { + pthread_mutex_lock(&lock1); + pthread_mutex_unlock(&lock1); + } + t1 = now() - t0; + printf( "pthread_mutex_lock/unlock: %.5g us/op\n", (t1*1000000.0)/ITERATIONS ); + + return 0; +} diff --git a/tests/bionic/libc/other/test_aligned.c b/tests/bionic/libc/other/test_aligned.c new file mode 100644 index 00000000..8a66dd65 --- /dev/null +++ b/tests/bionic/libc/other/test_aligned.c @@ -0,0 +1,117 @@ +#include +#include /* for htons() etc.. */ + +static char tab[8]; + +static void +read4( int o, unsigned val ) +{ + unsigned v = htonl(val); + unsigned v2; + + tab[o+0] = (char)(v >> 24); + tab[o+1] = (char)(v >> 16); + tab[o+2] = (char)(v >> 8); + tab[o+3] = (char)(v); + + printf( "read4: offset=%d value=%08x: ", o, val ); + fflush(stdout); + + v2 = *(unsigned*)(tab+o); + + if (v2 != val) { + printf( "FAIL (%08x)\n", v2 ); + } else { + printf( "ok\n" ); + } +} + +static void +writ4( int o, unsigned val ) +{ + unsigned v = htonl(val); + unsigned v2; + + printf( "writ4: offset=%d value=%08x: ", o, val ); + fflush(stdout); + + *(unsigned*)(tab+o) = v; + + v2 = ((unsigned)tab[o+0] << 24) | + ((unsigned)tab[o+1] << 16) | + ((unsigned)tab[o+2] << 8 ) | + ((unsigned)tab[o+3] ); + + if (v2 != val) { + printf( "FAIL (%08x)\n", v2 ); + } else { + printf( "ok\n" ); + } +} + +static void +read2( int o, unsigned val ) +{ + unsigned short v = htons(val); + unsigned short v2; + + tab[o+0] = (char)(v >> 8); + tab[o+1] = (char)(v); + + printf( "read2: offset=%d value=%08x: ", o, val ); + fflush(stdout); + + v2 = *(unsigned short*)(tab+o); + + if (v2 != val) { + printf( "FAIL (%04x)\n", v2 ); + } else { + printf( "ok\n" ); + } +} + +static void +writ2( int o, unsigned val ) +{ + unsigned short v = htons(val); + unsigned short v2; + + printf( "writ2: offset=%d value=%08x: ", o, val ); + fflush(stdout); + + *(unsigned short*)(tab+o) = v; + + v2 = ((unsigned)tab[o+0] << 8) | + ((unsigned)tab[o+1] ); + + if (v2 != val) { + printf( "FAIL (%08x)\n", v2 ); + } else { + printf( "ok\n" ); + } +} + + + +int main(void) +{ + read4( 0, 0x12345678 ); + writ4( 0, 0x12345678 ); + read4( 1, 0x12345678 ); + writ4( 1, 0x12345678 ); + read4( 2, 0x12345678 ); + writ4( 2, 0x12345678 ); + read4( 3, 0x12345678 ); + writ4( 3, 0x12345678 ); + + read2( 0, 0x1234 ); + writ2( 0, 0x1234 ); + read2( 1, 0x1234 ); + writ2( 1, 0x1234 ); + read2( 2, 0x1234 ); + writ2( 2, 0x1234 ); + read2( 3, 0x1234 ); + writ2( 3, 0x1234 ); + + return 0; +} diff --git a/tests/bionic/libc/other/test_arc4random.c b/tests/bionic/libc/other/test_arc4random.c new file mode 100644 index 00000000..4829a2d6 --- /dev/null +++ b/tests/bionic/libc/other/test_arc4random.c @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include + +int main(int argc, char *argv[]) +{ + unsigned int arc4random(); + + int i; + + for (i = 0; i < 50; i++) { + printf("%u\n", arc4random()); + } + return 0; +} diff --git a/tests/bionic/libc/other/test_atomics.c b/tests/bionic/libc/other/test_atomics.c new file mode 100644 index 00000000..0de2a938 --- /dev/null +++ b/tests/bionic/libc/other/test_atomics.c @@ -0,0 +1,17 @@ +#include + + +extern int __atomic_dec(volatile int* addr); + +int main(int argc, const char *argv[]) +{ + int x = 5; + + while (x > -20) { + printf("old_x=%d\n", __atomic_dec(&x)); + printf("x=%d\n", x); + } + + printf ("OK\n"); + return 0; +} diff --git a/tests/bionic/libc/other/test_jpeg.c b/tests/bionic/libc/other/test_jpeg.c new file mode 100644 index 00000000..8d7ef1a7 --- /dev/null +++ b/tests/bionic/libc/other/test_jpeg.c @@ -0,0 +1,362 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +/* this small program is used to measure the performance of libjpeg decompression + * algorithm... + */ + +#include +#include +#include +#include +#include +#include +#include +#include "jpeglib.h" +#include +#ifdef HAVE_ANDROID_OS +#include +#endif + +#define USE_STDIO + +#define CHUNK 32768 + +typedef struct { + struct jpeg_source_mgr jpeg_mgr; + char* base; + char* cursor; + char* end; +} SourceMgrRec, *SourceMgr; + +static void +_source_init_source(j_decompress_ptr cinfo) +{ + SourceMgr src = (SourceMgr) cinfo->src; + + src->jpeg_mgr.next_input_byte = (unsigned char*)src->base, + src->jpeg_mgr.bytes_in_buffer = src->end - src->base; +} + +static int +_source_fill_input_buffer(j_decompress_ptr cinfo) +{ + SourceMgr src = (SourceMgr) cinfo->src; + + cinfo->err->error_exit((j_common_ptr)cinfo); + return FALSE; +} + +static void +_source_skip_input_data(j_decompress_ptr cinfo, long num_bytes) +{ + SourceMgr src = (SourceMgr) cinfo->src; + + if (src->jpeg_mgr.next_input_byte + num_bytes > (unsigned char*)src->end ) { + cinfo->err->error_exit((j_common_ptr)cinfo); + } + + src->jpeg_mgr.next_input_byte += num_bytes; + src->jpeg_mgr.bytes_in_buffer -= num_bytes; +} + +static int +_source_resync_to_restart( j_decompress_ptr cinfo, int desired) +{ + SourceMgr src = (SourceMgr) cinfo->src; + + src->jpeg_mgr.next_input_byte = (unsigned char*)src->base; + src->jpeg_mgr.bytes_in_buffer = src->end - src->base; + return TRUE; +} + +static void +_source_term_source(j_decompress_ptr cinfo) +{ + // nothing to do +} + +static void +_source_init( SourceMgr src, char* base, long size ) +{ + src->base = base; + src->cursor = base; + src->end = base + size; + + src->jpeg_mgr.init_source = _source_init_source; + src->jpeg_mgr.fill_input_buffer = _source_fill_input_buffer; + src->jpeg_mgr.skip_input_data = _source_skip_input_data; + src->jpeg_mgr.resync_to_restart = _source_resync_to_restart; + src->jpeg_mgr.term_source = _source_term_source; +} + + +typedef struct { + struct jpeg_error_mgr jpeg_mgr; + jmp_buf jumper; + int volatile error; + +} ErrorMgrRec, *ErrorMgr; + +static void _error_exit(j_common_ptr cinfo) +{ + ErrorMgr error = (ErrorMgr) cinfo->err; + + (*error->jpeg_mgr.output_message) (cinfo); + + /* Let the memory manager delete any temp files before we die */ + longjmp(error->jumper, -1); +} + +#ifdef USE_STDIO +int decompress(FILE* input_file, int dct_method, int disable_rgb) +#else +int decompress(char* data, long fsize) +#endif +{ + ErrorMgrRec errmgr; + SourceMgrRec sourcemgr; + struct jpeg_decompress_struct cinfo; + int volatile error = 0; + jmp_buf jumper; + int isRGB; + char* pixels; + JSAMPLE* temprow; + + memset( &cinfo, 0, sizeof(cinfo) ); + memset( &errmgr, 0, sizeof(errmgr) ); + jpeg_create_decompress(&cinfo); + cinfo.err = jpeg_std_error(&errmgr.jpeg_mgr); +#if 0 + errmgr.jpeg_mgr.error_exit = _error_exit; + errmgr.error = 0; +#endif + + if (setjmp(errmgr.jumper) != 0) { + fprintf(stderr, "returning error from jpeglib ---\n" ); + goto Exit; + } + +#ifdef USE_STDIO + /* Specify data source for decompression */ + jpeg_stdio_src(&cinfo, input_file); +#else + _source_init( &sourcemgr, data, fsize ); + cinfo.src = &sourcemgr.jpeg_mgr; +#endif + + jpeg_read_header(&cinfo, 1); + + if (3 == cinfo.num_components && JCS_RGB == cinfo.out_color_space) + isRGB = 1; + else if (1 == cinfo.num_components && JCS_GRAYSCALE == cinfo.out_color_space) + isRGB = 0; // could use Index8 config if we want... + else { + fprintf( stderr, "unsupported jpeg colorspace %d with %d components\n", + cinfo.jpeg_color_space, cinfo.num_components ); + goto Exit; + } + + cinfo.dct_method = dct_method; + if (disable_rgb) + cinfo.out_color_space = JCS_YCbCr; + + jpeg_start_decompress(&cinfo); + + temprow = calloc( cinfo.num_components * cinfo.output_width, sizeof(JSAMPLE) ); + + { + unsigned y; + for (y = 0; y < cinfo.output_height; y++) { + JSAMPLE* rowptr = temprow; + (void)jpeg_read_scanlines(&cinfo, &rowptr, 1); + } + } + jpeg_finish_decompress(&cinfo); + + free( temprow ); +Exit: + jpeg_destroy_decompress(&cinfo); + return error; +} + + +#define DEFAULT_REPEAT 10 + +static void usage(void) +{ + fprintf(stderr, "usage: test_jpeg [options] filename.jpg [filename2.jpg ...]\n" ); + fprintf(stderr, "options: -r NN repeat count (default %d)\n", DEFAULT_REPEAT ); + fprintf(stderr, " -d N idct method (0=default, 1=fastest, 2=slow, 3=float)\n" ); + fprintf(stderr, " -C no RGB color conversion (YCbCr instead)\n" ); + exit(1); +} + +static double +get_time_usec( void ) +{ +#ifdef HAVE_ANDROID_OS + struct timespec ts; + + if ( clock_gettime( CLOCK_MONOTONIC, &ts ) < 0 ) + fprintf(stderr, "clock_gettime: %s\n", strerror(errno) ); + + return ts.tv_sec*1e6 + ts.tv_nsec*1e-3; +#else + struct timeval tv; + if (gettimeofday( &tv, NULL ) < 0) + fprintf(stderr, "gettimeofday: %s\n", strerror(errno) ); + + return tv.tv_sec*1000000. + tv.tv_usec*1.0; +#endif +} + + +int main( int argc, char** argv ) +{ + FILE* f; + int repeat_count = DEFAULT_REPEAT; + int dct_method = JDCT_DEFAULT; + int disable_rgb = 0; + double usec0, usec1; + + if (argc < 2) + usage(); + + for ( ; argc > 1 && argv[1][0] == '-'; argc--, argv++) { + const char* arg = &argv[1][1]; + switch (arg[0]) { + case 'r': + if (arg[1] == 0) { + if (argc < 3) + usage(); + arg = argv[2]; + argc--; + argv++; + } else + arg += 1; + + repeat_count = strtol(arg, NULL, 10); + + if (repeat_count <= 0) + repeat_count = 1; + break; + + case 'C': + disable_rgb = 1; + break; + + case 'd': + if (arg[1] == 0) { + if (argc < 3) + usage(); + arg = argv[2]; + argc--; + argv++; + } else + arg += 1; + + dct_method = strtol(arg, NULL, 10); + switch (dct_method) { + case 0: + dct_method = JDCT_DEFAULT; + break; + case 1: + dct_method = JDCT_IFAST; + break; + case 2: + dct_method = JDCT_ISLOW; + break; + case 3: + dct_method = JDCT_FLOAT; + break; + default: + usage(); + } + break; + + default: + usage(); + } + } + + for ( ; argc > 1; argc--, argv++ ) + { + long fsize; + char* data; + FILE* f = fopen( argv[1], "rb" ); + int rr; + + if (f == NULL) { + fprintf(stderr, "could not open '%s': %s\n", argv[1], strerror(errno) ); + continue; + } + + fseek( f, 0, SEEK_END ); + fsize = ftell(f); + fseek( f, 0, SEEK_SET ); + + usec0 = get_time_usec(); +#ifdef HAVE_ANDROID_OS + qemu_start_tracing(); +#endif +#ifdef USE_STDIO + for ( rr = repeat_count; rr > 0; rr-- ) { + fseek( f, 0, SEEK_SET ); + decompress(f, dct_method, disable_rgb); + } + fclose( f ); +#else + + data = malloc( fsize ); + if (data == NULL) { + if (fsize > 0) + fprintf(stderr, "could not allocate %ld bytes to load '%s'\n", fsize, argv[1] ); + fclose(f); + continue; + } + fread( data, 1, fsize, f ); + fclose(f); + + usec1 = get_time_usec() - usec0; + printf( "compressed load: %10.2f ms (%ld bytes)\n", usec1*1e-3, fsize ); + + usec0 = get_time_usec(); + for ( rr = repeat_count; rr > 0; rr -- ) + { + decompress( data, fsize ); + } + free( data ); +#endif +#ifdef HAVE_ANDROID_OS + qemu_stop_tracing(); +#endif + usec1 = get_time_usec() - usec0; + printf( "decompression took: %10.3f ms (%.2f KB/s, %d passes)\n", usec1/1e3, fsize*(1e6/1024)*repeat_count/usec1, repeat_count ); + } + return 0; +} diff --git a/tests/bionic/libc/other/test_sysconf.c b/tests/bionic/libc/other/test_sysconf.c new file mode 100644 index 00000000..717cbcb3 --- /dev/null +++ b/tests/bionic/libc/other/test_sysconf.c @@ -0,0 +1,137 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include +#include +#include +#include + +#define T(_name,_cond) \ + errno = 0; \ + printf( "testing %-*s : ", 32, #_name ); \ + ret = sysconf( _name ); \ + if (ret < 0 && errno != 0) { \ + printf( "error: %s\n", strerror(errno) ); \ + } else { \ + if ( ret _cond ) { \ + printf( "OK (%d)\n", ret ); \ + } else { \ + printf( "ERROR: %d does not meet %s\n", ret, #_cond ); \ + } \ + } + +int main( void ) +{ + int ret; + T(_SC_ARG_MAX, > 0); + T(_SC_BC_BASE_MAX, |1 ); + T(_SC_BC_DIM_MAX, |1 ); + T(_SC_BC_SCALE_MAX, |1 ); + T(_SC_BC_STRING_MAX, |1 ); + T(_SC_CHILD_MAX, >0 ); + T(_SC_CLK_TCK, >0 ); + T(_SC_COLL_WEIGHTS_MAX, |1 ); + T(_SC_EXPR_NEST_MAX, |1 ); + T(_SC_LINE_MAX, > 256 ); + T(_SC_NGROUPS_MAX, >0 ); + T(_SC_OPEN_MAX, >128 ); + T(_SC_PASS_MAX, |1 ); + T(_SC_2_C_BIND, >0 ); + T(_SC_2_C_DEV, |1 ); + T(_SC_2_C_VERSION, |1 ); + T(_SC_2_CHAR_TERM, |1 ); + T(_SC_2_FORT_DEV, |1 ); + T(_SC_2_FORT_RUN, |1 ); + T(_SC_2_LOCALEDEF, |1 ); + T(_SC_2_SW_DEV, |1 ); + T(_SC_2_UPE, |1 ); + T(_SC_2_VERSION, |1); + T(_SC_JOB_CONTROL, == 1); + T(_SC_SAVED_IDS, == 1); + T(_SC_VERSION, |1); + T(_SC_RE_DUP_MAX, |1); + T(_SC_STREAM_MAX, > 0); + T(_SC_TZNAME_MAX, |1 ); + T(_SC_XOPEN_CRYPT, |1 ); + T(_SC_XOPEN_ENH_I18N, |1 ); + T(_SC_XOPEN_SHM, |1 ); + T(_SC_XOPEN_VERSION, |1 ); + T(_SC_XOPEN_XCU_VERSION, |1 ); + T(_SC_XOPEN_REALTIME, |1 ); + T(_SC_XOPEN_REALTIME_THREADS, |1 ); + T(_SC_XOPEN_LEGACY, |1 ); + T(_SC_ATEXIT_MAX, >32 ); + T(_SC_IOV_MAX, >0 ); + T(_SC_PAGESIZE, == 4096 ); + T(_SC_PAGE_SIZE, == 4096 ); + T(_SC_XOPEN_UNIX, |1 ); + T(_SC_XBS5_ILP32_OFF32, |1 ); + T(_SC_XBS5_ILP32_OFFBIG, |1 ); + T(_SC_XBS5_LP64_OFF64, |1 ); + T(_SC_XBS5_LPBIG_OFFBIG, |1 ); + T(_SC_AIO_LISTIO_MAX, |1 ); + T(_SC_AIO_MAX, |1 ); + T(_SC_AIO_PRIO_DELTA_MAX, |1 ); + T(_SC_DELAYTIMER_MAX, >0 ); + T(_SC_MQ_OPEN_MAX, |1 ); + T(_SC_MQ_PRIO_MAX, >0 ); + T(_SC_RTSIG_MAX, |1 ); + T(_SC_SEM_NSEMS_MAX, |1 ); + T(_SC_SEM_VALUE_MAX, |1 ); + T(_SC_SIGQUEUE_MAX, >0 ); + T(_SC_TIMER_MAX, |1 ); + T(_SC_ASYNCHRONOUS_IO, |1 ); + T(_SC_FSYNC, |1 ); + T(_SC_MAPPED_FILES, |1 ); + T(_SC_MEMLOCK, |1 ); + T(_SC_MEMLOCK_RANGE, |1 ); + T(_SC_MEMORY_PROTECTION, |1 ); + T(_SC_MESSAGE_PASSING, |1 ); + T(_SC_PRIORITIZED_IO, |1 ); + T(_SC_PRIORITY_SCHEDULING, |1 ); + T(_SC_REALTIME_SIGNALS, |1 ); + T(_SC_SEMAPHORES, |1 ); + T(_SC_SHARED_MEMORY_OBJECTS, |1 ); + T(_SC_SYNCHRONIZED_IO, |1 ); + T(_SC_TIMERS, |1 ); + T(_SC_GETGR_R_SIZE_MAX, |1 ); + T(_SC_GETPW_R_SIZE_MAX, |1 ); + T(_SC_LOGIN_NAME_MAX, |1 ); + T(_SC_THREAD_DESTRUCTOR_ITERATIONS, |1 ); + T(_SC_THREAD_KEYS_MAX, > 0 ); + T(_SC_THREAD_STACK_MIN, >= 8192 ); + T(_SC_THREAD_THREADS_MAX, |1 ); + T(_SC_TTY_NAME_MAX, > 0 ); + T(_SC_THREADS, |1 ); + T(_SC_THREAD_ATTR_STACKADDR, |1 ); + T(_SC_THREAD_ATTR_STACKSIZE, |1 ); + T(_SC_THREAD_PRIORITY_SCHEDULING, |1 ); + T(_SC_THREAD_PRIO_INHERIT, |1 ); + T(_SC_THREAD_PRIO_PROTECT, |1 ); + T(_SC_THREAD_SAFE_FUNCTIONS, |1 ); + return 0; +} diff --git a/tests/bionic/libc/other/test_system.c b/tests/bionic/libc/other/test_system.c new file mode 100644 index 00000000..adb4c56a --- /dev/null +++ b/tests/bionic/libc/other/test_system.c @@ -0,0 +1,28 @@ +#include +#include +#include +#include + +int +main(int argc, char *argv[]) +{ + int rv; + + if (argc < 2) + return -1; + + rv = system(argv[1]); + if (rv < 0) { + fprintf(stderr, "Error calling system(): %d\n", errno); + return 1; + } + + printf("Done!\n"); + + if (WEXITSTATUS(rv) != 0) { + fprintf(stderr, "Command returned non-zero exit code: %d\n", + WEXITSTATUS(rv)); + return 1; + } + return 0; +} diff --git a/tests/bionic/libc/other/test_thread_max.c b/tests/bionic/libc/other/test_thread_max.c new file mode 100644 index 00000000..7aeb5c5a --- /dev/null +++ b/tests/bionic/libc/other/test_thread_max.c @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include +#include +#include +#include + +static void* +thread_func( void* arg ) +{ + fprintf(stderr, "thread %ld\n", (long)arg ); + return NULL; +} + +int main( void ) +{ + int count; + pthread_attr_t attr; + + pthread_attr_init(&attr); + pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_DETACHED ); + pthread_attr_setstacksize( &attr, 16*4096 ); + + for ( count = 0; count != ~0; count++ ) { + pthread_t thread; + struct timespec ts; + + if (pthread_create( &thread, &attr, thread_func, (void*)(long)count ) < 0) { + fprintf(stderr, "could not create thread %d\n", count); + break; + } + ts.tv_sec = 0; + ts.tv_nsec = 0.002*1e9; + nanosleep( &ts, &ts ); + } + sleep(1); + return 0; +} diff --git a/tests/bionic/libc/other/test_timer_create.c b/tests/bionic/libc/other/test_timer_create.c new file mode 100644 index 00000000..8995e121 --- /dev/null +++ b/tests/bionic/libc/other/test_timer_create.c @@ -0,0 +1,88 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +#include +#include +#include +#include +#include +#include + +void +handle(sigval_t v) +{ + time_t t; + char p[32]; + + time(&t); + strftime(p, sizeof(p), "%T", localtime(&t)); + printf("%s thread %d, val = %d, signal captured.\n", + p, (int)pthread_self(), v.sival_int); + return; +} + +int +create(int seconds, int id) +{ + timer_t tid; + struct sigevent se; + struct itimerspec ts, ots; + + memset(&se, 0, sizeof (se)); + se.sigev_notify = SIGEV_THREAD; + se.sigev_notify_function = handle; + se.sigev_value.sival_int = id; + + if (timer_create (CLOCK_REALTIME, &se, &tid) < 0) + { + perror ("timer_creat"); + return -1; + } + puts ("timer_create successfully."); + ts.it_value.tv_sec = 3; + ts.it_value.tv_nsec = 0; + ts.it_interval.tv_sec = seconds; + ts.it_interval.tv_nsec = 0; + if (timer_settime (tid, TIMER_ABSTIME, &ts, &ots) < 0) + { + perror ("timer_settime"); + return -1; + } + return 0; +} + +int +main (void) +{ + if (create (3, 1) < 0) return 1; + if (create (5, 2) < 0) return 1; + for (;;) + { + sleep (10); + } + return 0; +} diff --git a/tests/bionic/libc/other/test_vfprintf_leak.c b/tests/bionic/libc/other/test_vfprintf_leak.c new file mode 100644 index 00000000..4e94c51b --- /dev/null +++ b/tests/bionic/libc/other/test_vfprintf_leak.c @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +/* this test is used to check that a memory-leak in vfprintf was fixed. + * the initial code leaked heap memory each time a formatted double was printed + */ +#include + +extern size_t dlmalloc_footprint(); + +int main(void) +{ + size_t initial = dlmalloc_footprint(); + size_t final; + char temp[64]; + int n; + + for (n = 0; n < 10000; n++) + snprintf( temp, sizeof(temp), "%g", n*0.647287623 ); + + final = dlmalloc_footprint(); + /* vfprintf uses temporary heap blocks to do the formatting, so */ + /* it's OK to have one page in there */ + if (final <= 4096) { + printf( "OK: initial = %ld, final == %ld\n", (long)initial, (long)final ); + return 0; + } else { + fprintf(stderr, "KO: initial == %ld, final == %ld\n", (long)initial, (long)final ); + return 1; + } +} diff --git a/tests/bionic/libc/other/test_zlib.c b/tests/bionic/libc/other/test_zlib.c new file mode 100644 index 00000000..3eae8279 --- /dev/null +++ b/tests/bionic/libc/other/test_zlib.c @@ -0,0 +1,267 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +/* this small program is used to measure the performance of zlib's inflate + * algorithm... + */ + +/* most code lifted from the public-domain http://www.zlib.net/zpipe.c */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#define CHUNK 32768 + +int def(FILE *source, FILE *dest, int level) +{ + int ret, flush; + unsigned have; + z_stream strm; + unsigned char in[CHUNK]; + unsigned char out[CHUNK]; + + /* allocate deflate state */ + strm.zalloc = Z_NULL; + strm.zfree = Z_NULL; + strm.opaque = Z_NULL; + ret = deflateInit(&strm, level); + if (ret != Z_OK) + return ret; + + /* compress until end of file */ + do { + strm.avail_in = fread(in, 1, CHUNK, source); + if (ferror(source)) { + (void)deflateEnd(&strm); + return Z_ERRNO; + } + flush = feof(source) ? Z_FINISH : Z_NO_FLUSH; + strm.next_in = in; + + /* run deflate() on input until output buffer not full, finish + compression if all of source has been read in */ + do { + strm.avail_out = CHUNK; + strm.next_out = out; + ret = deflate(&strm, flush); /* no bad return value */ + have = CHUNK - strm.avail_out; + if (fwrite(out, 1, have, dest) != have || ferror(dest)) { + (void)deflateEnd(&strm); + return Z_ERRNO; + } + } while (strm.avail_out == 0); + + /* done when last data in file processed */ + } while (flush != Z_FINISH); + + /* clean up and return */ + (void)deflateEnd(&strm); + return Z_OK; +} + + +int inf(FILE *source) +{ + int ret; + unsigned have; + z_stream strm; + static unsigned char in[CHUNK]; + static unsigned char out[CHUNK]; + + /* allocate inflate state */ + strm.zalloc = Z_NULL; + strm.zfree = Z_NULL; + strm.opaque = Z_NULL; + strm.avail_in = 0; + strm.next_in = Z_NULL; + ret = inflateInit(&strm); + if (ret != Z_OK) + return ret; + + /* decompress until deflate stream ends or end of file */ + do { + strm.avail_in = fread(in, 1, CHUNK, source); + if (ferror(source)) { + (void)inflateEnd(&strm); + return Z_ERRNO; + } + if (strm.avail_in == 0) + break; + strm.next_in = in; + + /* run inflate() on input until output buffer not full */ + do { + strm.avail_out = CHUNK; + strm.next_out = out; + ret = inflate(&strm, Z_NO_FLUSH); + switch (ret) { + case Z_NEED_DICT: + ret = Z_DATA_ERROR; /* and fall through */ + case Z_DATA_ERROR: + case Z_MEM_ERROR: + (void)inflateEnd(&strm); + return ret; + } + } while (strm.avail_out == 0); + + /* done when inflate() says it's done */ + } while (ret != Z_STREAM_END); + + /* clean up and return */ + (void)inflateEnd(&strm); + return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR; +} + +#define DEFAULT_REPEAT 10 +#define DEFAULT_LEVEL 9 + +static void usage(void) +{ + fprintf(stderr, "usage: test_zlib [options] filename [filename2 ...]\n" ); + fprintf(stderr, "options: -r NN repeat count (default %d)\n", DEFAULT_REPEAT ); + fprintf(stderr, " -N set compression level (default %d)\n", DEFAULT_LEVEL ); + exit(1); +} + +static double +get_time_usec( void ) +{ +#ifdef HAVE_ANDROID_OS + struct timespec ts; + + if ( clock_gettime( CLOCK_MONOTONIC, &ts ) < 0 ) + fprintf(stderr, "clock_gettime: %s\n", strerror(errno) ); + + return ts.tv_sec*1e6 + ts.tv_nsec*1e-3; +#else + struct timeval tv; + if (gettimeofday( &tv, NULL ) < 0) + fprintf(stderr, "gettimeofday: %s\n", strerror(errno) ); + + return tv.tv_sec*1000000. + tv.tv_usec*1.0; +#endif +} + +int main( int argc, char** argv ) +{ + FILE* f; + char tempfile[256]; + int repeat_count = DEFAULT_REPEAT; + int compression_level = DEFAULT_LEVEL; + double usec0, usec1; + + if (argc < 2) + usage(); + + for ( ; argc > 1 && argv[1][0] == '-'; argc--, argv++) { + const char* arg = &argv[1][1]; + switch (arg[0]) { + case 'r': + if (arg[1] == 0) { + if (argc < 3) + usage(); + arg = argv[2]; + argc--; + argv++; + } else + arg += 1; + + repeat_count = strtol(arg, NULL, 10); + + if (repeat_count <= 0) + repeat_count = 1; + break; + + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + compression_level = arg[0] - '0'; + break; + + default: + usage(); + } + } + + sprintf(tempfile, "/tmp/ztest.%d", getpid() ); + + for ( ; argc > 1; argc--, argv++ ) + { + /* first, compress the file into a temporary storage */ + FILE* f = fopen(argv[1], "rb"); + FILE* out = NULL; + long fsize; + int ret, rr; + + if (f == NULL) { + fprintf(stderr, "could not open '%s': %s\n", argv[1], strerror(errno) ); + continue; + } + + printf( "testing %s\n", argv[1] ); + fseek( f, 0, SEEK_END ); + fsize = ftell(f); + fseek( f, 0, SEEK_SET ); + + out = fopen( tempfile, "wb" ); + if (out == NULL) { + fprintf(stderr, "could not create '%s': %s\n", tempfile, strerror(errno)); + fclose(f); + continue; + } + + usec0 = get_time_usec(); + + ret = def( f, out, compression_level ); + + usec1 = get_time_usec() - usec0; + printf( "compression took: %10.3f ms (%.2f KB/s)\n", usec1/1e3, fsize*(1e6/1024)/usec1 ); + + fclose( out ); + fclose(f); + + usec0 = get_time_usec(); + f = fopen( tempfile, "rb" ); + + for ( rr = repeat_count; rr > 0; rr -- ) + { + fseek( f, 0, SEEK_SET ); + inf(f); + } + fclose( f ); + usec1 = get_time_usec() - usec0; + printf( "decompression took: %10.3f ms (%.2f KB/s, %d passes)\n", usec1/1e3, fsize*(1e6/1024)*repeat_count/usec1, repeat_count ); + } + + unlink(tempfile); + return 0; +} diff --git a/tests/cpueater/Android.mk b/tests/cpueater/Android.mk index 88e3cd83..0b258b1d 100644 --- a/tests/cpueater/Android.mk +++ b/tests/cpueater/Android.mk @@ -22,3 +22,11 @@ LOCAL_MODULE_TAGS := tests eng LOCAL_SRC_FILES := cpueater.c include $(BUILD_EXECUTABLE) +include $(CLEAR_VARS) +LOCAL_MODULE := daemonize +LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES) +LOCAL_MODULE_TAGS := tests eng +LOCAL_SRC_FILES := daemonize.c +LOCAL_SHARED_LIBRARIES := libhardware +include $(BUILD_EXECUTABLE) + diff --git a/tests/cpueater/daemonize.c b/tests/cpueater/daemonize.c new file mode 100644 index 00000000..8d07a1c6 --- /dev/null +++ b/tests/cpueater/daemonize.c @@ -0,0 +1,130 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + + +#include +#include +#include +#include +#include +#include +#include + + +#include "hardware/power.h" + + +main(int argc, char **argv) +{ + int pid, fd, mode; + unsigned int delay = 0; + int status = 0; + char *file = 0; + char lockid[32]; + + if (argc < 2) { + printf("Usage: %s [-f logfile] [-a] [-d delay] \n", argv[0]); + exit(1); + } + close(0); open("/dev/null", 0); + close(1); + + mode = O_TRUNC; + + while(**++argv == '-') { + while(*++*argv) { + switch(**argv) { + case 'f': + if(*++*argv) + file = *argv; + else + file = *++argv; + goto next_arg; + case 'd': + if(*++*argv) + delay = atoi(*argv); + else + delay = atoi(*++argv); + goto next_arg; + case 'a': + mode = O_APPEND; + break; + } + } +next_arg: ; + } + + if (file) { + if(open(file, O_WRONLY|mode|O_CREAT, 0666) < 0) { + perror(file); + exit(1); + } + } + else { + if(open("/dev/null", O_WRONLY) < 0) { + perror("/dev/null"); + exit(1); + } + } + + switch(pid = fork()) { + case -1: + perror(argv[0]); + exit(1); + break; + case 0: + fflush(stdout); + close(2); dup(1); /* join stdout and stderr */ + chdir("/"); + umask(0); + setpgrp(); + setsid(); + for (fd = 3; fd < 256; fd++) { + close(fd); + } + if(delay) { + snprintf(lockid, 32, "daemonize%d", (int) getpid()); + acquire_wake_lock(PARTIAL_WAKE_LOCK, lockid); + } + + switch(pid = fork()) { + case -1: + break; + case 0: + if(delay) { + sleep(delay); + } + execv(argv[0], argv); + execvp(argv[0], argv); + perror(argv[0]); + break; + default: + if(delay) { + waitpid(pid, &status, 0); + release_wake_lock(lockid); + } + _exit(0); + } + _exit(1); + break; + default: + exit(0); + break; + } +} + +/* vim:ts=4:sw=4:softtabstop=4:smarttab:expandtab */ diff --git a/tests/framebuffer/Android.mk b/tests/framebuffer/Android.mk new file mode 100644 index 00000000..d6a8537d --- /dev/null +++ b/tests/framebuffer/Android.mk @@ -0,0 +1,33 @@ +LOCAL_PATH:= $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES:= \ + refresh.c + +LOCAL_SHARED_LIBRARIES := \ + libcutils + +LOCAL_MODULE:= test-fb-refresh + +LOCAL_MODULE_TAGS := tests + +ifeq ($(TARGET_SIMULATOR),true) + ifeq ($(HOST_OS),linux) + # need this for clock_gettime() + LOCAL_LDLIBS += -lrt + endif +endif + +include $(BUILD_EXECUTABLE) + +## + +ifneq ($(TARGET_SIMULATOR),true) +include $(CLEAR_VARS) +LOCAL_SRC_FILES := fb_test.c +LOCAL_MODULE = test-fb-simple +LOCAL_MODULE_TAGS := tests +LOCAL_FORCE_STATIC_EXECUTABLE := true +LOCAL_STATIC_LIBRARIES := libc +include $(BUILD_EXECUTABLE) +endif # sim diff --git a/tests/framebuffer/fb_test.c b/tests/framebuffer/fb_test.c new file mode 100644 index 00000000..6fdbf3b3 --- /dev/null +++ b/tests/framebuffer/fb_test.c @@ -0,0 +1,232 @@ +/* + * Copyright (C) 2007 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include +#include + +#include +#include +#include +#include + +#include +#include + +#include + +#include "minui.h" + +typedef struct { + GGLSurface texture; + unsigned cwidth; + unsigned cheight; + unsigned ascent; +} GRFont; + +static GGLContext *gr_context = 0; +static GGLSurface gr_framebuffer[2]; +static unsigned gr_active_fb = 0; + +static int gr_fb_fd = -1; +static int gr_vt_fd = -1; + +static struct fb_var_screeninfo vi; +struct fb_fix_screeninfo fi; +struct timespec tv, tv2; + +static void dumpinfo(struct fb_fix_screeninfo *fi, + struct fb_var_screeninfo *vi); + +static int get_framebuffer(GGLSurface *fb) +{ + int fd; + void *bits; + + fd = open("/dev/graphics/fb0", O_RDWR); + if(fd < 0) { + perror("cannot open fb0"); + return -1; + } + + if(ioctl(fd, FBIOGET_FSCREENINFO, &fi) < 0) { + perror("failed to get fb0 info"); + return -1; + } + + if(ioctl(fd, FBIOGET_VSCREENINFO, &vi) < 0) { + perror("failed to get fb0 info"); + return -1; + } + + dumpinfo(&fi, &vi); + + bits = mmap(0, fi.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if(bits == MAP_FAILED) { + perror("failed to mmap framebuffer"); + return -1; + } + + fb->version = sizeof(*fb); + fb->width = vi.xres; + fb->height = vi.yres; + fb->stride = fi.line_length / (vi.bits_per_pixel >> 3); + fb->data = bits; + fb->format = GGL_PIXEL_FORMAT_RGB_565; + + fb++; + + fb->version = sizeof(*fb); + fb->width = vi.xres; + fb->height = vi.yres; + fb->stride = fi.line_length / (vi.bits_per_pixel >> 3); + fb->data = (void*) (((unsigned) bits) + vi.yres * vi.xres * 2); + fb->format = GGL_PIXEL_FORMAT_RGB_565; + + return fd; +} + +static void set_active_framebuffer(unsigned n) +{ + if(n > 1) return; + vi.yres_virtual = vi.yres * 2; + vi.yoffset = n * vi.yres; + if(ioctl(gr_fb_fd, FBIOPUT_VSCREENINFO, &vi) < 0) { + fprintf(stderr,"active fb swap failed!\n"); + } +} + +static void dumpinfo(struct fb_fix_screeninfo *fi, struct fb_var_screeninfo *vi) +{ + fprintf(stderr,"vi.xres = %d\n", vi->xres); + fprintf(stderr,"vi.yres = %d\n", vi->yres); + fprintf(stderr,"vi.xresv = %d\n", vi->xres_virtual); + fprintf(stderr,"vi.yresv = %d\n", vi->yres_virtual); + fprintf(stderr,"vi.xoff = %d\n", vi->xoffset); + fprintf(stderr,"vi.yoff = %d\n", vi->yoffset); + fprintf(stderr, "vi.bits_per_pixel = %d\n", vi->bits_per_pixel); + + fprintf(stderr, "fi.line_length = %d\n", fi->line_length); + +} + +int gr_init(void) +{ + int fd; + + + fd = open("/dev/tty0", O_RDWR | O_SYNC); + if(fd < 0) return -1; + + if(ioctl(fd, KDSETMODE, (void*) KD_GRAPHICS)) { + close(fd); + return -1; + } + + gr_fb_fd = get_framebuffer(gr_framebuffer); + + if(gr_fb_fd < 0) { + ioctl(fd, KDSETMODE, (void*) KD_TEXT); + close(fd); + return -1; + } + + gr_vt_fd = fd; + + /* start with 0 as front (displayed) and 1 as back (drawing) */ + gr_active_fb = 0; + set_active_framebuffer(0); + + return 0; +} + +void gr_exit(void) +{ + close(gr_fb_fd); + gr_fb_fd = -1; + + ioctl(gr_vt_fd, KDSETMODE, (void*) KD_TEXT); + close(gr_vt_fd); + gr_vt_fd = -1; +} + +int gr_fb_width(void) +{ + return gr_framebuffer[0].width; +} + +int gr_fb_height(void) +{ + return gr_framebuffer[0].height; +} + +uint16_t red = 0xf800; +uint16_t green = 0x07e0; +uint16_t blue = 0x001f; + +void draw_grid(int w, int h, uint16_t* loc) { + int i, j; + int v; + int stride = fi.line_length / (vi.bits_per_pixel >> 3); + + for (j = 0; j < h/2; j++) { + for (i = 0; i < w/2; i++) + loc[i + j*(stride)] = red; + for (; i < w; i++) + loc[i + j*(stride)] = green; + } + for (; j < h; j++) { + for (i = 0; i < w/2; i++) + loc[i + j*(stride)] = blue; + for (; i < w; i++) + loc[i + j*(stride)] = 0xffff; + } + +} + +void clear_screen(int w, int h, uint16_t* loc) +{ + int i,j; + int stride = fi.line_length / (vi.bits_per_pixel >> 3); + + for (j = 0; j < h; j++) + for (i = 0; i < w; i++) + loc[i + j*(stride)] = 0x0000; +} + + +int main(int argc, char **argv) { + int w; + int h; + gr_init(); + w = vi.xres; + h = vi.yres; + clear_screen(w, h, (uint16_t *)gr_framebuffer[0].data); + + if (argc > 2) { + w = atoi(argv[1]); + h = atoi(argv[2]); + } + + draw_grid(w, h, (uint16_t *)gr_framebuffer[0].data); + printf("%lld\n", (tv2.tv_sec*1000000000LL + tv2.tv_nsec) - (tv.tv_sec*1000000000LL + tv.tv_nsec)); + set_active_framebuffer(1); + set_active_framebuffer(0); + + return 0; +} diff --git a/tests/framebuffer/minui.h b/tests/framebuffer/minui.h new file mode 100644 index 00000000..4efc9719 --- /dev/null +++ b/tests/framebuffer/minui.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2007 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _MINUI_H_ +#define _MINUI_H_ + +int gr_init(void); +void gr_exit(void); + +int gr_fb_width(void); +int gr_fb_height(void); +void gr_flip(void); + +void gr_color(unsigned char r, unsigned char g, unsigned char b); +void gr_fill(int x, int y, int w, int h); +int gr_text(int x, int y, const char *s); +int gr_measure(const char *s); + + +typedef struct event event; + +struct event +{ + unsigned type; + unsigned code; + unsigned value; +}; + +int ev_init(void); +void ev_exit(void); + +int ev_get(event *ev, unsigned dont_wait); + +#define TYPE_KEY 1 + +#define KEY_UP 103 +#define KEY_DOWN 108 +#define KEY_LEFT 105 +#define KEY_RIGHT 106 +#define KEY_CENTER 232 +#define KEY_ENTER 28 + +#endif diff --git a/tests/framebuffer/refresh.c b/tests/framebuffer/refresh.c new file mode 100644 index 00000000..43dc7cff --- /dev/null +++ b/tests/framebuffer/refresh.c @@ -0,0 +1,169 @@ +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +int64_t systemTime() +{ + struct timespec t; + t.tv_sec = t.tv_nsec = 0; + clock_gettime(CLOCK_MONOTONIC, &t); + return (int64_t)(t.tv_sec)*1000000000LL + t.tv_nsec; +} + +int main(int argc, char** argv) +{ + char const * const device_template[] = { + "/dev/graphics/fb%u", + "/dev/fb%u", + 0 }; + int fd = -1; + int i=0; + int j=0; + char name[64]; + while ((fd==-1) && device_template[i]) { + snprintf(name, 64, device_template[i], 0); + fd = open(name, O_RDWR, 0); + i++; + } + if (fd < 0) + return -errno; + + struct fb_fix_screeninfo finfo; + if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1) + return -errno; + + struct fb_var_screeninfo info; + if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1) + return -errno; + + info.reserved[0] = 0; + info.reserved[1] = 0; + info.reserved[2] = 0; + info.xoffset = 0; + info.yoffset = 0; + info.bits_per_pixel = 16; + info.activate = FB_ACTIVATE_NOW; + + if (ioctl(fd, FBIOPUT_VSCREENINFO, &info) == -1) { + printf("FBIOPUT_VSCREENINFO failed (%d x %d)\n", + info.xres_virtual, info.yres_virtual); + return 0; + } + + if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1) + return -errno; + + int refreshRate = 1000000000000000LLU / + ( + (uint64_t)( info.upper_margin + info.lower_margin + info.yres ) + * ( info.left_margin + info.right_margin + info.xres ) + * info.pixclock + ); + + float xdpi = (info.xres * 25.4f) / info.width; + float ydpi = (info.yres * 25.4f) / info.height; + float fps = refreshRate / 1000.0f; + + printf( "using (fd=%d)\n" + "id = %s\n" + "xres = %d px\n" + "yres = %d px\n" + "xres_virtual = %d px\n" + "yres_virtual = %d px\n" + "bpp = %d\n" + "r = %2u:%u\n" + "g = %2u:%u\n" + "b = %2u:%u\n", + fd, + finfo.id, + info.xres, + info.yres, + info.xres_virtual, + info.yres_virtual, + info.bits_per_pixel, + info.red.offset, info.red.length, + info.green.offset, info.green.length, + info.blue.offset, info.blue.length + ); + + printf( "width = %d mm (%f dpi)\n" + "height = %d mm (%f dpi)\n" + "refresh rate = %.2f Hz\n", + info.width, xdpi, + info.height, ydpi, + fps + ); + + printf("upper_margin=%d, lower_margin=%d, left_margin=%d, right_margin=%d, pixclock=%d, finfo.smem_len=%d\n", + info.upper_margin, info.lower_margin, info.left_margin, info.right_margin, info.pixclock, finfo.smem_len); + + if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1) + return -errno; + + if (finfo.smem_len <= 0) + return -errno; + + /* + * Open and map the display. + */ + + uint16_t* buffer = (uint16_t*) mmap( + 0, finfo.smem_len, + PROT_READ | PROT_WRITE, + MAP_SHARED, + fd, 0); + + if (buffer == MAP_FAILED) + return -errno; + + // at least for now, always clear the fb + memset(buffer, 0, finfo.smem_len); + memset(buffer, 0xff, 320*(info.yres_virtual/2)*2); + + int l,t,w,h; + l=0; + t=0; + w=320; + h=480; + info.reserved[0] = 0x54445055; // "UPDT"; + info.reserved[1] = (uint16_t)l | ((uint32_t)t << 16); + info.reserved[2] = (uint16_t)(l+w) | ((uint32_t)(t+h) << 16); + + int err; + int c = 0; + int64_t time = systemTime(); + while (1) { + + info.activate = FB_ACTIVATE_VBL; + info.yoffset = 0; + ioctl(fd, FBIOPUT_VSCREENINFO, &info); + + info.activate = FB_ACTIVATE_VBL; + info.yoffset = info.yres_virtual/2; + err = ioctl(fd, FBIOPUT_VSCREENINFO, &info); + + c+=2; + if (c==60*2) { + int64_t now = systemTime(); + time = now - time; + printf("refresh rate = %f Hz\n", (c*1000000000.0 / (double)time)); + c = 0; + time = now; + } + } + return 0; +} diff --git a/tests/fstest/perm_checker.conf b/tests/fstest/perm_checker.conf index 460f2e4a..fe253d7b 100644 --- a/tests/fstest/perm_checker.conf +++ b/tests/fstest/perm_checker.conf @@ -11,29 +11,36 @@ /data/anr/... 000 662 root system log log /data/app/ 771 771 system system system system /data/app/... 644 664 system system system system -/data/dalvik-cache/ 750 751 root root root root +/data/app-private/ 700 771 system system system system +/data/dalvik-cache/ 750 771 root system root system /data/dalvik-cache/... 400 744 root 19999 root 19999 /data/data 701 771 system system system system /data/data/... 000 775 system 19999 system 19999 -/data/testinfo/ 770 771 root system root system -/data/testinfo/* 000 664 root system root system -/data/tombstones/ 755 755 system system system system -/data/tombstones/* 000 600 system 19999 system 19999 +/data/local/ 771 771 shell shell shell shell +/data/local/tmp/ 771 1771 shell shell shell shell /data/lost+found/ 700 770 root root root root /data/misc/ 1711 1771 root system root misc /data/misc/akmd_set.txt 600 640 root compass compass compass /data/misc/rild* 600 660 root radio root radio -/data/misc/hcid/ 770 770 bluetooth bluetooth bluetooth bluetooth +/data/misc/dhcp/ 700 770 root dhcp dhcp dhcp +/data/misc/dhcp/... 000 660 root dhcp dhcp dhcp +/data/misc/hcid/ 700 770 root bluetooth bluetooth bluetooth +/data/misc/hcid/... 600 770 root bluetooth bluetooth bluetooth /data/misc/wifi/ 000 1771 system wifi system wifi /data/misc/wifi/... 000 770 root wifi root wifi -/data/local/ 771 771 shell shell shell shell -/data/local/tmp/ 771 1771 shell shell shell shell -/data/app_private/ 700 771 system system system system -/data/system/... 000 770 system system system system -/dev/ 1777 1777 root root root root -/dev/alarm 660 660 root system root system +/data/property/ 700 770 root root root root +/data/property/... 600 660 root root root root +/data/system/ 000 775 system system system system +/data/system/... 000 774 system system system system +/data/testinfo/ 770 771 root system root system +/data/testinfo/* 000 664 root system root system +/data/tombstones/ 755 755 system system system system +/data/tombstones/* 000 600 system 19999 system 19999 +/dev/ 755 755 root root root root +/dev/alarm 600 664 root radio root radio /dev/ashmem 666 666 root root root root -/dev/android_adb 600 600 root root root root +/dev/android_adb 600 660 root adb root adb +/dev/android_adb_enable 600 660 root adb root adb /dev/android_ums 640 640 mount mount mount mount /dev/binder 666 666 root root root root /dev/console 600 600 root root root root @@ -45,12 +52,14 @@ /dev/cpu_dma_latency 600 660 root system root system /dev/mem 600 600 root root root root /dev/msm_mp3 600 660 root system root audio +/dev/msm_pcm_ctl 660 660 system system audio audio /dev/msm_pcm_in 660 660 system system audio audio /dev/msm_pcm_out 660 660 system system audio audio /dev/msm_perf 600 600 root root root root /dev/null 666 666 root root root root -/dev/pmem_adsp 660 660 system system audio audio /dev/pmem 660 660 system system graphics graphics +/dev/pmem_adsp 660 660 system system audio audio +/dev/pmem_camera 600 660 root system root camera /dev/ppp 600 600 root root root root /dev/psaux 600 600 root root root root /dev/ptmx 666 666 root root root root @@ -81,16 +90,21 @@ /dev/oncrpc/ 755 755 root root root root /dev/oncrpc/... 000 660 root camera root camera /dev/pts/ 755 755 root root root root -/dev/pts/* 600 600 root system root system +/dev/pts/* 600 600 root shell root shell /dev/mtd/ 750 775 root root root root +/dev/mtd/mtd0 460 460 radio radio diag diag /dev/mtd/* 600 600 root root root root /dev/socket/ 750 755 root system root system +/dev/socket/bluetooth 600 660 root bluetooth bluetooth bluetooth /dev/socket/dbus 660 660 root bluetooth bluetooth bluetooth +/dev/socket/dbus_bluetooth 600 660 root bluetooth bluetooth bluetooth /dev/socket/installd 600 660 system system system system /dev/socket/mountd 660 660 root mount root mount /dev/socket/property_service 666 666 root system root system -/dev/socket/rild 660 660 root radio radio radio +/dev/socket/rild 660 660 root radio root radio +/dev/socket/rild-debug 660 660 root radio root radio /dev/socket/usbd 660 660 root mount mount mount +/dev/socket/wpa_* 600 660 root wifi wifi wifi /dev/socket/zygote 666 666 root root root root /etc 777 777 root root root root /proc/ 555 555 root root root root @@ -116,15 +130,16 @@ /system/* 000 664 root system root system /system/app/ 755 755 root root root root /system/app/... 600 644 root root root root -/system/bin/... 000 755 root system root system -/system/xbin/... 000 755 root system root system +/system/bin/... 000 755 root shell root shell +/system/bin/netcfg 000 2750 root root inet inet +/system/bin/ping 000 2755 root root net_raw net_raw /system/etc/ 755 755 root root root root -/system/etc/... 000 664 root system root audio +/system/etc/... 000 664 root bluetooth root audio /system/etc/firmware/ 700 755 root root root root -/system/etc/init.goldfish.sh 500 550 root root root root -/system/etc/init.gprs-pppd 500 550 root root root root +/system/etc/init.goldfish.sh 500 550 root root root shell +/system/etc/init.gprs-pppd 500 550 root root root shell /system/etc/init.testmenu 500 550 root root root root -/system/etc/perm_checker.conf 000 777 root system root system +/system/etc/perm_checker.conf 000 777 root shell root shell /system/etc/ppp/ 755 775 root system root system /system/etc/ppp/chap-secrets 600 660 root system root system /system/etc/ppp/ip-down 500 550 root system root system @@ -147,4 +162,4 @@ /system/sounds/ 755 755 root root root root /system/sounds/... 644 644 root root root root /system/usr/... 400 755 root root root root -/sqlite_stmt_journals 1777 1777 root root root root +/sqlite_stmt_journals/ 1777 1777 root root root root -- 2.11.0