├── Makefile ├── README.rst ├── bitstream.c ├── bitstream.h ├── package.json └── tests ├── CuTest.c ├── CuTest.h ├── make-tests.sh └── test_bitstream.c /Makefile: -------------------------------------------------------------------------------- 1 | GCOV_OUTPUT = *.gcda *.gcno *.gcov 2 | GCOV_CCFLAGS = -fprofile-arcs -ftest-coverage 3 | CC = gcc 4 | CCFLAGS = -I. -Itests -g -O2 -Wall -Werror -Wcast-align -fno-omit-frame-pointer -fno-common -fsigned-char $(GCOV_CCFLAGS) 5 | 6 | all: test 7 | 8 | main.c: 9 | sh tests/make-tests.sh tests/test_*.c > main.c 10 | 11 | test: main.c bitstream.o tests/test_bitstream.c tests/CuTest.c main.c 12 | $(CC) $(CCFLAGS) -o $@ $^ 13 | ./test 14 | gcov main.c tests/test_bitstream.c bitstream.c 15 | 16 | bitstream.o: bitstream.c 17 | $(CC) $(CCFLAGS) -c -o $@ $^ 18 | 19 | clean: 20 | rm -f main.c bitstream.o test $(GCOV_OUTPUT) 21 | -------------------------------------------------------------------------------- /README.rst: -------------------------------------------------------------------------------- 1 | How does it work? 2 | ----------------- 3 | 4 | See bitstream.h for documentation. 5 | 6 | See bitstream in action: https://github.com/willemt/peer-wire-protocol/blob/master/pwp_connection.c 7 | 8 | Check out quick example:: 9 | 10 | char* bits[100]; 11 | 12 | bitstream_init(bits, 100); 13 | 14 | /* write 0x5 as a byte to the stream. Move pointer by 1 byte */ 15 | bitstream_write_ubyte(&b, 0x5); 16 | 17 | /* write out an 32bit unsigned int to the stream. Move pointer by 4 bytes */ 18 | bitstream_write_uint32(&b, 0xFF00FF00); 19 | 20 | /* write out 1 bit. Record that we've "moved" forward one bit */ 21 | unsigned int bit_offset = 0; 22 | bitstream_write_bit_from_bitoffset(&b, 1, &bit_offset); 23 | 24 | /* write out 31 bits of a uint32. Move pointer 4 bytes forward */ 25 | bitstream_write_uint32_from_bitoffset(&b, 0xFF00FF00, 31, &bit_offset); 26 | 27 | 28 | Building 29 | -------- 30 | $make 31 | 32 | -------------------------------------------------------------------------------- /bitstream.c: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | #include 5 | 6 | void bitstream_init( 7 | char *b, 8 | int size 9 | ) 10 | { 11 | memset(b, 0, sizeof(char) * size); 12 | } 13 | 14 | void bitstream_write_byte( 15 | char **b, 16 | char value 17 | ) 18 | { 19 | **b = value; 20 | *b += 1; 21 | } 22 | 23 | void bitstream_write_byte_from_bitoffset( 24 | char **b, 25 | char value, 26 | unsigned int* bit_pos 27 | ) 28 | { 29 | /* position pointer */ 30 | unsigned int byte_offset = (*bit_pos - *bit_pos % 8) / 8; 31 | unsigned int bit_offset = *bit_pos % 8; 32 | unsigned char *ptr = (unsigned char*)*b + byte_offset; 33 | 34 | /* left half */ 35 | unsigned char val = *ptr; 36 | val >>= bit_offset; 37 | val <<= bit_offset; 38 | val |= value >> bit_offset; 39 | *ptr = val; 40 | 41 | /* right half */ 42 | val = value << bit_offset; 43 | *(ptr + 1) = val; 44 | *b += 1; 45 | } 46 | 47 | void bitstream_write_uint32( 48 | char **b, 49 | uint32_t value 50 | ) 51 | { 52 | memcpy(*b, &value, sizeof(uint32_t)); 53 | *b += sizeof(uint32_t); 54 | } 55 | 56 | char bitstream_read_byte( 57 | char **b 58 | ) 59 | { 60 | unsigned char val = **b; 61 | *b += 1; 62 | return val; 63 | } 64 | 65 | uint32_t bitstream_read_uint32( 66 | char **b 67 | ) 68 | { 69 | uint32_t value; 70 | 71 | memcpy(&value, *b, sizeof(uint32_t)); 72 | *b += sizeof(uint32_t); 73 | return value; 74 | } 75 | 76 | void bitstream_write_uint32_from_bitoffset( 77 | char **b, 78 | const uint32_t val, 79 | const unsigned int nbits, 80 | unsigned int* bit_pos 81 | ) 82 | { 83 | 84 | assert(nbits <= 32); 85 | 86 | unsigned int int_offset = (*bit_pos - *bit_pos % 32) / 32; 87 | unsigned int bit_offset = *bit_pos % 32; 88 | 89 | uint32_t val_posting; 90 | /* get old value */ 91 | memcpy(&val_posting, *b + (int_offset) * sizeof(uint32_t), sizeof(uint32_t)); 92 | 93 | /* write b out */ 94 | val_posting = val_posting | ((val << (32 - nbits)) >> bit_offset); 95 | //memcpy(*b, &val_posting, sizeof(uint32_t)); 96 | memcpy(*b + (int_offset) * sizeof(uint32_t), &val_posting, sizeof(uint32_t)); 97 | 98 | /* do right handside */ 99 | if (32 < bit_offset + nbits) 100 | { 101 | int nbits2 = (bit_offset + nbits) % 32; 102 | val_posting = val << (32 - nbits2); 103 | //memcpy(*b, &val_posting, sizeof(uint32_t)); 104 | memcpy(*b + (int_offset + 1) * sizeof(uint32_t), &val_posting, sizeof(uint32_t)); 105 | } 106 | 107 | *bit_pos += nbits; 108 | } 109 | 110 | void bitstream_write_bit_from_bitoffset( 111 | char **b, 112 | const unsigned int val, 113 | unsigned int* bit_pos 114 | ) 115 | { 116 | /* position pointer */ 117 | unsigned int byte_offset = (*bit_pos - *bit_pos % 8) / 8; 118 | unsigned int bit_offset = *bit_pos % 8; 119 | unsigned char *ptr = (unsigned char*)*b + byte_offset; 120 | 121 | unsigned char stamp; 122 | 123 | stamp = val != 0; 124 | stamp <<= 8 -1; 125 | stamp >>= bit_offset; 126 | *ptr |= stamp; 127 | *bit_pos += 1; 128 | } 129 | 130 | void bitstream_read_uint32_from_bitoffset( 131 | char **b, 132 | uint32_t * val_out, 133 | const unsigned int nbits, 134 | unsigned int* bit_pos 135 | ) 136 | { 137 | unsigned int bit_offset, int_offset; 138 | 139 | assert(nbits <= 32); 140 | 141 | /* position pointer */ 142 | int_offset = (*bit_pos - *bit_pos % 32) / 32; 143 | bit_offset = *bit_pos % 32; 144 | 145 | /* read b */ 146 | //*val = ntohl(*ptr); 147 | //*val = l2b_endian(*ptr); 148 | memcpy(val_out, *b + int_offset * sizeof(uint32_t), sizeof(uint32_t)); 149 | *val_out <<= bit_offset; 150 | *val_out >>= 32 - nbits; 151 | 152 | /* do otherside */ 153 | if (32 < bit_offset + nbits) 154 | { 155 | int nbits2; 156 | uint32_t val; 157 | 158 | nbits2 = (bit_offset + nbits) % 32; 159 | memcpy(&val, *b + (int_offset + 1) * sizeof(uint32_t), sizeof(uint32_t)); 160 | 161 | //*val |= ntohl(*ptr) >> (32 - nbits2); 162 | //*val |= l2b_endian(*ptr) >> (32 - nbits2); 163 | //*val_out |= *ptr >> (32 - nbits2); 164 | *val_out |= val >> (32 - nbits2); 165 | } 166 | 167 | *bit_pos += nbits; 168 | } 169 | 170 | int bitstream_read_bit( 171 | char **b, 172 | unsigned int* bit_pos 173 | ) 174 | { 175 | /* position pointer */ 176 | unsigned int byte_offset = (*bit_pos - *bit_pos % 8) / 8; 177 | unsigned int bit_offset = *bit_pos % 8; 178 | unsigned char *ptr = (unsigned char*)*b + byte_offset; 179 | 180 | //val = ntohl(*ptr); 181 | unsigned char val = *ptr; 182 | val <<= bit_offset; 183 | val >>= 8 - 1; 184 | *bit_pos += 1; 185 | return val == 1; 186 | } 187 | 188 | #if 0 189 | static int l2b_endian(int in) 190 | { 191 | int out; 192 | 193 | ((unsigned char*)&out)[0] = ((unsigned char*)&in)[3]; 194 | ((unsigned char*)&out)[1] = ((unsigned char*)&in)[2]; 195 | ((unsigned char*)&out)[2] = ((unsigned char*)&in)[1]; 196 | ((unsigned char*)&out)[3] = ((unsigned char*)&in)[0]; 197 | 198 | return out; 199 | } 200 | #endif 201 | 202 | void bitstream_write_string( 203 | char **b, 204 | const char* string, 205 | unsigned int len 206 | ) 207 | { 208 | strncpy((char*)*b,string,len); 209 | *b += len; 210 | } 211 | 212 | void bitstream_read_string( 213 | char **b, 214 | char* out_string, 215 | unsigned int len 216 | ) 217 | { 218 | strncpy(out_string,(char*)*b, len); 219 | *b += len; 220 | } 221 | 222 | -------------------------------------------------------------------------------- /bitstream.h: -------------------------------------------------------------------------------- 1 | #ifndef BITSTREAM_H 2 | #define BITSTREAM_H 3 | 4 | void bitstream_init( 5 | char *b, 6 | unsigned int size); 7 | 8 | /** 9 | * Write out byte value to bitstream. Increment b by 1 */ 10 | void bitstream_write_byte( 11 | char **b, 12 | char value); 13 | 14 | /** 15 | * Write out uint32 value to bitstream. Increment b by 4 */ 16 | void bitstream_write_uint32( 17 | char **b, 18 | uint32_t value); 19 | 20 | /** 21 | * Write out bit value to bitstream. 22 | * Only increment b by 1 when bit_pos will be 8 23 | * @param bit_pos Current bit offset within bitstream */ 24 | void bitstream_write_bit_from_bitoffset( 25 | char **b, 26 | const uint32_t val, 27 | unsigned int* bit_pos 28 | ); 29 | 30 | /** 31 | * Write out up to 32bits to bitstream. 32 | * Increment b according to bit_pos 33 | * 34 | * @param val value to be written 35 | * @param nbits number of bits to be written 36 | * @param bit_pos Current bit offset within bitstream */ 37 | void bitstream_write_uint32_from_bitoffset( 38 | char **b, 39 | const uint32_t val, 40 | const unsigned int nbits, 41 | unsigned int* bit_pos); 42 | 43 | /** 44 | * Write out string to bitstream. Increment b by length of string 45 | * @param string The string to be written 46 | * @param len Length of string */ 47 | void bitstream_write_string( 48 | char **b, 49 | const char* string, 50 | unsigned int len); 51 | 52 | /** 53 | * Read uint32 from bitstream. 54 | * Increment b by 4 55 | * @param bit_pos Current bit offset within bitstream */ 56 | void bitstream_read_uint32_from_bitoffset( 57 | char **b, 58 | uint32_t * val, 59 | const unsigned int nbits, 60 | unsigned int* bit_pos); 61 | 62 | /** 63 | * Read one bit from bitstream. 64 | * Only increment b by 1 when bit_pos will be 8 65 | * @param bit_pos Current bit offset within bitstream 66 | * @return bit's value */ 67 | int bitstream_read_bit( 68 | char **b, 69 | unsigned int* bit_pos); 70 | 71 | /** 72 | * Read string from bitstream. 73 | * Increment by len 74 | * @param bit_pos Current bit offset within bitstream */ 75 | void bitstream_read_string( 76 | char **b, 77 | char* out_string, 78 | unsigned int len); 79 | 80 | /** 81 | * Read byte from bitstream 82 | * Increment b by 1 83 | * @param byte value */ 84 | char bitstream_read_byte( 85 | char **b); 86 | 87 | /** 88 | * Read uint32 from bitstream. 89 | * Increment by 4 bytes 90 | * @return value of uint32 */ 91 | uint32_t bitstream_read_uint32( 92 | char **b); 93 | 94 | void bitstream_write_byte_from_bitoffset( 95 | char **b, 96 | char value, 97 | unsigned int* bit_pos); 98 | 99 | #endif /* BITSTREAM_H */ 100 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "bitstream", 3 | "version": "0.0.1", 4 | "repo": "willemt/bitstream", 5 | "description": "Let me write out bits to a stream", 6 | "keywords": ["stream", "bits"], 7 | "license": "BSD", 8 | "src": ["bitstream.c", "bitstream.h"] 9 | } 10 | -------------------------------------------------------------------------------- /tests/CuTest.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #include "CuTest.h" 9 | 10 | /*-------------------------------------------------------------------------* 11 | * CuStr 12 | *-------------------------------------------------------------------------*/ 13 | 14 | char* CuStrAlloc(int size) 15 | { 16 | char* newStr = (char*) malloc( sizeof(char) * (size) ); 17 | return newStr; 18 | } 19 | 20 | char* CuStrCopy(const char* old) 21 | { 22 | int len = strlen(old); 23 | char* newStr = CuStrAlloc(len + 1); 24 | strcpy(newStr, old); 25 | return newStr; 26 | } 27 | 28 | /*-------------------------------------------------------------------------* 29 | * CuString 30 | *-------------------------------------------------------------------------*/ 31 | 32 | void CuStringInit(CuString* str) 33 | { 34 | str->length = 0; 35 | str->size = STRING_MAX; 36 | str->buffer = (char*) malloc(sizeof(char) * str->size); 37 | str->buffer[0] = '\0'; 38 | } 39 | 40 | CuString* CuStringNew(void) 41 | { 42 | CuString* str = (CuString*) malloc(sizeof(CuString)); 43 | str->length = 0; 44 | str->size = STRING_MAX; 45 | str->buffer = (char*) malloc(sizeof(char) * str->size); 46 | str->buffer[0] = '\0'; 47 | return str; 48 | } 49 | 50 | void CuStringResize(CuString* str, int newSize) 51 | { 52 | str->buffer = (char*) realloc(str->buffer, sizeof(char) * newSize); 53 | str->size = newSize; 54 | } 55 | 56 | void CuStringAppend(CuString* str, const char* text) 57 | { 58 | int length; 59 | 60 | if (text == NULL) { 61 | text = "NULL"; 62 | } 63 | 64 | length = strlen(text); 65 | if (str->length + length + 1 >= str->size) 66 | CuStringResize(str, str->length + length + 1 + STRING_INC); 67 | str->length += length; 68 | strcat(str->buffer, text); 69 | } 70 | 71 | void CuStringAppendChar(CuString* str, char ch) 72 | { 73 | char text[2]; 74 | text[0] = ch; 75 | text[1] = '\0'; 76 | CuStringAppend(str, text); 77 | } 78 | 79 | void CuStringAppendFormat(CuString* str, const char* format, ...) 80 | { 81 | va_list argp; 82 | char buf[HUGE_STRING_LEN]; 83 | va_start(argp, format); 84 | vsprintf(buf, format, argp); 85 | va_end(argp); 86 | CuStringAppend(str, buf); 87 | } 88 | 89 | void CuStringInsert(CuString* str, const char* text, int pos) 90 | { 91 | int length = strlen(text); 92 | if (pos > str->length) 93 | pos = str->length; 94 | if (str->length + length + 1 >= str->size) 95 | CuStringResize(str, str->length + length + 1 + STRING_INC); 96 | memmove(str->buffer + pos + length, str->buffer + pos, (str->length - pos) + 1); 97 | str->length += length; 98 | memcpy(str->buffer + pos, text, length); 99 | } 100 | 101 | /*-------------------------------------------------------------------------* 102 | * CuTest 103 | *-------------------------------------------------------------------------*/ 104 | 105 | void CuTestInit(CuTest* t, const char* name, TestFunction function) 106 | { 107 | t->name = CuStrCopy(name); 108 | t->failed = 0; 109 | t->ran = 0; 110 | t->message = NULL; 111 | t->function = function; 112 | t->jumpBuf = NULL; 113 | } 114 | 115 | CuTest* CuTestNew(const char* name, TestFunction function) 116 | { 117 | CuTest* tc = CU_ALLOC(CuTest); 118 | CuTestInit(tc, name, function); 119 | return tc; 120 | } 121 | 122 | void CuTestRun(CuTest* tc) 123 | { 124 | printf(" running %s\n", tc->name); 125 | 126 | jmp_buf buf; 127 | tc->jumpBuf = &buf; 128 | if (setjmp(buf) == 0) 129 | { 130 | tc->ran = 1; 131 | (tc->function)(tc); 132 | } 133 | tc->jumpBuf = 0; 134 | } 135 | 136 | static void CuFailInternal(CuTest* tc, const char* file, int line, CuString* string) 137 | { 138 | char buf[HUGE_STRING_LEN]; 139 | 140 | sprintf(buf, "%s:%d: ", file, line); 141 | CuStringInsert(string, buf, 0); 142 | 143 | tc->failed = 1; 144 | tc->message = string->buffer; 145 | if (tc->jumpBuf != 0) longjmp(*(tc->jumpBuf), 0); 146 | } 147 | 148 | void CuFail_Line(CuTest* tc, const char* file, int line, const char* message2, const char* message) 149 | { 150 | CuString string; 151 | 152 | CuStringInit(&string); 153 | if (message2 != NULL) 154 | { 155 | CuStringAppend(&string, message2); 156 | CuStringAppend(&string, ": "); 157 | } 158 | CuStringAppend(&string, message); 159 | CuFailInternal(tc, file, line, &string); 160 | } 161 | 162 | void CuAssert_Line(CuTest* tc, const char* file, int line, const char* message, int condition) 163 | { 164 | if (condition) return; 165 | CuFail_Line(tc, file, line, NULL, message); 166 | } 167 | 168 | void CuAssertStrEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, 169 | const char* expected, const char* actual) 170 | { 171 | CuString string; 172 | if ((expected == NULL && actual == NULL) || 173 | (expected != NULL && actual != NULL && 174 | strcmp(expected, actual) == 0)) 175 | { 176 | return; 177 | } 178 | 179 | CuStringInit(&string); 180 | if (message != NULL) 181 | { 182 | CuStringAppend(&string, message); 183 | CuStringAppend(&string, ": "); 184 | } 185 | CuStringAppend(&string, "expected <"); 186 | CuStringAppend(&string, expected); 187 | CuStringAppend(&string, "> but was <"); 188 | CuStringAppend(&string, actual); 189 | CuStringAppend(&string, ">"); 190 | CuFailInternal(tc, file, line, &string); 191 | } 192 | 193 | void CuAssertIntEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, 194 | int expected, int actual) 195 | { 196 | char buf[STRING_MAX]; 197 | if (expected == actual) return; 198 | sprintf(buf, "expected <%d> but was <%d>", expected, actual); 199 | CuFail_Line(tc, file, line, message, buf); 200 | } 201 | 202 | void CuAssertDblEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, 203 | double expected, double actual, double delta) 204 | { 205 | char buf[STRING_MAX]; 206 | if (fabs(expected - actual) <= delta) return; 207 | sprintf(buf, "expected <%lf> but was <%lf>", expected, actual); 208 | CuFail_Line(tc, file, line, message, buf); 209 | } 210 | 211 | void CuAssertPtrEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, 212 | void* expected, void* actual) 213 | { 214 | char buf[STRING_MAX]; 215 | if (expected == actual) return; 216 | sprintf(buf, "expected pointer <0x%p> but was <0x%p>", expected, actual); 217 | CuFail_Line(tc, file, line, message, buf); 218 | } 219 | 220 | 221 | /*-------------------------------------------------------------------------* 222 | * CuSuite 223 | *-------------------------------------------------------------------------*/ 224 | 225 | void CuSuiteInit(CuSuite* testSuite) 226 | { 227 | testSuite->count = 0; 228 | testSuite->failCount = 0; 229 | } 230 | 231 | CuSuite* CuSuiteNew(void) 232 | { 233 | CuSuite* testSuite = CU_ALLOC(CuSuite); 234 | CuSuiteInit(testSuite); 235 | return testSuite; 236 | } 237 | 238 | void CuSuiteAdd(CuSuite* testSuite, CuTest *testCase) 239 | { 240 | assert(testSuite->count < MAX_TEST_CASES); 241 | testSuite->list[testSuite->count] = testCase; 242 | testSuite->count++; 243 | } 244 | 245 | void CuSuiteAddSuite(CuSuite* testSuite, CuSuite* testSuite2) 246 | { 247 | int i; 248 | for (i = 0 ; i < testSuite2->count ; ++i) 249 | { 250 | CuTest* testCase = testSuite2->list[i]; 251 | CuSuiteAdd(testSuite, testCase); 252 | } 253 | } 254 | 255 | void CuSuiteRun(CuSuite* testSuite) 256 | { 257 | int i; 258 | for (i = 0 ; i < testSuite->count ; ++i) 259 | { 260 | CuTest* testCase = testSuite->list[i]; 261 | CuTestRun(testCase); 262 | if (testCase->failed) { testSuite->failCount += 1; } 263 | } 264 | } 265 | 266 | void CuSuiteSummary(CuSuite* testSuite, CuString* summary) 267 | { 268 | int i; 269 | for (i = 0 ; i < testSuite->count ; ++i) 270 | { 271 | CuTest* testCase = testSuite->list[i]; 272 | CuStringAppend(summary, testCase->failed ? "F" : "."); 273 | } 274 | CuStringAppend(summary, "\n\n"); 275 | } 276 | 277 | void CuSuiteDetails(CuSuite* testSuite, CuString* details) 278 | { 279 | int i; 280 | int failCount = 0; 281 | 282 | if (testSuite->failCount == 0) 283 | { 284 | int passCount = testSuite->count - testSuite->failCount; 285 | const char* testWord = passCount == 1 ? "test" : "tests"; 286 | CuStringAppendFormat(details, "OK (%d %s)\n", passCount, testWord); 287 | } 288 | else 289 | { 290 | if (testSuite->failCount == 1) 291 | CuStringAppend(details, "There was 1 failure:\n"); 292 | else 293 | CuStringAppendFormat(details, "There were %d failures:\n", testSuite->failCount); 294 | 295 | for (i = 0 ; i < testSuite->count ; ++i) 296 | { 297 | CuTest* testCase = testSuite->list[i]; 298 | if (testCase->failed) 299 | { 300 | failCount++; 301 | CuStringAppendFormat(details, "%d) %s: %s\n", 302 | failCount, testCase->name, testCase->message); 303 | } 304 | } 305 | CuStringAppend(details, "\n!!!FAILURES!!!\n"); 306 | 307 | CuStringAppendFormat(details, "Runs: %d ", testSuite->count); 308 | CuStringAppendFormat(details, "Passes: %d ", testSuite->count - testSuite->failCount); 309 | CuStringAppendFormat(details, "Fails: %d\n", testSuite->failCount); 310 | } 311 | } 312 | -------------------------------------------------------------------------------- /tests/CuTest.h: -------------------------------------------------------------------------------- 1 | #ifndef CU_TEST_H 2 | #define CU_TEST_H 3 | 4 | #include 5 | #include 6 | 7 | /* CuString */ 8 | 9 | char* CuStrAlloc(int size); 10 | char* CuStrCopy(const char* old); 11 | 12 | #define CU_ALLOC(TYPE) ((TYPE*) malloc(sizeof(TYPE))) 13 | 14 | #define HUGE_STRING_LEN 8192 15 | #define STRING_MAX 256 16 | #define STRING_INC 256 17 | 18 | typedef struct 19 | { 20 | int length; 21 | int size; 22 | char* buffer; 23 | } CuString; 24 | 25 | void CuStringInit(CuString* str); 26 | CuString* CuStringNew(void); 27 | void CuStringRead(CuString* str, const char* path); 28 | void CuStringAppend(CuString* str, const char* text); 29 | void CuStringAppendChar(CuString* str, char ch); 30 | void CuStringAppendFormat(CuString* str, const char* format, ...); 31 | void CuStringInsert(CuString* str, const char* text, int pos); 32 | void CuStringResize(CuString* str, int newSize); 33 | 34 | /* CuTest */ 35 | 36 | typedef struct CuTest CuTest; 37 | 38 | typedef void (*TestFunction)(CuTest *); 39 | 40 | struct CuTest 41 | { 42 | const char* name; 43 | TestFunction function; 44 | int failed; 45 | int ran; 46 | const char* message; 47 | jmp_buf *jumpBuf; 48 | }; 49 | 50 | void CuTestInit(CuTest* t, const char* name, TestFunction function); 51 | CuTest* CuTestNew(const char* name, TestFunction function); 52 | void CuTestRun(CuTest* tc); 53 | 54 | /* Internal versions of assert functions -- use the public versions */ 55 | void CuFail_Line(CuTest* tc, const char* file, int line, const char* message2, const char* message); 56 | void CuAssert_Line(CuTest* tc, const char* file, int line, const char* message, int condition); 57 | void CuAssertStrEquals_LineMsg(CuTest* tc, 58 | const char* file, int line, const char* message, 59 | const char* expected, const char* actual); 60 | void CuAssertIntEquals_LineMsg(CuTest* tc, 61 | const char* file, int line, const char* message, 62 | int expected, int actual); 63 | void CuAssertDblEquals_LineMsg(CuTest* tc, 64 | const char* file, int line, const char* message, 65 | double expected, double actual, double delta); 66 | void CuAssertPtrEquals_LineMsg(CuTest* tc, 67 | const char* file, int line, const char* message, 68 | void* expected, void* actual); 69 | 70 | /* public assert functions */ 71 | 72 | #define CuFail(tc, ms) CuFail_Line( (tc), __FILE__, __LINE__, NULL, (ms)) 73 | #define CuAssert(tc, ms, cond) CuAssert_Line((tc), __FILE__, __LINE__, (ms), (cond)) 74 | #define CuAssertTrue(tc, cond) CuAssert_Line((tc), __FILE__, __LINE__, "assert failed", (cond)) 75 | 76 | #define CuAssertStrEquals(tc,ex,ac) CuAssertStrEquals_LineMsg((tc),__FILE__,__LINE__,NULL,(ex),(ac)) 77 | #define CuAssertStrEquals_Msg(tc,ms,ex,ac) CuAssertStrEquals_LineMsg((tc),__FILE__,__LINE__,(ms),(ex),(ac)) 78 | #define CuAssertIntEquals(tc,ex,ac) CuAssertIntEquals_LineMsg((tc),__FILE__,__LINE__,NULL,(ex),(ac)) 79 | #define CuAssertIntEquals_Msg(tc,ms,ex,ac) CuAssertIntEquals_LineMsg((tc),__FILE__,__LINE__,(ms),(ex),(ac)) 80 | #define CuAssertDblEquals(tc,ex,ac,dl) CuAssertDblEquals_LineMsg((tc),__FILE__,__LINE__,NULL,(ex),(ac),(dl)) 81 | #define CuAssertDblEquals_Msg(tc,ms,ex,ac,dl) CuAssertDblEquals_LineMsg((tc),__FILE__,__LINE__,(ms),(ex),(ac),(dl)) 82 | #define CuAssertPtrEquals(tc,ex,ac) CuAssertPtrEquals_LineMsg((tc),__FILE__,__LINE__,NULL,(ex),(ac)) 83 | #define CuAssertPtrEquals_Msg(tc,ms,ex,ac) CuAssertPtrEquals_LineMsg((tc),__FILE__,__LINE__,(ms),(ex),(ac)) 84 | 85 | #define CuAssertPtrNotNull(tc,p) CuAssert_Line((tc),__FILE__,__LINE__,"null pointer unexpected",(p != NULL)) 86 | #define CuAssertPtrNotNullMsg(tc,msg,p) CuAssert_Line((tc),__FILE__,__LINE__,(msg),(p != NULL)) 87 | 88 | /* CuSuite */ 89 | 90 | #define MAX_TEST_CASES 1024 91 | 92 | #define SUITE_ADD_TEST(SUITE,TEST) CuSuiteAdd(SUITE, CuTestNew(#TEST, TEST)) 93 | 94 | typedef struct 95 | { 96 | int count; 97 | CuTest* list[MAX_TEST_CASES]; 98 | int failCount; 99 | 100 | } CuSuite; 101 | 102 | 103 | void CuSuiteInit(CuSuite* testSuite); 104 | CuSuite* CuSuiteNew(void); 105 | void CuSuiteAdd(CuSuite* testSuite, CuTest *testCase); 106 | void CuSuiteAddSuite(CuSuite* testSuite, CuSuite* testSuite2); 107 | void CuSuiteRun(CuSuite* testSuite); 108 | void CuSuiteSummary(CuSuite* testSuite, CuString* summary); 109 | void CuSuiteDetails(CuSuite* testSuite, CuString* details); 110 | 111 | #endif /* CU_TEST_H */ 112 | -------------------------------------------------------------------------------- /tests/make-tests.sh: -------------------------------------------------------------------------------- 1 | 2 | #!/bin/bash 3 | 4 | # Auto generate single AllTests file for CuTest. 5 | # Searches through all *.c files in the current directory. 6 | # Prints to stdout. 7 | # Author: Asim Jalis 8 | # Date: 01/08/2003 9 | 10 | FILES=$1 11 | 12 | #if test $# -eq 0 ; then FILES=*.c ; else FILES=$* ; fi 13 | 14 | echo ' 15 | 16 | /* This is auto-generated code. Edit at your own peril. */ 17 | #include 18 | #include "CuTest.h" 19 | 20 | ' 21 | 22 | cat $FILES | grep '^void Test' | 23 | sed -e 's/(.*$//' \ 24 | -e 's/$/(CuTest*);/' \ 25 | -e 's/^/extern /' 26 | 27 | echo \ 28 | ' 29 | 30 | void RunAllTests(void) 31 | { 32 | CuString *output = CuStringNew(); 33 | CuSuite* suite = CuSuiteNew(); 34 | 35 | ' 36 | cat $FILES | grep '^void Test' | 37 | sed -e 's/^void //' \ 38 | -e 's/(.*$//' \ 39 | -e 's/^/ SUITE_ADD_TEST(suite, /' \ 40 | -e 's/$/);/' 41 | 42 | echo \ 43 | ' 44 | CuSuiteRun(suite); 45 | CuSuiteSummary(suite, output); 46 | CuSuiteDetails(suite, output); 47 | printf("%s\\n", output->buffer); 48 | } 49 | 50 | int main() 51 | { 52 | RunAllTests(); 53 | return 0; 54 | } 55 | ' 56 | -------------------------------------------------------------------------------- /tests/test_bitstream.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "CuTest.h" 3 | #include 4 | #include "bitstream.h" 5 | #include 6 | 7 | void Test_WriteBitIncreasesBitOffset( 8 | CuTest * tc 9 | ) 10 | { 11 | char bits[1000]; 12 | char *cptr_write; 13 | unsigned int bo; 14 | 15 | bo = 0; 16 | cptr_write = &bits[0]; 17 | bitstream_init(bits, 1000); 18 | 19 | bitstream_write_bit_from_bitoffset(&cptr_write, 1, &bo); 20 | CuAssertTrue(tc, 1 == bo); 21 | } 22 | 23 | void Test_ReadBitNothing( 24 | CuTest * tc 25 | ) 26 | { 27 | char bits[1000]; 28 | char *cptr_write, *cptr_read; 29 | unsigned int bo; 30 | 31 | cptr_write = &bits[0]; 32 | cptr_read = &bits[0]; 33 | 34 | bitstream_init(bits, 1000); 35 | bo = 0; 36 | CuAssertTrue(tc, 0 == bitstream_read_bit(&cptr_read, &bo)); 37 | } 38 | 39 | void Test_ReadBit( 40 | CuTest * tc 41 | ) 42 | { 43 | char bits[1000]; 44 | unsigned int bo; 45 | 46 | char *cptr_write = &bits[0]; 47 | char *cptr_read = &bits[0]; 48 | bitstream_init(bits, 1000); 49 | 50 | bo = 0; 51 | bitstream_write_bit_from_bitoffset(&cptr_write, 0, &bo); 52 | bitstream_write_bit_from_bitoffset(&cptr_write, 0, &bo); 53 | bitstream_write_bit_from_bitoffset(&cptr_write, 0, &bo); 54 | bitstream_write_bit_from_bitoffset(&cptr_write, 0, &bo); 55 | bitstream_write_bit_from_bitoffset(&cptr_write, 0, &bo); 56 | bitstream_write_bit_from_bitoffset(&cptr_write, 1, &bo); 57 | bitstream_write_bit_from_bitoffset(&cptr_write, 0, &bo); 58 | bitstream_write_bit_from_bitoffset(&cptr_write, 1, &bo); 59 | 60 | bo = 0; 61 | CuAssertTrue(tc, 0 == bitstream_read_bit(&cptr_read, &bo)); 62 | CuAssertTrue(tc, 0 == bitstream_read_bit(&cptr_read, &bo)); 63 | CuAssertTrue(tc, 0 == bitstream_read_bit(&cptr_read, &bo)); 64 | CuAssertTrue(tc, 0 == bitstream_read_bit(&cptr_read, &bo)); 65 | CuAssertTrue(tc, 0 == bitstream_read_bit(&cptr_read, &bo)); 66 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read, &bo)); 67 | CuAssertTrue(tc, 0 == bitstream_read_bit(&cptr_read, &bo)); 68 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read, &bo)); 69 | } 70 | 71 | void Test_WriteBit( 72 | CuTest * tc 73 | ) 74 | { 75 | char bits[1000]; 76 | unsigned int bo; 77 | 78 | char *cptr_write = &bits[0]; 79 | char *cptr_read = &bits[0]; 80 | bitstream_init(bits, 1000); 81 | 82 | bo = 0; 83 | bitstream_write_bit_from_bitoffset(&cptr_write, 1, &bo); 84 | bitstream_write_bit_from_bitoffset(&cptr_write, 0, &bo); 85 | bitstream_write_bit_from_bitoffset(&cptr_write, 1, &bo); 86 | 87 | bo = 0; 88 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read,&bo)); 89 | CuAssertTrue(tc, 0 == bitstream_read_bit(&cptr_read,&bo)); 90 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read,&bo)); 91 | } 92 | 93 | void Test_ReadUByteWithNothingResultsInZero( 94 | CuTest * tc 95 | ) 96 | { 97 | char num[10]; 98 | 99 | memset(num, 0, sizeof(char) * 10); 100 | char *cptr_read = &num[0]; 101 | 102 | CuAssertTrue(tc, 0 == bitstream_read_byte(&cptr_read)); 103 | } 104 | 105 | void Test_UbyteWriteAndRead( 106 | CuTest * tc 107 | ) 108 | { 109 | char num[10]; 110 | memset(num, 0, sizeof(char) * 10); 111 | char *cptr_write = &num[0]; 112 | char *cptr_read = &num[0]; 113 | 114 | bitstream_write_byte(&cptr_write, 0x0FF); 115 | CuAssertTrue(tc, 0x0FF == (unsigned char)bitstream_read_byte(&cptr_read)); 116 | 117 | unsigned int bo = 0; 118 | cptr_read = &num[0]; 119 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read, &bo)); 120 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read, &bo)); 121 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read, &bo)); 122 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read, &bo)); 123 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read, &bo)); 124 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read, &bo)); 125 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read, &bo)); 126 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read, &bo)); 127 | } 128 | 129 | void Test_UbyteWriteAndRead2( 130 | CuTest * tc 131 | ) 132 | { 133 | char num[10]; 134 | memset(num, 0, sizeof(char) * 10); 135 | char *cptr_write = &num[0]; 136 | char *cptr_read = &num[0]; 137 | 138 | bitstream_write_byte(&cptr_write, 0x05); 139 | CuAssertTrue(tc, 0x05 == bitstream_read_byte(&cptr_read)); 140 | } 141 | 142 | void Test_UbyteWriteWith4BitOffset( 143 | CuTest * tc 144 | ) 145 | { 146 | char num[10]; 147 | unsigned int bo; 148 | 149 | memset(num, 0, sizeof(char) * 10); 150 | char *cptr_write = &num[0]; 151 | char *cptr_read = &num[0]; 152 | 153 | bitstream_write_byte(&cptr_write, 0xFF); 154 | CuAssertTrue(tc, 0xFF == (unsigned char)bitstream_read_byte(&cptr_read)); 155 | 156 | bo = 4; 157 | cptr_write = &num[0]; 158 | bitstream_write_byte_from_bitoffset(&cptr_write, 0x0, &bo); 159 | cptr_read = &num[0]; 160 | bo = 0; 161 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read, &bo)); 162 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read, &bo)); 163 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read, &bo)); 164 | CuAssertTrue(tc, 1 == bitstream_read_bit(&cptr_read, &bo)); 165 | CuAssertTrue(tc, 0 == bitstream_read_bit(&cptr_read, &bo)); 166 | CuAssertTrue(tc, 0 == bitstream_read_bit(&cptr_read, &bo)); 167 | CuAssertTrue(tc, 0 == bitstream_read_bit(&cptr_read, &bo)); 168 | CuAssertTrue(tc, 0 == bitstream_read_bit(&cptr_read, &bo)); 169 | 170 | cptr_read = &num[0]; 171 | CuAssertTrue(tc, 0xF0 == (unsigned char)bitstream_read_byte(&cptr_read)); 172 | CuAssertTrue(tc, 0x00 == bitstream_read_byte(&cptr_read)); 173 | } 174 | 175 | void Test_UbyteWriteWith8BitOffset( 176 | CuTest * tc 177 | ) 178 | { 179 | char num[10]; 180 | memset(num, 0, sizeof(char) * 10); 181 | char *cptr_write = &num[0]; 182 | char *cptr_read = &num[0]; 183 | 184 | bitstream_write_byte(&cptr_write, 0x05); 185 | unsigned int bo = 8; 186 | cptr_write = &num[0]; 187 | bitstream_write_byte_from_bitoffset(&cptr_write, 0xAF, &bo); 188 | CuAssertTrue(tc, 0x05 == (unsigned char)bitstream_read_byte(&cptr_read)); 189 | CuAssertTrue(tc, 0xAF == (unsigned char)bitstream_read_byte(&cptr_read)); 190 | } 191 | 192 | void Test_Uint32WriteRead( 193 | CuTest * tc 194 | ) 195 | { 196 | char num[10]; 197 | char *cptr_write, *cptr_read; 198 | 199 | memset(num, 0, sizeof(char) * 10); 200 | cptr_write = &num[0]; 201 | cptr_read = &num[0]; 202 | 203 | bitstream_write_uint32(&cptr_write, 0x0F070301); 204 | CuAssertTrue(tc, 0x0F070301 == bitstream_read_uint32(&cptr_read)); 205 | } 206 | 207 | void Test_MiscWriteRead( 208 | CuTest * tc 209 | ) 210 | { 211 | char num[10]; 212 | char *cptr_write, *cptr_read; 213 | char cval; 214 | uint32_t ival; 215 | 216 | memset(num, 0, sizeof(char) * 10); 217 | cptr_write = &num[0]; 218 | cptr_read = &num[0]; 219 | 220 | bitstream_write_byte(&cptr_write, 0xFF); 221 | bitstream_write_uint32(&cptr_write, 0x0F070301); 222 | bitstream_write_byte(&cptr_write, 0xFF); 223 | cval = bitstream_read_byte(&cptr_read); 224 | CuAssertTrue(tc, (unsigned char)cval == 0xFF); 225 | ival = bitstream_read_uint32(&cptr_read); 226 | CuAssertTrue(tc, ival == 0x0F070301); 227 | cval = bitstream_read_byte(&cptr_read); 228 | CuAssertTrue(tc, (unsigned char)cval == 0xFF); 229 | } 230 | 231 | void Test_WriteFirstUint32( 232 | CuTest * tc 233 | ) 234 | { 235 | char bits[1000]; 236 | uint32_t val; 237 | char *cptr_write, *cptr_read; 238 | unsigned int bo; 239 | 240 | cptr_write = &bits[0]; 241 | cptr_read = &bits[0]; 242 | bitstream_init(bits, 1000); 243 | 244 | bo = 0; 245 | bitstream_write_uint32_from_bitoffset(&cptr_write, 9, 32, &bo); 246 | CuAssertTrue(tc, bo == 32); 247 | 248 | bo = 0; 249 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 32, &bo); 250 | CuAssertTrue(tc, bo == 32); 251 | CuAssertTrue(tc, val == 9); 252 | } 253 | 254 | void Test_WriteFirstUint32II( 255 | CuTest * tc 256 | ) 257 | { 258 | char bits[1000]; 259 | uint32_t val; 260 | char *cptr_write, *cptr_read; 261 | unsigned int bo; 262 | 263 | cptr_write = &bits[0]; 264 | cptr_read = &bits[0]; 265 | bitstream_init(bits, 1000); 266 | 267 | bo = 0; 268 | bitstream_write_uint32_from_bitoffset(&cptr_write, 32768, 32, &bo); 269 | 270 | bo = 0; 271 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 32, &bo); 272 | CuAssertTrue(tc, val == 32768); 273 | } 274 | 275 | void Test_WriteTwo( 276 | CuTest * tc 277 | ) 278 | { 279 | char bits[1000]; 280 | uint32_t val; 281 | char *cptr_write, *cptr_read; 282 | unsigned int bo; 283 | 284 | cptr_write = &bits[0]; 285 | cptr_read = &bits[0]; 286 | bitstream_init(bits, 1000); 287 | 288 | bo = 0; 289 | bitstream_write_uint32_from_bitoffset(&cptr_write, 32768, 16,&bo); 290 | bitstream_write_uint32_from_bitoffset(&cptr_write, 255, 16,&bo); 291 | 292 | bo = 0; 293 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 16, &bo); 294 | CuAssertTrue(tc, val == 32768); 295 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 16, &bo); 296 | CuAssertTrue(tc, val == 255); 297 | } 298 | 299 | void Test_WriteThree( 300 | CuTest * tc 301 | ) 302 | { 303 | char bits[1000]; 304 | uint32_t val; 305 | char *cptr_write, *cptr_read; 306 | unsigned int bo; 307 | 308 | cptr_write = &bits[0]; 309 | cptr_read = &bits[0]; 310 | bitstream_init(bits, 1000); 311 | 312 | bo = 0; 313 | bitstream_write_uint32_from_bitoffset(&cptr_write, 32768, 16,&bo); 314 | bitstream_write_uint32_from_bitoffset(&cptr_write, 255, 8,&bo); 315 | bitstream_write_uint32_from_bitoffset(&cptr_write, 138, 8,&bo); 316 | 317 | bo = 0; 318 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 16, &bo); 319 | CuAssertTrue(tc, val == 32768); 320 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 8, &bo); 321 | CuAssertTrue(tc, val == 255); 322 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 8, &bo); 323 | CuAssertTrue(tc, val == 138); 324 | } 325 | 326 | void Test_WriteFive( 327 | CuTest * tc 328 | ) 329 | { 330 | char bits[1000]; 331 | uint32_t val; 332 | char *cptr_write, *cptr_read; 333 | unsigned int bo; 334 | 335 | cptr_write = &bits[0]; 336 | cptr_read = &bits[0]; 337 | 338 | bitstream_init(bits, 1000); 339 | 340 | bo = 0; 341 | bitstream_write_uint32_from_bitoffset(&cptr_write, 230, 9,&bo); 342 | bitstream_write_uint32_from_bitoffset(&cptr_write, 255, 9,&bo); 343 | bitstream_write_uint32_from_bitoffset(&cptr_write, 31, 5,&bo); 344 | bitstream_write_uint32_from_bitoffset(&cptr_write, 17, 6,&bo); 345 | bitstream_write_uint32_from_bitoffset(&cptr_write, 2, 3,&bo); 346 | 347 | bo = 0; 348 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 9, &bo); 349 | CuAssertTrue(tc, val == 230); 350 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 9, &bo); 351 | CuAssertTrue(tc, val == 255); 352 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 5, &bo); 353 | CuAssertTrue(tc, val == 31); 354 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 6, &bo); 355 | CuAssertTrue(tc, val == 17); 356 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 3, &bo); 357 | CuAssertTrue(tc, val == 2); 358 | } 359 | 360 | void Test_WriteCrossBoundary( 361 | CuTest * tc 362 | ) 363 | { 364 | char bits[1000]; 365 | uint32_t val; 366 | char *cptr_write, *cptr_read; 367 | unsigned int bo; 368 | 369 | cptr_write = &bits[0]; 370 | cptr_read = &bits[0]; 371 | 372 | bitstream_init(bits, 1000); 373 | 374 | bo = 0; 375 | bitstream_write_uint32_from_bitoffset(&cptr_write, 230, 18,&bo); 376 | bitstream_write_uint32_from_bitoffset(&cptr_write, 32333, 32,&bo); 377 | 378 | bo = 0; 379 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 18, &bo); 380 | CuAssertTrue(tc, val == 230); 381 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 32, &bo); 382 | CuAssertTrue(tc, val == 32333); 383 | } 384 | 385 | void Test_WriteCrossBoundaryII( 386 | CuTest * tc 387 | ) 388 | { 389 | char bits[1000]; 390 | uint32_t val; 391 | char *cptr_write, *cptr_read; 392 | unsigned int bo; 393 | 394 | cptr_write = &bits[0]; 395 | cptr_read = &bits[0]; 396 | 397 | bitstream_init(bits, 1000); 398 | 399 | bo = 0; 400 | bitstream_write_uint32_from_bitoffset(&cptr_write, 230, 17,&bo); 401 | bitstream_write_uint32_from_bitoffset(&cptr_write, 2888, 17,&bo); 402 | bitstream_write_uint32_from_bitoffset(&cptr_write, 32678, 32,&bo); 403 | 404 | bo = 0; 405 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 17, &bo); 406 | CuAssertTrue(tc, val == 230); 407 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 17, &bo); 408 | CuAssertTrue(tc, val == 2888); 409 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 32, &bo); 410 | CuAssertTrue(tc, val == 32678); 411 | } 412 | 413 | void Test_WriteCrossBoundaryIII( 414 | CuTest * tc 415 | ) 416 | { 417 | char bits[1000]; 418 | uint32_t val; 419 | char *cptr_write, *cptr_read; 420 | unsigned int bo; 421 | 422 | cptr_write = &bits[0]; 423 | cptr_read = &bits[0]; 424 | 425 | bitstream_init(bits, 1000); 426 | 427 | bo = 0; 428 | bitstream_write_uint32_from_bitoffset(&cptr_write, 23000, 29,&bo); 429 | bitstream_write_uint32_from_bitoffset(&cptr_write, 288800, 30,&bo); 430 | bitstream_write_uint32_from_bitoffset(&cptr_write, 31678, 21,&bo); 431 | 432 | bo = 0; 433 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 29, &bo); 434 | CuAssertTrue(tc, val == 23000); 435 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 30, &bo); 436 | CuAssertTrue(tc, val == 288800); 437 | bitstream_read_uint32_from_bitoffset(&cptr_read, &val, 21, &bo); 438 | CuAssertTrue(tc, val == 31678); 439 | } 440 | 441 | void Test_WriteString( 442 | CuTest * tc 443 | ) 444 | { 445 | char output[100]; 446 | char bits[1000]; 447 | char *cptr_write, *cptr_read; 448 | 449 | cptr_write = &bits[0]; 450 | cptr_read = &bits[0]; 451 | 452 | bitstream_init(bits, 1000); 453 | 454 | bitstream_write_string(&cptr_write, "testing", strlen("testing")); 455 | 456 | bitstream_read_string(&cptr_read, output, strlen("testing")); 457 | CuAssertTrue(tc, 0 == strncmp(output,"testing",strlen("testing"))); 458 | } 459 | --------------------------------------------------------------------------------