TEST(String, SplitShell) { char **argv; int argc; POINTERS_EQUAL(NULL, string_split_shell (NULL, NULL)); /* test with an empty string */ argc = -1; argv = string_split_shell ("", &argc); LONGS_EQUAL(0, argc); CHECK(argv); POINTERS_EQUAL(NULL, argv[0]); string_free_split (argv); /* test with a real string (command + arguments) */ argv = string_split_shell ("/path/to/bin arg1 \"arg2 here\" 'arg3 here'", &argc); LONGS_EQUAL(4, argc); CHECK(argv); STRCMP_EQUAL("/path/to/bin", argv[0]); STRCMP_EQUAL("arg1", argv[1]); STRCMP_EQUAL("arg2 here", argv[2]); STRCMP_EQUAL("arg3 here", argv[3]); POINTERS_EQUAL(NULL, argv[4]); string_free_split (argv); /* free split with NULL */ string_free_split_shared (NULL); }
TEST(RandomClass, CreateXOrShiftObject) { Random* pRandom; uint32_t nResult = 0; pRandom = random_new(setXorShiftSeed, nextXorShiftUInt32); POINTERS_EQUAL(setXorShiftSeed, pRandom->setSeed); POINTERS_EQUAL(nextXorShiftUInt32, pRandom->getNextUInt32); }
TEST(TestMemoryAllocatorTest, SetCurrentMallocAllocator) { allocator = new TestMemoryAllocator("malloc_allocator"); setCurrentMallocAllocator(allocator); POINTERS_EQUAL(allocator, getCurrentMallocAllocator()); setCurrentMallocAllocatorToDefault(); POINTERS_EQUAL(defaultMallocAllocator(), getCurrentMallocAllocator()); }
TEST(MockSupport_c, whenReturnValueIsGivenReturnConstPointerValueOrDefaultShouldIgnoreTheDefault) { const void* defaultValue = (void*) 10; const void* expectedValue = (void*) 27; mock_c()->expectOneCall("foo")->andReturnConstPointerValue(expectedValue); POINTERS_EQUAL(expectedValue, mock_c()->actualCall("foo")->returnConstPointerValueOrDefault(defaultValue)); POINTERS_EQUAL(expectedValue, mock_c()->returnConstPointerValueOrDefault(defaultValue)); }
TEST(TestMemoryAllocatorTest, SetCurrentNewArrayAllocator) { allocator = new TestMemoryAllocator("new array allocator for test"); setCurrentNewArrayAllocator(allocator); POINTERS_EQUAL(allocator, getCurrentNewArrayAllocator()); setCurrentNewArrayAllocatorToDefault(); POINTERS_EQUAL(defaultNewArrayAllocator(), getCurrentNewArrayAllocator()); }
TEST(HttpdSingletonTestGroup, Instantiate) { HttpdSingleton *Httpd = HttpdSingleton::Instantiate(); CHECK(Httpd != NULL); POINTERS_EQUAL(Httpd, HttpdSingleton::Instantiate()); POINTERS_EQUAL(Httpd, HttpdSingleton::Instantiate()); HttpdSingleton::Instantiate(false); };
TEST(HttpdSingletonTestGroup, StartStop) { CHECK(HttpdSingleton::Instantiate() != NULL); POINTERS_EQUAL(NULL, HttpdSingleton::Instantiate(false)); CHECK(HttpdSingleton::Instantiate() != NULL); POINTERS_EQUAL(NULL, HttpdSingleton::Instantiate(false)); POINTERS_EQUAL(NULL, HttpdSingleton::Instantiate(false)); CHECK(HttpdSingleton::Instantiate() != NULL); POINTERS_EQUAL(NULL, HttpdSingleton::Instantiate(false)); };
TEST(String, Strip) { POINTERS_EQUAL(NULL, string_strip (NULL, 1, 1, NULL)); POINTERS_EQUAL(NULL, string_strip (NULL, 1, 1, ".;")); STRCMP_EQUAL("test", string_strip ("test", 1, 1, NULL)); STRCMP_EQUAL("test", string_strip ("test", 1, 1, ".;")); STRCMP_EQUAL(".-test.-", string_strip (".-test.-", 0, 0, ".-")); STRCMP_EQUAL("test", string_strip (".-test.-", 1, 1, ".-")); STRCMP_EQUAL("test.-", string_strip (".-test.-", 1, 0, ".-")); STRCMP_EQUAL(".-test", string_strip (".-test.-", 0, 1, ".-")); }
TEST(MockNamedValueComparatorRepository, installMultipleComparator) { TypeForTestingExpectedFunctionCallComparator comparator1, comparator2, comparator3; MockNamedValueComparatorRepository repository; repository.installComparator("type1", comparator1); repository.installComparator("type2", comparator2); repository.installComparator("type3", comparator3); POINTERS_EQUAL(&comparator3, repository.getComparatorForType("type3")); POINTERS_EQUAL(&comparator2, repository.getComparatorForType("type2")); POINTERS_EQUAL(&comparator1, repository.getComparatorForType("type1")); }
TEST(CircularBuffer, shouldHaveGetAndIncrementFunction) { uint16_t *buf = (uint16_t*) malloc(sizeof(uint16_t)*4); CircularBuffer cb = CircularBuffer_New(buf, 4, 2); POINTERS_EQUAL( CircularBuffer_GetNextBuffer( cb ), buf ); POINTERS_EQUAL( CircularBuffer_GetNextBuffer( cb ), buf+2 ); free( buf ); free( cb ); }
TEST(CircularBuffer, shouldSupportLargeSplit) { uint16_t *buf = (uint16_t*) malloc(sizeof(uint16_t)*16); CircularBuffer cb = CircularBuffer_New( buf, 16, 4); POINTERS_EQUAL( CircularBuffer_GetNextBuffer( cb ), buf ); POINTERS_EQUAL( CircularBuffer_GetNextBuffer( cb ), buf+4 ); POINTERS_EQUAL( CircularBuffer_GetNextBuffer( cb ), buf+8 ); POINTERS_EQUAL( CircularBuffer_GetNextBuffer( cb ), buf+12 ); POINTERS_EQUAL( CircularBuffer_GetNextBuffer( cb ), buf ); free( buf ); free( cb ); }
TEST(String, RemoveQuotes) { POINTERS_EQUAL(NULL, string_remove_quotes (NULL, NULL)); POINTERS_EQUAL(NULL, string_remove_quotes (NULL, "abc")); POINTERS_EQUAL(NULL, string_remove_quotes ("abc", NULL)); STRCMP_EQUAL("", string_remove_quotes("", "")); STRCMP_EQUAL("", string_remove_quotes("", "\"'")); STRCMP_EQUAL("abc", string_remove_quotes("abc", "\"'")); STRCMP_EQUAL(" abc ", string_remove_quotes(" abc ", "\"'")); STRCMP_EQUAL("abc", string_remove_quotes("'abc'", "\"'")); STRCMP_EQUAL("abc", string_remove_quotes(" 'abc' ", "\"'")); STRCMP_EQUAL("'abc'", string_remove_quotes("\"'abc'\"", "\"'")); STRCMP_EQUAL("'abc'", string_remove_quotes(" \"'abc'\" ", "\"'")); STRCMP_EQUAL("'a'b'c'", string_remove_quotes("\"'a'b'c'\"", "\"'")); STRCMP_EQUAL("'a'b'c'", string_remove_quotes(" \"'a'b'c'\" ", "\"'")); }
static int functionThatReturnsAValue() { CHECK(0 == 0); CHECK_TEXT(0 == 0, "Shouldn't fail"); CHECK_TRUE(0 == 0); CHECK_TRUE_TEXT(0 == 0, "Shouldn't fail"); CHECK_FALSE(0 != 0); CHECK_FALSE_TEXT(0 != 0, "Shouldn't fail"); LONGS_EQUAL(1,1); LONGS_EQUAL_TEXT(1, 1, "Shouldn't fail"); BYTES_EQUAL(0xab,0xab); BYTES_EQUAL_TEXT(0xab, 0xab, "Shouldn't fail"); CHECK_EQUAL(100,100); CHECK_EQUAL_TEXT(100, 100, "Shouldn't fail"); STRCMP_EQUAL("THIS", "THIS"); STRCMP_EQUAL_TEXT("THIS", "THIS", "Shouldn't fail"); DOUBLES_EQUAL(1.0, 1.0, .01); DOUBLES_EQUAL_TEXT(1.0, 1.0, .01, "Shouldn't fail"); POINTERS_EQUAL(0, 0); POINTERS_EQUAL_TEXT(0, 0, "Shouldn't fail"); MEMCMP_EQUAL("THIS", "THIS", 5); MEMCMP_EQUAL_TEXT("THIS", "THIS", 5, "Shouldn't fail"); BITS_EQUAL(0x01, (unsigned char )0x01, 0xFF); BITS_EQUAL(0x0001, (unsigned short )0x0001, 0xFFFF); BITS_EQUAL(0x00000001, (unsigned long )0x00000001, 0xFFFFFFFF); BITS_EQUAL_TEXT(0x01, (unsigned char )0x01, 0xFF, "Shouldn't fail"); return 0; }
TEST(MockNamedValueHandlerRepository, installCopier) { TypeForTestingExpectedFunctionCallCopier copier; MockNamedValueComparatorsAndCopiersRepository repository; repository.installCopier("typeName", copier); POINTERS_EQUAL(&copier, repository.getCopierForType("typeName")); }
TEST(String, Duplicate) { const char *str_test = "test"; char *str; POINTERS_EQUAL(NULL, string_strndup (NULL, 0)); str = string_strndup (str_test, 0); CHECK(str); CHECK(str != str_test); STRCMP_EQUAL(str, ""); free (str); str = string_strndup (str_test, 2); CHECK(str); CHECK(str != str_test); STRCMP_EQUAL(str, "te"); free (str); str = string_strndup (str_test, 500); CHECK(str); CHECK(str != str_test); STRCMP_EQUAL(str, str_test); free (str); }
TEST(MockNamedValueComparatorRepository, installComparator) { TypeForTestingExpectedFunctionCallComparator comparator; MockNamedValueComparatorRepository repository; repository.installComparator("typeName", comparator); POINTERS_EQUAL(&comparator, repository.getComparatorForType("typeName")); }
TEST(String, ConvertEscapedChars) { POINTERS_EQUAL(NULL, string_convert_escaped_chars (NULL)); STRCMP_EQUAL("", string_convert_escaped_chars ("")); STRCMP_EQUAL("\"", string_convert_escaped_chars ("\\\"")); STRCMP_EQUAL("\\", string_convert_escaped_chars ("\\\\")); STRCMP_EQUAL("\a", string_convert_escaped_chars ("\\a")); STRCMP_EQUAL("\a", string_convert_escaped_chars ("\\a")); STRCMP_EQUAL("\b", string_convert_escaped_chars ("\\b")); STRCMP_EQUAL("\e", string_convert_escaped_chars ("\\e")); STRCMP_EQUAL("\f", string_convert_escaped_chars ("\\f")); STRCMP_EQUAL("\n", string_convert_escaped_chars ("\\n")); STRCMP_EQUAL("\r", string_convert_escaped_chars ("\\r")); STRCMP_EQUAL("\t", string_convert_escaped_chars ("\\t")); STRCMP_EQUAL("\v", string_convert_escaped_chars ("\\v")); STRCMP_EQUAL("\123", string_convert_escaped_chars ("\\0123")); STRCMP_EQUAL("\123", string_convert_escaped_chars ("\\0123")); /* invalid */ STRCMP_EQUAL("\x41", string_convert_escaped_chars ("\\x41")); STRCMP_EQUAL("\x04z", string_convert_escaped_chars ("\\x4z")); STRCMP_EQUAL("\u0012zz", string_convert_escaped_chars ("\\u12zz")); STRCMP_EQUAL("\U00123456", string_convert_escaped_chars ("\\U00123456")); STRCMP_EQUAL("\U00000123zzz", string_convert_escaped_chars ("\\U00123zzz")); STRCMP_EQUAL("", string_convert_escaped_chars ("\\U12345678")); /* invalid */ }
TEST(String, Shared) { const char *str1, *str2, *str3; int count; count = string_hashtable_shared->items_count; str1 = string_shared_get ("this is a test"); CHECK(str1); LONGS_EQUAL(count + 1, string_hashtable_shared->items_count); str2 = string_shared_get ("this is a test"); CHECK(str2); POINTERS_EQUAL(str1, str2); LONGS_EQUAL(count + 1, string_hashtable_shared->items_count); str3 = string_shared_get ("this is another test"); CHECK(str3); CHECK(str1 != str3); CHECK(str2 != str3); LONGS_EQUAL(count + 2, string_hashtable_shared->items_count); string_shared_free (str1); LONGS_EQUAL(count + 2, string_hashtable_shared->items_count); string_shared_free (str2); LONGS_EQUAL(count + 1, string_hashtable_shared->items_count); string_shared_free (str3); LONGS_EQUAL(count + 0, string_hashtable_shared->items_count); }
TEST(MemoryLeakWarningLocalDetectorTest, localDetectorIsGlobalDetector) { MemoryLeakDetector* globalDetector = MemoryLeakWarningPlugin::getGlobalDetector(); MemoryLeakWarningPlugin memoryLeakWarningPlugin("TestMemoryLeakWarningPlugin", NULL); MemoryLeakDetector* localDetector = memoryLeakWarningPlugin.getMemoryLeakDetector(); POINTERS_EQUAL(globalDetector, localDetector); }
TEST(SimpleString, copyInBufferWithEmptyBuffer) { SimpleString str("Hello World"); char* buffer= NULL; str.copyToBuffer(buffer, 0); POINTERS_EQUAL(NULL, buffer); }
void assertHasAdcEvent() { EventType *adcEventType = AdcEventType_get(); Event *event = EventSource_poll(_eventSource); CHECK( event != NULL); POINTERS_EQUAL(adcEventType, Event_getEventType(event)); }
/* START: nullInterfaceTest */ TEST(LightDriver, NullInterfaceDoesNotCrash) { LightDriver_SetInterface(NULL); LightDriver_TurnOn(&testDriver); LightDriver_TurnOff(&testDriver); LightDriver_Destroy(&testDriver); POINTERS_EQUAL(NONSENSE_POINTER, savedDriver); }
TEST(CallStackTestGroup, GetNameBigLevel) { CallStack TestCallStack; TestSuiteUnwind5(TestCallStack); POINTERS_EQUAL(NULL, TestCallStack.GetName(300000)); };
TEST(String, Replace) { regex_t regex; char *result; /* basic replace */ POINTERS_EQUAL(NULL, string_replace (NULL, NULL, NULL)); POINTERS_EQUAL(NULL, string_replace ("string", NULL, NULL)); POINTERS_EQUAL(NULL, string_replace (NULL, "search", NULL)); POINTERS_EQUAL(NULL, string_replace (NULL, NULL, "replace")); POINTERS_EQUAL(NULL, string_replace ("string", "search", NULL)); POINTERS_EQUAL(NULL, string_replace ("string", NULL, "replace")); POINTERS_EQUAL(NULL, string_replace (NULL, "search", "replace")); STRCMP_EQUAL("test abc def", string_replace("test abc def", "xyz", "xxx")); STRCMP_EQUAL("test xxx def", string_replace("test abc def", "abc", "xxx")); STRCMP_EQUAL("xxx test xxx def xxx", string_replace("abc test abc def abc", "abc", "xxx")); /* replace with regex */ WEE_REPLACE_REGEX(-1, NULL, NULL, NULL, NULL, '$', NULL); WEE_REPLACE_REGEX(0, NULL, NULL, "", NULL, '$', NULL); WEE_REPLACE_REGEX(0, "string", "string", "", NULL, '$', NULL); WEE_REPLACE_REGEX(0, "test abc def", "test abc def", "xyz", "xxx", '$', NULL); WEE_REPLACE_REGEX(0, "test xxx def", "test abc def", "abc", "xxx", '$', NULL); WEE_REPLACE_REGEX(0, "foo", "test foo", "^(test +)(.*)", "$2", '$', NULL); WEE_REPLACE_REGEX(0, "test / ***", "test foo", "^(test +)(.*)", "$1/ $.*2", '$', NULL); WEE_REPLACE_REGEX(0, "%%%", "test foo", "^(test +)(.*)", "$.%+", '$', NULL); /* replace with a callback */ /* TODO: write tests for string_replace_with_callback */ }
void validateNullTokenPointers() { size_t i; for (i = 0 ; i < ARRAY_SIZE(m_token.tokenPointers) ; i++) { POINTERS_EQUAL( NULL, m_token.tokenPointers[i] ); } }
TEST(String, SplitCommand) { char **argv; POINTERS_EQUAL(NULL, string_split_command (NULL, ';')); POINTERS_EQUAL(NULL, string_split_command ("", ';')); argv = string_split_command ("abc;de;fghi", ';'); CHECK(argv); STRCMP_EQUAL("abc", argv[0]); STRCMP_EQUAL("de", argv[1]); STRCMP_EQUAL("fghi", argv[2]); POINTERS_EQUAL(NULL, argv[3]); string_free_split_command (argv); /* free split with NULL */ string_free_split_command (NULL); }
TEST(Utf8, Validity) { char *error; /* check 8 bits */ LONGS_EQUAL(0, utf8_has_8bits (NULL)); LONGS_EQUAL(0, utf8_has_8bits ("")); LONGS_EQUAL(0, utf8_has_8bits ("abc")); LONGS_EQUAL(1, utf8_has_8bits ("no\xc3\xabl")); /* check validity */ LONGS_EQUAL(1, utf8_is_valid (NULL, NULL)); LONGS_EQUAL(1, utf8_is_valid (NULL, &error)); LONGS_EQUAL(1, utf8_is_valid ("", NULL)); LONGS_EQUAL(1, utf8_is_valid ("", &error)); LONGS_EQUAL(1, utf8_is_valid ("abc", &error)); POINTERS_EQUAL(NULL, error); LONGS_EQUAL(1, utf8_is_valid (noel_valid, &error)); POINTERS_EQUAL(NULL, error); LONGS_EQUAL(0, utf8_is_valid (noel_invalid, &error)); POINTERS_EQUAL(noel_invalid + 2, error); /* 2 bytes: code point must be in range U+0080-07FF */ LONGS_EQUAL(0, utf8_is_valid ("\xc0\x80", NULL)); /* U+0 */ LONGS_EQUAL(0, utf8_is_valid ("\xc1\xbf", NULL)); /* U+7F */ LONGS_EQUAL(1, utf8_is_valid ("\xc2\x80", NULL)); /* U+80 */ LONGS_EQUAL(1, utf8_is_valid ("\xdf\xbf", NULL)); /* U+7FF */ /* 3 bytes: code point must be in range: U+0800-FFFF */ LONGS_EQUAL(0, utf8_is_valid ("\xe0\x80\x80", NULL)); /* U+0 */ LONGS_EQUAL(0, utf8_is_valid ("\xe0\x9f\xbf", NULL)); /* U+7FF */ LONGS_EQUAL(0, utf8_is_valid ("\xed\xa0\x80", NULL)); /* U+D800 */ LONGS_EQUAL(0, utf8_is_valid ("\xed\xbf\xbf", NULL)); /* U+DFFF */ LONGS_EQUAL(1, utf8_is_valid ("\xe0\xa0\x80", NULL)); /* U+800 */ LONGS_EQUAL(1, utf8_is_valid ("\xed\x9f\xbf", NULL)); /* U+D7FF */ LONGS_EQUAL(1, utf8_is_valid ("\xe7\x80\x80", NULL)); /* U+E000 */ LONGS_EQUAL(1, utf8_is_valid ("\xef\xbf\xbf", NULL)); /* U+FFFF */ /* 4 bytes: code point must be in range: U+10000-1FFFFF */ LONGS_EQUAL(0, utf8_is_valid ("\xf0\x80\x80\x80", NULL)); /* U+0 */ LONGS_EQUAL(0, utf8_is_valid ("\xf0\x8f\xbf\xbf", NULL)); /* U+FFFF */ LONGS_EQUAL(1, utf8_is_valid ("\xf0\x90\x80\x80", NULL)); /* U+10000 */ LONGS_EQUAL(1, utf8_is_valid ("\xf7\xbf\xbf\xbf", NULL)); /* U+1FFFFF */ }
TEST(TrajectoryInitTestGroup, CanInitChunk) { trajectory_chunk_t chunk; trajectory_chunk_init(&chunk, (float *)buffer, 3, 2, 100, 10); POINTERS_EQUAL((float *)buffer, chunk.buffer); CHECK_EQUAL(3, chunk.length); CHECK_EQUAL(2, chunk.dimension); CHECK_EQUAL(100, (int)chunk.start_time_us); CHECK_EQUAL(10, (int)chunk.sampling_time_us); }
TEST(TLVDecoder, ParseTlv1DataSuccessfully) { Tlv_t tlv; // parse CHECK(TlvParse(tlv1Data, sizeof(tlv1Data), &tlv)); // encoding tlv object in the buffer POINTERS_EQUAL(tlv1Data, TlvPtr(&tlv)); // tag class LONGS_EQUAL(TAG_CLASS_APP, TagTagClass(&tlv.tag)); // Primitive or constructed CHECK(TagIsPorC(&tlv.tag)); // tag number LONGS_EQUAL(0x10, TagTagNum(&tlv.tag)); // length LONGS_EQUAL(0x43, TlvDataLen(&tlv)); // value POINTERS_EQUAL(&tlv1Data[2], TlvValue(&tlv)); LONGS_EQUAL(TlvDataLen(&tlv), TlvDataCapacity(&tlv)); }
TEST(filter, create_fail_invalid_closing_brackets){ char * filter_str; filter_pt get_filter; //test missing closing brackets in substring mock().expectNCalls(6, "framework_log"); filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=at(tr3)))"); get_filter = filter_create(filter_str); POINTERS_EQUAL(NULL, get_filter); free(filter_str); mock().checkExpectations(); //test missing closing brackets in value mock().expectNCalls(5, "framework_log"); filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3>=att(r3)))"); get_filter = filter_create(filter_str); POINTERS_EQUAL(NULL, get_filter); free(filter_str); mock().checkExpectations(); }