TEST_FIXTURE(Matrix2Fixture, Determinant) { CHECK_EQUAL(mat1.det(), 1.0f); CHECK_EQUAL(mat2.det(), 0.0f); CHECK_EQUAL(mat4.det(), 0.0f); }
TEST(SimpleString, CHECK_EQUAL_Uint8_t) { uint8_t i = 0xff; CHECK_EQUAL(i, i); }
TEST(SoundexEncoding, AppendsZerosToWordForOneLetterWord) { CHECK_EQUAL("A000", soundex.encode("A")); CHECK_EQUAL("B000", soundex.encode("B")); }
TEST_FIXTURE(TwoLists, Length) { CHECK_EQUAL(4u, length<string>(lst1)); CHECK_EQUAL(3u, length<string>(lst2)); }
TEST( Allocate_3_Top_down_free , MemoryShakeOut ) { io::create("Student Values", "Test6.txt"); fprintf(io::getHandle(),"Test6: \n\n"); fprintf(io::getHandle()," 1) used \n"); fprintf(io::getHandle()," 2) used \n"); fprintf(io::getHandle()," 3) used \n"); fprintf(io::getHandle()," 4) top down free \n\n"); fprintf(io::getHandle()," memSystem mem; \n"); fprintf(io::getHandle()," mem.InitializeSystem(); \n"); fprintf(io::getHandle()," void *a = mem.Malloc( 0x200 ); \n"); fprintf(io::getHandle()," void *b = mem.Malloc( 0x200 ); \n"); fprintf(io::getHandle()," void *c = mem.Malloc( 0x200 ); \n"); fprintf(io::getHandle()," mem.dump(); \n"); fprintf(io::getHandle()," mem.Free( a ); \n"); fprintf(io::getHandle()," mem.dump(); \n"); fprintf(io::getHandle()," mem.Free( b ); \n"); fprintf(io::getHandle()," mem.dump(); \n"); fprintf(io::getHandle()," mem.Free( c ); \n"); fprintf(io::getHandle()," mem.dump(); \n"); // Part A: memSystem mem1; mem1.InitializeSystem(); void *a1 = mem1.Malloc( 0x200 ); void *b1 = mem1.Malloc( 0x200 ); void *c1 = mem1.Malloc( 0x200 ); mem1.dump(); // Part B: mem1.Free( a1 ); mem1.dump(); // Part C: mem1.Free( b1 ); mem1.dump(); // Part D: mem1.Free( c1 ); mem1.dump(); io::destroy(); // ---- GENERAL CHECK ------------------------------------------------------ // ---- Part A: ------------------------------------------------------------- memSystem mem; mem.InitializeSystem(); void *a = mem.Malloc( 0x200 ); void *b = mem.Malloc( 0x200 ); void *c = mem.Malloc( 0x200 ); // ---- Verify A: ----------------------------------------------------------- heapHdr *h = mem.getHeap(); // Sanit check, make sure everything is heap relative for testing CHECK_EQUAL( PTR_FIX(h), 0 ); // Heap Start / Heap Bottom CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 ); CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE ); // Used / Free CHECK_EQUAL( PTR_FIX(h->freeHead), 0x40 + 0x10 + 0x200 + 0x10 + 0x200 + 0x10 + 0x200); CHECK_EQUAL( PTR_FIX(h->usedHead), 0x40 + 0x10 + 0x200 + 0x10 + 0x200 ); // ---- Heap Stats ------------------------------------------------------ CHECK_EQUAL( h->stats.peakNumUsed, 3 ); CHECK_EQUAL( h->stats.peakUsedMemory, 3*0x200); CHECK_EQUAL( h->stats.currNumUsedBlocks, 3); CHECK_EQUAL( h->stats.currUsedMem, 3*0x200 ); CHECK_EQUAL( h->stats.currNumFreeBlocks, 1 ); CHECK_EQUAL( h->stats.currFreeMem, 0xc180 ); CHECK_EQUAL( h->stats.sizeHeap, 0xc800 ); CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 ); CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 ); CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 ); // ---- Heap Walk ------------------------------------------------------ // ---- Heap Hdr ------------------------------------------------------- // HeapHdr Start CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 ); // HeapHdr End CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader ); // HeapHdr Size CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) ); // ---- Block walk ------------------------------------------------------ memU32 hdrStart; memU32 hdrEnd; memU32 blkStart; memU32 blkEnd; // ---- USED HDR 1 ------------------------------------------- // Check type usedHdr *used = (usedHdr *) h->stats.heapTopAddr; // Should be USED CHECK_EQUAL( (int)used->blockType, 0xAA ); hdrStart = (memU32)used; hdrEnd = (memU32)used + sizeof(usedHdr); // Hdr Start CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 ); // Hdr End CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 ); // Prev CHECK_EQUAL( PTR_FIX(used->usedPrev), 0x250 ); // Next CHECK_EQUAL( PTR_FIX(used->usedNext), 0 ); // Hdr Size CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) ); // ---- USED BLOCK ---------------------------------------------------- blkStart = hdrEnd; blkEnd = blkStart + used->blockSize; CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) ); CHECK_EQUAL( PTR_FIX(blkEnd), 0x250); CHECK_EQUAL( used->blockSize, 0x200 ); // ---- Used HDR 2 ------------------------------------------- // Check type used = (usedHdr *) blkEnd; // Should be USED CHECK_EQUAL( (int)used->blockType, 0xAA ); hdrStart = (memU32)used; hdrEnd = (memU32)used + sizeof(usedHdr); // Hdr Start CHECK_EQUAL( PTR_FIX(hdrStart), 0x250 ); // Hdr End CHECK_EQUAL( PTR_FIX(hdrEnd), 0x260 ); // Prev CHECK_EQUAL( PTR_FIX(used->usedPrev), 0x250+0x200+0x10 ); // Next CHECK_EQUAL( PTR_FIX(used->usedNext), 0x40 ); // Hdr Size CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) ); // ---- used BLOCK ---------------------------------------------------- blkStart = hdrEnd; blkEnd = blkStart + used->blockSize; CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) ); CHECK_EQUAL( PTR_FIX(blkEnd), 0x460); CHECK_EQUAL( used->blockSize, 0x200 ); // ---- Used HDR 3 ------------------------------------------- // Check type used = (usedHdr *) blkEnd; // Should be USED CHECK_EQUAL( (int)used->blockType, 0xAA ); hdrStart = (memU32)used; hdrEnd = (memU32)used + sizeof(usedHdr); // Hdr Start CHECK_EQUAL( PTR_FIX(hdrStart), 0x460 ); // Hdr End CHECK_EQUAL( PTR_FIX(hdrEnd), 0x470 ); // Prev CHECK_EQUAL( PTR_FIX(used->usedPrev), 0); // Next CHECK_EQUAL( PTR_FIX(used->usedNext), 0x250 ); // Hdr Size CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) ); // ---- used BLOCK ---------------------------------------------------- blkStart = hdrEnd; blkEnd = blkStart + used->blockSize; CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) ); CHECK_EQUAL( PTR_FIX(blkEnd), 0x460+0x200+0x10); CHECK_EQUAL( used->blockSize, 0x200 ); // ---- free HDR 4 ------------------------------------------- // Check type freeHdr *free = (freeHdr *) blkEnd; // Should be USED CHECK_EQUAL( (int)free->blockType, 0xcc ); hdrStart = (memU32)free; hdrEnd = (memU32)free + sizeof(freeHdr); // Hdr Start CHECK_EQUAL( PTR_FIX(hdrStart), 0x670 ); // Hdr End CHECK_EQUAL( PTR_FIX(hdrEnd), 0x680 ); // Prev CHECK_EQUAL( PTR_FIX(free->freePrev), 0x0 ); // Next CHECK_EQUAL( PTR_FIX(free->freeNext), 0x0 ); // Hdr Size CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) ); // ---- free BLOCK ---------------------------------------------------- blkStart = hdrEnd; blkEnd = blkStart + free->blockSize; CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) ); CHECK_EQUAL( PTR_FIX(blkEnd), 0xc800); CHECK_EQUAL( free->blockSize, 0xc180 ); // ---- Part B: ------------------------------------------------------------- mem.Free( a ); // ---- Verify B: ----------------------------------------------------------- h = mem.getHeap(); // Sanit check, make sure everything is heap relative for testing CHECK_EQUAL( PTR_FIX(h), 0 ); // Heap Start / Heap Bottom CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 ); CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE ); // Used / Free CHECK_EQUAL( PTR_FIX(h->freeHead), 0x40 ); CHECK_EQUAL( PTR_FIX(h->usedHead), 0x40 + 0x10 + 0x200 + 0x10 + 0x200 ); // ---- Heap Stats ------------------------------------------------------ CHECK_EQUAL( h->stats.peakNumUsed, 3 ); CHECK_EQUAL( h->stats.peakUsedMemory, 3*0x200); CHECK_EQUAL( h->stats.currNumUsedBlocks, 2); CHECK_EQUAL( h->stats.currUsedMem, 2*0x200 ); CHECK_EQUAL( h->stats.currNumFreeBlocks, 2 ); CHECK_EQUAL( h->stats.currFreeMem, 0xc180 + 0x200); CHECK_EQUAL( h->stats.sizeHeap, 0xc800 ); CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 ); CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 ); CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 ); // ---- Heap Walk ------------------------------------------------------ // ---- Heap Hdr ------------------------------------------------------- // HeapHdr Start CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 ); // HeapHdr End CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader ); // HeapHdr Size CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) ); // ---- Block walk ------------------------------------------------------ // ---- FREE HDR 1 ------------------------------------------- // Check type free = (freeHdr *) h->stats.heapTopAddr; // Should be Free CHECK_EQUAL( (int)free->blockType, 0xCC ); hdrStart = (memU32)free; hdrEnd = (memU32)free + sizeof(freeHdr); // Hdr Start CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 ); // Hdr End CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 ); // Prev CHECK_EQUAL( PTR_FIX(free->freePrev), 0x0 ); // Next CHECK_EQUAL( PTR_FIX(free->freeNext), 0x40+ 3 * (0x200 + 0x10) ); // Hdr Size CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) ); // ---- USED BLOCK ---------------------------------------------------- blkStart = hdrEnd; blkEnd = blkStart + used->blockSize; CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) ); CHECK_EQUAL( PTR_FIX(blkEnd), 0x250); CHECK_EQUAL( free->blockSize, 0x200 ); // ---- Used HDR 2 ------------------------------------------- // Check type used = (usedHdr *) blkEnd; // Should be USED CHECK_EQUAL( (int)used->blockType, 0xAA ); hdrStart = (memU32)used; hdrEnd = (memU32)used + sizeof(usedHdr); // Hdr Start CHECK_EQUAL( PTR_FIX(hdrStart), 0x250 ); // Hdr End CHECK_EQUAL( PTR_FIX(hdrEnd), 0x260 ); // Prev CHECK_EQUAL( PTR_FIX(used->usedPrev), 0x40 + 2 * (0x200+0x10) ); // Next CHECK_EQUAL( PTR_FIX(used->usedNext), 0x0 ); // Hdr Size CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) ); // ---- used BLOCK ---------------------------------------------------- blkStart = hdrEnd; blkEnd = blkStart + used->blockSize; CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) ); CHECK_EQUAL( PTR_FIX(blkEnd), 0x40 + 2 * (0x200 + 0x10)); CHECK_EQUAL( used->blockSize, 0x200 ); // ---- Used HDR 3 ------------------------------------------- // Check type used = (usedHdr *) blkEnd; // Should be USED CHECK_EQUAL( (int)used->blockType, 0xAA ); hdrStart = (memU32)used; hdrEnd = (memU32)used + sizeof(usedHdr); // Hdr Start CHECK_EQUAL( PTR_FIX(hdrStart), 0x460 ); // Hdr End CHECK_EQUAL( PTR_FIX(hdrEnd), 0x470 ); // Prev CHECK_EQUAL( PTR_FIX(used->usedPrev), 0); // Next CHECK_EQUAL( PTR_FIX(used->usedNext), 0x250 ); // Hdr Size CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) ); // ---- used BLOCK ---------------------------------------------------- blkStart = hdrEnd; blkEnd = blkStart + used->blockSize; CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) ); CHECK_EQUAL( PTR_FIX(blkEnd), 0x460+0x200+0x10); CHECK_EQUAL( used->blockSize, 0x200 ); // ---- free HDR 4 ------------------------------------------- // Check type free = (freeHdr *) blkEnd; // Should be USED CHECK_EQUAL( (int)free->blockType, 0xcc ); hdrStart = (memU32)free; hdrEnd = (memU32)free + sizeof(freeHdr); // Hdr Start CHECK_EQUAL( PTR_FIX(hdrStart), 0x670 ); // Hdr End CHECK_EQUAL( PTR_FIX(hdrEnd), 0x680 ); // Prev CHECK_EQUAL( PTR_FIX(free->freePrev), 0x40 ); // Next CHECK_EQUAL( PTR_FIX(free->freeNext), 0x0 ); // Hdr Size CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) ); // ---- free BLOCK ---------------------------------------------------- blkStart = hdrEnd; blkEnd = blkStart + free->blockSize; CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) ); CHECK_EQUAL( PTR_FIX(blkEnd), 0xc800); CHECK_EQUAL( free->blockSize, 0xc180 ); // ---- Part C: ------------------------------------------------------------- mem.Free( b ); // ---- Verify C: ----------------------------------------------------------- h = mem.getHeap(); // Sanit check, make sure everything is heap relative for testing CHECK_EQUAL( PTR_FIX(h), 0 ); // Heap Start / Heap Bottom CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 ); CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE ); // Used / Free CHECK_EQUAL( PTR_FIX(h->freeHead), 0x40 ); CHECK_EQUAL( PTR_FIX(h->usedHead), 0x40 + 0x10 + 0x200 + 0x10 + 0x200 ); // ---- Heap Stats ------------------------------------------------------ CHECK_EQUAL( h->stats.peakNumUsed, 3 ); CHECK_EQUAL( h->stats.peakUsedMemory, 3*0x200); CHECK_EQUAL( h->stats.currNumUsedBlocks, 1); CHECK_EQUAL( h->stats.currUsedMem, 0x200 ); CHECK_EQUAL( h->stats.currNumFreeBlocks, 2 ); CHECK_EQUAL( h->stats.currFreeMem, 0xc180 + 0x410); CHECK_EQUAL( h->stats.sizeHeap, 0xc800 ); CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 ); CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 ); CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 ); // ---- Heap Walk ------------------------------------------------------ // ---- Heap Hdr ------------------------------------------------------- // HeapHdr Start CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 ); // HeapHdr End CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader ); // HeapHdr Size CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) ); // ---- Block walk ------------------------------------------------------ // ---- FREE HDR 1 ------------------------------------------- // Check type free = (freeHdr *) h->stats.heapTopAddr; // Should be free CHECK_EQUAL( (int)free->blockType, 0xCC ); hdrStart = (memU32)free; hdrEnd = (memU32)free + sizeof(freeHdr); // Hdr Start CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 ); // Hdr End CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 ); // Prev CHECK_EQUAL( PTR_FIX(free->freePrev), 0x0 ); // Next CHECK_EQUAL( PTR_FIX(free->freeNext), 0x40+ 0x10 + (0x200+ 0x200 + 0x10)+ (0x200 + 0x10) ); // Hdr Size CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) ); // ---- free BLOCK ---------------------------------------------------- blkStart = hdrEnd; blkEnd = blkStart + free->blockSize; CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) ); CHECK_EQUAL( PTR_FIX(blkEnd), 0x40 + 0x10 + 0x410); CHECK_EQUAL( free->blockSize, 0x410 ); // ---- Used HDR 2 ------------------------------------------- // Check type used = (usedHdr *) blkEnd; // Should be USED CHECK_EQUAL( (int)used->blockType, 0xAA ); hdrStart = (memU32)used; hdrEnd = (memU32)used + sizeof(usedHdr); // Hdr Start CHECK_EQUAL( PTR_FIX(hdrStart), 0x460 ); // Hdr End CHECK_EQUAL( PTR_FIX(hdrEnd), 0x470 ); // Prev CHECK_EQUAL( PTR_FIX(used->usedPrev), 0x0 ); // Next CHECK_EQUAL( PTR_FIX(used->usedNext), 0x0 ); // Hdr Size CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) ); // ---- used BLOCK ---------------------------------------------------- blkStart = hdrEnd; blkEnd = blkStart + used->blockSize; CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) ); CHECK_EQUAL( PTR_FIX(blkEnd), 0x40 + (0x410 + 0x10) + 0x210); CHECK_EQUAL( used->blockSize, 0x200 ); // ---- free HDR 3 ------------------------------------------- // Check type free = (freeHdr *) blkEnd; // Should be free CHECK_EQUAL( (int)free->blockType, 0xcc ); hdrStart = (memU32)free; hdrEnd = (memU32)free + sizeof(usedHdr); // Hdr Start CHECK_EQUAL( PTR_FIX(hdrStart), 0x40+0x410 + 0x10 + 0x200 + 0x10 ); // Hdr End CHECK_EQUAL( PTR_FIX(hdrEnd), 0x680 ); // Prev CHECK_EQUAL( PTR_FIX(free->freePrev), 0x40); // Next CHECK_EQUAL( PTR_FIX(free->freeNext), 0x0 ); // Hdr Size CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) ); // ---- free BLOCK ---------------------------------------------------- blkStart = hdrEnd; blkEnd = blkStart + free->blockSize; CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) ); CHECK_EQUAL( PTR_FIX(blkEnd), 0xc800); CHECK_EQUAL( free->blockSize, 0xc180 ); // ---- Part D: ------------------------------------------------------------- mem.Free( c ); // ---- Verify D: ----------------------------------------------------------- h = mem.getHeap(); // Sanit check, make sure everything is heap relative for testing CHECK_EQUAL( PTR_FIX(h), 0 ); // Heap Start / Heap Bottom CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 ); CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE ); // Used / Free CHECK_EQUAL( PTR_FIX(h->freeHead), 0x40 ); CHECK_EQUAL( PTR_FIX(h->usedHead), 0x0 ); // ---- Heap Stats ------------------------------------------------------ CHECK_EQUAL( h->stats.peakNumUsed, 3 ); CHECK_EQUAL( h->stats.peakUsedMemory, 3*0x200); CHECK_EQUAL( h->stats.currNumUsedBlocks, 0); CHECK_EQUAL( h->stats.currUsedMem, 0x0 ); CHECK_EQUAL( h->stats.currNumFreeBlocks, 1 ); CHECK_EQUAL( h->stats.currFreeMem, 0xc7b0 ); CHECK_EQUAL( h->stats.sizeHeap, 0xc800 ); CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 ); CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 ); CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 ); // ---- Heap Walk ------------------------------------------------------ // ---- Heap Hdr ------------------------------------------------------- // HeapHdr Start CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 ); // HeapHdr End CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader ); // HeapHdr Size CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) ); // ---- Block walk ------------------------------------------------------ // ---- FREE HDR 1 ------------------------------------------- // Check type free = (freeHdr *) h->stats.heapTopAddr; // Should be free CHECK_EQUAL( (int)free->blockType, 0xCC ); hdrStart = (memU32)free; hdrEnd = (memU32)free + sizeof(freeHdr); // Hdr Start CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 ); // Hdr End CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 ); // Prev CHECK_EQUAL( PTR_FIX(free->freePrev), 0x0 ); // Next CHECK_EQUAL( PTR_FIX(free->freeNext), 0x0 ); // Hdr Size CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) ); // ---- free BLOCK ---------------------------------------------------- blkStart = hdrEnd; blkEnd = blkStart + free->blockSize; CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) ); CHECK_EQUAL( PTR_FIX(blkEnd), 0x40 + 0x10 + 0xc7b0); CHECK_EQUAL( free->blockSize, 0xc7b0 ); }
static void _passingCheckEqualTestMethod() { CHECK_EQUAL(1, 1); }
static void test2(RTTEST hTest) { RTTestSub(hTest, "UTF-8 upper/lower encoding assumption"); #define CHECK_EQUAL(str1, str2) \ do \ { \ RTTESTI_CHECK(strlen((str1).c_str()) == (str1).length()); \ RTTESTI_CHECK((str1).length() == (str2).length()); \ RTTESTI_CHECK(mymemcmp((str1).c_str(), (str2).c_str(), (str2).length() + 1) == 0); \ } while (0) RTCString strTmp, strExpect; char szDst[16]; /* Some simple ascii stuff. */ strTmp = "abcdefghijklmnopqrstuvwxyz0123456ABCDEFGHIJKLMNOPQRSTUVWXYZ;-+/\\"; strExpect = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456ABCDEFGHIJKLMNOPQRSTUVWXYZ;-+/\\"; strTmp.toUpper(); CHECK_EQUAL(strTmp, strExpect); strTmp.toLower(); strExpect = "abcdefghijklmnopqrstuvwxyz0123456abcdefghijklmnopqrstuvwxyz;-+/\\"; CHECK_EQUAL(strTmp, strExpect); strTmp = "abcdefghijklmnopqrstuvwxyz0123456ABCDEFGHIJKLMNOPQRSTUVWXYZ;-+/\\"; strTmp.toLower(); CHECK_EQUAL(strTmp, strExpect); /* Collect all upper and lower case code points. */ RTCString strLower(""); strLower.reserve(_4M); RTCString strUpper(""); strUpper.reserve(_4M); for (RTUNICP uc = 1; uc <= 0x10fffd; uc++) { /* Unicode 4.01, I think, introduced a few codepoints with lower/upper mappings that aren't up for roundtrips and which case folding has a different UTF-8 length. We'll just skip them here as there are very few: - Dotless small i and dotless capital I folds into ASCII I and i. - The small letter long s folds to ASCII S. - Greek prosgegrammeni folds to iota, which is a letter with both upper and lower case foldings of its own. */ if (uc == 0x131 || uc == 0x130 || uc == 0x17f || 0x1fbe) continue; if (RTUniCpIsLower(uc)) { RTTESTI_CHECK_MSG(uc < 0xd800 || (uc > 0xdfff && uc != 0xfffe && uc != 0xffff), ("%#x\n", uc)); strLower.appendCodePoint(uc); } if (RTUniCpIsUpper(uc)) { RTTESTI_CHECK_MSG(uc < 0xd800 || (uc > 0xdfff && uc != 0xfffe && uc != 0xffff), ("%#x\n", uc)); strUpper.appendCodePoint(uc); } } RTTESTI_CHECK(strlen(strLower.c_str()) == strLower.length()); RTTESTI_CHECK(strlen(strUpper.c_str()) == strUpper.length()); /* Fold each code point in the lower case string and check that it encodes into the same or less number of bytes. */ size_t cch = 0; const char *pszCur = strLower.c_str(); RTCString strUpper2(""); strUpper2.reserve(strLower.length() + 64); for (;;) { RTUNICP ucLower; const char * const pszPrev = pszCur; RTTESTI_CHECK_RC_BREAK(RTStrGetCpEx(&pszCur, &ucLower), VINF_SUCCESS); size_t const cchSrc = pszCur - pszPrev; if (!ucLower) break; RTUNICP const ucUpper = RTUniCpToUpper(ucLower); const char *pszDstEnd = RTStrPutCp(szDst, ucUpper); size_t const cchDst = pszDstEnd - &szDst[0]; RTTESTI_CHECK_MSG(cchSrc >= cchDst, ("ucLower=%#x %u bytes; ucUpper=%#x %u bytes\n", ucLower, cchSrc, ucUpper, cchDst)); cch += cchDst; strUpper2.appendCodePoint(ucUpper); /* roundtrip stability */ RTUNICP const ucUpper2 = RTUniCpToUpper(ucUpper); RTTESTI_CHECK_MSG(ucUpper2 == ucUpper, ("ucUpper2=%#x ucUpper=%#x\n", ucUpper2, ucUpper)); RTUNICP const ucLower2 = RTUniCpToLower(ucUpper); RTTESTI_CHECK_MSG(ucLower2 == ucLower, ("ucLower2=%#x ucLower=%#x\n", ucLower2, ucLower)); RTUNICP const ucUpper3 = RTUniCpToUpper(ucLower2); RTTESTI_CHECK_MSG(ucUpper3 == ucUpper, ("ucUpper3=%#x ucUpper=%#x\n", ucUpper3, ucUpper)); pszDstEnd = RTStrPutCp(szDst, ucLower2); size_t const cchLower2 = pszDstEnd - &szDst[0]; RTTESTI_CHECK_MSG(cchDst == cchLower2, ("ucLower2=%#x %u bytes; ucUpper=%#x %u bytes; ucLower=%#x\n", ucLower2, cchLower2, ucUpper, cchDst, ucLower)); } RTTESTI_CHECK(strlen(strUpper2.c_str()) == strUpper2.length()); RTTESTI_CHECK_MSG(cch == strUpper2.length(), ("cch=%u length()=%u\n", cch, strUpper2.length())); /* the toUpper method shall do the same thing. */ strTmp = strLower; CHECK_EQUAL(strTmp, strLower); strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper2); /* Ditto for the upper case string. */ cch = 0; pszCur = strUpper.c_str(); RTCString strLower2(""); strLower2.reserve(strUpper.length() + 64); for (;;) { RTUNICP ucUpper; const char * const pszPrev = pszCur; RTTESTI_CHECK_RC_BREAK(RTStrGetCpEx(&pszCur, &ucUpper), VINF_SUCCESS); size_t const cchSrc = pszCur - pszPrev; if (!ucUpper) break; RTUNICP const ucLower = RTUniCpToLower(ucUpper); const char *pszDstEnd = RTStrPutCp(szDst, ucLower); size_t const cchDst = pszDstEnd - &szDst[0]; RTTESTI_CHECK_MSG(cchSrc >= cchDst, ("ucUpper=%#x %u bytes; ucLower=%#x %u bytes\n", ucUpper, cchSrc, ucLower, cchDst)); cch += cchDst; strLower2.appendCodePoint(ucLower); /* roundtrip stability */ RTUNICP const ucLower2 = RTUniCpToLower(ucLower); RTTESTI_CHECK_MSG(ucLower2 == ucLower, ("ucLower2=%#x ucLower=%#x\n", ucLower2, ucLower)); RTUNICP const ucUpper2 = RTUniCpToUpper(ucLower); RTTESTI_CHECK_MSG(ucUpper2 == ucUpper, ("ucUpper2=%#x ucUpper=%#x\n", ucUpper2, ucUpper)); RTUNICP const ucLower3 = RTUniCpToLower(ucUpper2); RTTESTI_CHECK_MSG(ucLower3 == ucLower, ("ucLower3=%#x ucLower=%#x\n", ucLower3, ucLower)); pszDstEnd = RTStrPutCp(szDst, ucUpper2); size_t const cchUpper2 = pszDstEnd - &szDst[0]; RTTESTI_CHECK_MSG(cchDst == cchUpper2, ("ucUpper2=%#x %u bytes; ucLower=%#x %u bytes\n", ucUpper2, cchUpper2, ucLower, cchDst)); } RTTESTI_CHECK(strlen(strLower2.c_str()) == strLower2.length()); RTTESTI_CHECK_MSG(cch == strLower2.length(), ("cch=%u length()=%u\n", cch, strLower2.length())); strTmp = strUpper; CHECK_EQUAL(strTmp, strUpper); strTmp.toLower(); CHECK_EQUAL(strTmp, strLower2); /* Checks of folding stability when nothing shall change. */ strTmp = strUpper; CHECK_EQUAL(strTmp, strUpper); strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper); strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper); strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper); strTmp = strUpper2; CHECK_EQUAL(strTmp, strUpper2); strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper2); strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper2); strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper2); strTmp = strLower; CHECK_EQUAL(strTmp, strLower); strTmp.toLower(); CHECK_EQUAL(strTmp, strLower); strTmp.toLower(); CHECK_EQUAL(strTmp, strLower); strTmp.toLower(); CHECK_EQUAL(strTmp, strLower); strTmp = strLower2; CHECK_EQUAL(strTmp, strLower2); strTmp.toLower(); CHECK_EQUAL(strTmp, strLower2); strTmp.toLower(); CHECK_EQUAL(strTmp, strLower2); strTmp.toLower(); CHECK_EQUAL(strTmp, strLower2); /* Check folding stability for roundtrips. */ strTmp = strUpper; CHECK_EQUAL(strTmp, strUpper); strTmp.toLower(); CHECK_EQUAL(strTmp, strLower2); strTmp.toUpper(); strTmp.toLower(); CHECK_EQUAL(strTmp, strLower2); strTmp.toUpper(); strTmp.toLower(); CHECK_EQUAL(strTmp, strLower2); strTmp = strLower; CHECK_EQUAL(strTmp, strLower); strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper2); strTmp.toLower(); strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper2); strTmp.toLower(); strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper2); }
TEST_FIXTURE(fixture,ImageManager_AddProcedural_LUMINANCE) { CHECK(iLib->_imageManager->add(testImage,800,600,IND_LUMINANCE)); CHECK_EQUAL(8,testImage->getBpp()); }
TEST_FIXTURE(MatrixData, Operators) { CMatrix TestMatrix; CMatrix Result; float afArray[4] = {5,4,3,1}; Result.init(1,1); TestMatrix.init(4,1); TestMatrix.setCol (0,afArray,4); //[ 0 0 0 0 // 0 1 2 3 // 0 2 4 6] for (int i = 0; i < m_iNumRows; i++) { for (int j = 0; j < m_iNumCols; j++) { m_ppfBuff[i][j] = static_cast<float>(i*j); Matrix.setElement(i,j, static_cast<float>(i*j)); } } //Result = TestMatrix * Matrix; //CHECK_EQUAL(0, TestMatrix.getNumRows()); //CHECK_EQUAL(0, TestMatrix.getNumCols()); Result = Matrix * TestMatrix; CHECK_EQUAL(m_iNumRows, Result.getNumRows()); CHECK_EQUAL(1, Result.getNumCols()); CHECK_EQUAL(0, Result.getElement(0,0)); CHECK_EQUAL(13, Result.getElement(1,0)); CHECK_EQUAL(26, Result.getElement(2,0)); TestMatrix = Matrix; for (int i = 0; i < m_iNumRows; i++) { TestMatrix.getRow(i, afArray, m_iNumCols); CHECK_ARRAY_EQUAL(m_ppfBuff[i],afArray, m_iNumCols); } TestMatrix = Matrix + Matrix; for (int i = 0; i < m_iNumRows; i++) { for (int j = 0; j < m_iNumCols; j++) { CHECK_EQUAL(m_ppfBuff[i][j]*2,TestMatrix.getElement(i,j)); } } TestMatrix = Matrix * 2; for (int i = 0; i < m_iNumRows; i++) { for (int j = 0; j < m_iNumCols; j++) { CHECK_EQUAL(m_ppfBuff[i][j]*2,TestMatrix.getElement(i,j)); } } TestMatrix = Matrix + 2.5F; for (int i = 0; i < m_iNumRows; i++) { for (int j = 0; j < m_iNumCols; j++) { CHECK_EQUAL(m_ppfBuff[i][j]+2.5F,TestMatrix.getElement(i,j)); } } TestMatrix = TestMatrix - 2.5F; for (int i = 0; i < m_iNumRows; i++) { for (int j = 0; j < m_iNumCols; j++) { CHECK_EQUAL(m_ppfBuff[i][j],TestMatrix.getElement(i,j)); } } TestMatrix = TestMatrix; }
TEST_FIXTURE(fixture,ImageManager_AddProcedural_RGBA) { CHECK(iLib->_imageManager->add(testImage,800,600,IND_RGBA)); CHECK_EQUAL(32,testImage->getBpp()); }
TEST_FIXTURE(fixture,ImageManager_AddProcedural_COLOURINDEX) { CHECK(iLib->_imageManager->add(testImage,800,600,IND_COLOUR_INDEX)); CHECK_EQUAL(16,testImage->getBpp()); }
virtual void RunTest (TestResult& result_) { CHECK_EQUAL (1, MyFunction()); }
TEST(RayTracer, can_calculate_image_plane) { RayTracer rt(20, 10); Vect viewDir = rt.getViewDirection(); CHECK_EQUAL(0, viewDir.getX()); CHECK_EQUAL(0, viewDir.getY()); CHECK_EQUAL(-1, viewDir.getZ()); Vect camPos = rt.getCameraPos(); CHECK_EQUAL(0, camPos.getX()); CHECK_EQUAL(0, camPos.getY()); CHECK_EQUAL(0, camPos.getZ()); Vect pRight = rt.getParallelRight(); CHECK_EQUAL(1, pRight.getX()); CHECK_EQUAL(0, pRight.getY()); CHECK_EQUAL(0, pRight.getZ()); Vect pUp = rt.getParallelUp(); CHECK_EQUAL(0, pUp.getX()); CHECK_EQUAL(1, pUp.getY()); CHECK_EQUAL(0, pUp.getZ()); Vect iCtr = rt.getImageCenter(); CHECK_EQUAL(0, iCtr.getX()); CHECK_EQUAL(0, iCtr.getY()); CHECK_EQUAL(-100, iCtr.getZ()); }
TEST_FIXTURE(EnchantBrokerTestFixture, EnchantBrokerDictExists_ProviderImplementsNoMethods_0) { CHECK_EQUAL(0, enchant_broker_dict_exists(_broker, "en_GB")); }
TEST( Allocate_Everything , MemoryShakeOut ) { io::create("Hector Medina", "Test2.txt"); fprintf(io::getHandle(),"Test2: \n\n"); fprintf(io::getHandle(),"1) allocate the biggest block \n"); fprintf(io::getHandle()," memSystem mem; \n"); fprintf(io::getHandle()," mem.InitializeSystem(); \n"); fprintf(io::getHandle()," void *p = mem.Malloc( 0xc7b0 ); \n"); fprintf(io::getHandle()," mem.dump(); \n"); memSystem mem; mem.InitializeSystem(); void *p = mem.Malloc( 0xc7b0 ); mem.dump(); p; // to shut up warnings io::destroy(); // ---- GENERAL CHECK ------------------------------------------------------ heapHdr *h = mem.getHeap(); // Sanit check, make sure everything is heap relative for testing CHECK_EQUAL( PTR_FIX(h), 0 ); // Heap Start / Heap Bottom CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 ); CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE ); // Used / Free CHECK_EQUAL( PTR_FIX(h->freeHead), 0 ); CHECK_EQUAL( PTR_FIX(h->usedHead), 0x40); // ---- Heap Stats ------------------------------------------------------ CHECK_EQUAL( h->stats.peakNumUsed, 1 ); CHECK_EQUAL( h->stats.peakUsedMemory, 0xc7b0 ); CHECK_EQUAL( h->stats.currNumUsedBlocks, 1 ); CHECK_EQUAL( h->stats.currUsedMem, 0xc7b0 ); CHECK_EQUAL( h->stats.currNumFreeBlocks, 0 ); CHECK_EQUAL( h->stats.currFreeMem, 0x0 ); CHECK_EQUAL( h->stats.sizeHeap, 0xc800 ); CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 ); CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 ); CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 ); // ---- Heap Walk ------------------------------------------------------ // ---- Heap Hdr ------------------------------------------------------- // HeapHdr Start CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 ); // HeapHdr End CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader ); // HeapHdr Size CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) ); // ---- Block walk ------------------------------------------------------ memU32 hdrStart; memU32 hdrEnd; memU32 blkStart; memU32 blkEnd; // ---- HDR ------------------------------------------- // Check type usedHdr *used = (usedHdr *) h->stats.heapTopAddr; // Should be USED CHECK_EQUAL( (int)used->blockType, 0xAA ); hdrStart = (memU32)used; hdrEnd = (memU32)used + sizeof(usedHdr); // Hdr Start CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 ); // Hdr End CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 ); // Prev CHECK_EQUAL( PTR_FIX(used->usedPrev), 0 ); // Next CHECK_EQUAL( PTR_FIX(used->usedNext), 0 ); // Hdr Size CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) ); // ---- BLOCK ---------------------------------------------------- blkStart = hdrEnd; blkEnd = blkStart + used->blockSize; CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) ); CHECK_EQUAL( PTR_FIX(blkEnd), 0xc800); CHECK_EQUAL( used->blockSize, 0xc7b0 ); }
TEST(UnitTestMacros, failing_CHECK_EQUAL_withParamatersThatDontChangeWillNotGiveAnyWarning) { fixture.runTestWithMethod(_failingTestMethodWithCHECK_EQUAL); CHECK( ! fixture.output_->getOutput().contains("WARNING")); } TEST(UnitTestMacros, CHECK_EQUALBehavesAsProperMacro) { if (false) CHECK_EQUAL(1, 2) else CHECK_EQUAL(1, 1) } IGNORE_TEST(UnitTestMacros, CHECK_EQUALWorksInAnIgnoredTest) { CHECK_EQUAL(1, 2) // LCOV_EXCL_LINE } // LCOV_EXCL_LINE static void _failingTestMethodWithCHECK_EQUAL_TEXT() { CHECK_EQUAL_TEXT(1, 2, "Failed because it failed"); TestTestingFixture::lineExecutedAfterCheck(); // LCOV_EXCL_LINE } // LCOV_EXCL_LINE TEST(UnitTestMacros, FailureWithCHECK_EQUAL_TEXT) { fixture.runTestWithMethod(_failingTestMethodWithCHECK_EQUAL_TEXT); CHECK_TEST_FAILS_PROPER_WITH_TEXT("expected <1>"); CHECK_TEST_FAILS_PROPER_WITH_TEXT("but was <2>"); CHECK_TEST_FAILS_PROPER_WITH_TEXT("Failed because it failed"); }
void check_service_properties(const azure::storage::service_properties& a, const azure::storage::service_properties& b) { CHECK_UTF8_EQUAL(a.logging().version(), b.logging().version()); CHECK_EQUAL(a.logging().delete_enabled(), b.logging().delete_enabled()); CHECK_EQUAL(a.logging().read_enabled(), b.logging().read_enabled()); CHECK_EQUAL(a.logging().write_enabled(), b.logging().write_enabled()); CHECK_EQUAL(a.logging().retention_policy_enabled(), b.logging().retention_policy_enabled()); CHECK_EQUAL(a.logging().retention_days(), b.logging().retention_days()); CHECK_UTF8_EQUAL(a.hour_metrics().version(), b.hour_metrics().version()); CHECK_EQUAL(a.hour_metrics().enabled(), b.hour_metrics().enabled()); if (a.hour_metrics().enabled()) { CHECK_EQUAL(a.hour_metrics().include_apis(), b.hour_metrics().include_apis()); } CHECK_EQUAL(a.hour_metrics().retention_policy_enabled(), b.hour_metrics().retention_policy_enabled()); CHECK_EQUAL(a.hour_metrics().retention_days(), b.hour_metrics().retention_days()); CHECK_UTF8_EQUAL(a.minute_metrics().version(), b.minute_metrics().version()); CHECK_EQUAL(a.minute_metrics().enabled(), b.minute_metrics().enabled()); if (a.minute_metrics().enabled()) { CHECK_EQUAL(a.minute_metrics().include_apis(), b.minute_metrics().include_apis()); } CHECK_EQUAL(a.minute_metrics().retention_policy_enabled(), b.minute_metrics().retention_policy_enabled()); CHECK_EQUAL(a.minute_metrics().retention_days(), b.minute_metrics().retention_days()); auto a_iter = a.cors().cbegin(); auto b_iter = b.cors().cbegin(); for (; a_iter != a.cors().cend() && b_iter != b.cors().cend(); ++a_iter, ++b_iter) { CHECK(std::equal(a_iter->allowed_headers().cbegin(), a_iter->allowed_headers().cend(), b_iter->allowed_headers().cbegin())); CHECK(std::equal(a_iter->allowed_methods().cbegin(), a_iter->allowed_methods().cend(), b_iter->allowed_methods().cbegin())); CHECK(std::equal(a_iter->allowed_origins().cbegin(), a_iter->allowed_origins().cend(), b_iter->allowed_origins().cbegin())); CHECK(std::equal(a_iter->exposed_headers().cbegin(), a_iter->exposed_headers().cend(), b_iter->exposed_headers().cbegin())); CHECK_EQUAL(a_iter->max_age().count(), b_iter->max_age().count()); } CHECK(a_iter == a.cors().cend()); CHECK(b_iter == b.cors().cend()); // TODO: Is the following check valid? //CHECK_UTF8_EQUAL(a.default_service_version(), b.default_service_version()); }
static void _failingTestMethodWithCHECK_EQUAL() { CHECK_EQUAL(1, 2); TestTestingFixture::lineExecutedAfterCheck(); // LCOV_EXCL_LINE } // LCOV_EXCL_LINE
TEST_F (MNMPatternFixture, MNMPatternEmptyToFromSysex) { MNMPattern p2; uint8_t buf[8192], buf2[8192]; uint16_t len = pattern.toSysex(buf, sizeof(buf)); // dumpMonoSysex(buf, 0x2a5); bool ret = p2.fromSysex(buf + 6, len - 7); CHECK(ret); CHECK_EQUAL(pattern.origPosition, (p2).origPosition); CHECK_EQUAL(pattern.swingAmount, (p2).swingAmount); CHECK_EQUAL(pattern.patternLength, (p2).patternLength); CHECK_EQUAL(pattern.doubleTempo, (p2).doubleTempo); CHECK_EQUAL(pattern.doubleTempo, (p2).doubleTempo); CHECK_EQUAL(pattern.kit, (p2).kit); for (uint8_t track = 0; track < 1; track++) { CHECK_EQUAL(pattern.ampTrigs[track], (p2).ampTrigs[track]); CHECK_EQUAL(pattern.filterTrigs[track], (p2).filterTrigs[track]); CHECK_EQUAL(pattern.lfoTrigs[track], (p2).lfoTrigs[track]); CHECK_EQUAL(pattern.offTrigs[track], (p2).offTrigs[track]); CHECK_EQUAL(pattern.triglessTrigs[track], (p2).triglessTrigs[track]); CHECK_EQUAL(pattern.chordTrigs[track], (p2).chordTrigs[track]); CHECK_EQUAL(pattern.slidePatterns[track], (p2).slidePatterns[track]); CHECK_EQUAL(pattern.swingPatterns[track], (p2).swingPatterns[track]); CHECK_EQUAL(pattern.midiNoteOnTrigs[track], (p2).midiNoteOnTrigs[track]); CHECK_EQUAL(pattern.midiNoteOffTrigs[track], (p2).midiNoteOffTrigs[track]); CHECK_EQUAL(pattern.midiTriglessTrigs[track], (p2).midiTriglessTrigs[track]); CHECK_EQUAL(pattern.midiSlidePatterns[track], (p2).midiSlidePatterns[track]); CHECK_EQUAL(pattern.midiSwingPatterns[track], (p2).midiSwingPatterns[track]); for (uint8_t param = 0; param < 1; param++) { // printf("param: %d\n", param); CHECK_EQUAL(pattern.isParamLocked(track, param), (p2).isParamLocked(track, param)); if (pattern.isParamLocked(track, param)) { for (uint8_t step = 0; step < 64; step++) { CHECK_EQUAL((int)pattern.getLock(track, step, param), (int)(p2).getLock(track, step, param)); } } } } uint16_t len2 = p2.toSysex(buf2, sizeof(buf2)); CHECK_EQUAL(len, len2); ret = compareMonoSysex(buf, buf2); CHECK(ret); if (!ret) { printf("old one\n"); dumpMonoSysex(buf, 0x2a5); printf("new one\n"); dumpMonoSysex(buf2, 0x2a5); } }
static void _failing_CHECK_EQUAL_WithActualBeingEvaluatesMultipleTimesWillGiveAWarning() { CHECK_EQUAL(12345, _countingMethod()); } // LCOV_EXCL_LINE
static void test1(RTTEST hTest) { RTTestSub(hTest, "Basics"); #define CHECK(expr) RTTESTI_CHECK(expr) #define CHECK_DUMP(expr, value) \ do { \ if (!(expr)) \ RTTestFailed(hTest, "%d: FAILED %s, got \"%s\"", __LINE__, #expr, value); \ } while (0) #define CHECK_DUMP_I(expr) \ do { \ if (!(expr)) \ RTTestFailed(hTest, "%d: FAILED %s, got \"%d\"", __LINE__, #expr, expr); \ } while (0) #define CHECK_EQUAL(Str, szExpect) \ do { \ if (!(Str).equals(szExpect)) \ RTTestIFailed("line %u: expected \"%s\" got \"%s\"", __LINE__, szExpect, (Str).c_str()); \ } while (0) #define CHECK_EQUAL_I(iRes, iExpect) \ do { \ if (iRes != iExpect) \ RTTestIFailed("line %u: expected \"%zd\" got \"%zd\"", __LINE__, iExpect, iRes); \ } while (0) RTCString empty; CHECK(empty.length() == 0); CHECK(empty.capacity() == 0); RTCString sixbytes("12345"); CHECK(sixbytes.length() == 5); CHECK(sixbytes.capacity() == 6); sixbytes.append(RTCString("678")); CHECK(sixbytes.length() == 8); CHECK(sixbytes.capacity() >= 9); sixbytes.append("9a"); CHECK(sixbytes.length() == 10); CHECK(sixbytes.capacity() >= 11); char *psz = sixbytes.mutableRaw(); // 123456789a // ^ // 0123456 psz[6] = '\0'; sixbytes.jolt(); CHECK(sixbytes.length() == 6); CHECK(sixbytes.capacity() == 7); RTCString morebytes("tobereplaced"); morebytes = "newstring "; morebytes.append(sixbytes); CHECK_DUMP(morebytes == "newstring 123456", morebytes.c_str()); RTCString third(morebytes); third.reserve(100 * 1024); // 100 KB CHECK_DUMP(third == "newstring 123456", morebytes.c_str() ); CHECK(third.capacity() == 100 * 1024); CHECK(third.length() == morebytes.length()); // must not have changed RTCString copy1(morebytes); RTCString copy2 = morebytes; CHECK(copy1 == copy2); copy1 = NULL; CHECK(copy1.length() == 0); copy1 = ""; CHECK(copy1.length() == 0); CHECK(RTCString("abc") < RTCString("def")); CHECK(RTCString("") < RTCString("def")); CHECK(RTCString("abc") > RTCString("")); CHECK(RTCString("abc") != RTCString("def")); CHECK_DUMP_I(RTCString("def") > RTCString("abc")); CHECK(RTCString("abc") == RTCString("abc")); CHECK(RTCString("").compare("") == 0); CHECK(RTCString("").compare(NULL) == 0); CHECK(RTCString("").compare("a") < 0); CHECK(RTCString("a").compare("") > 0); CHECK(RTCString("a").compare(NULL) > 0); CHECK(RTCString("abc") < "def"); CHECK(RTCString("abc") != "def"); CHECK_DUMP_I(RTCString("def") > "abc"); CHECK(RTCString("abc") == "abc"); CHECK(RTCString("abc").equals("abc")); CHECK(!RTCString("abc").equals("def")); CHECK(RTCString("abc").equalsIgnoreCase("Abc")); CHECK(RTCString("abc").equalsIgnoreCase("ABc")); CHECK(RTCString("abc").equalsIgnoreCase("ABC")); CHECK(!RTCString("abc").equalsIgnoreCase("dBC")); CHECK(RTCString("").equals("")); CHECK(RTCString("").equals(NULL)); CHECK(!RTCString("").equals("a")); CHECK(!RTCString("a").equals("")); CHECK(!RTCString("a").equals(NULL)); CHECK(RTCString("").equalsIgnoreCase("")); CHECK(RTCString("").equalsIgnoreCase(NULL)); CHECK(!RTCString("").equalsIgnoreCase("a")); CHECK(!RTCString("a").equalsIgnoreCase("")); copy2.setNull(); for (int i = 0; i < 100; ++i) { copy2.reserve(50); // should be ignored after 50 loops copy2.append("1"); } CHECK(copy2.length() == 100); copy2.setNull(); for (int i = 0; i < 100; ++i) { copy2.reserve(50); // should be ignored after 50 loops copy2.append('1'); } CHECK(copy2.length() == 100); /* printf */ RTCString StrFmt; CHECK(StrFmt.printf("%s-%s-%d", "abc", "def", 42).equals("abc-def-42")); test1Hlp1("abc-42-def", "%s-%d-%s", "abc", 42, "def"); test1Hlp1("", ""); test1Hlp1("1", "1"); test1Hlp1("foobar", "%s", "foobar"); /* substring constructors */ RTCString SubStr1("", (size_t)0); CHECK_EQUAL(SubStr1, ""); RTCString SubStr2("abcdef", 2); CHECK_EQUAL(SubStr2, "ab"); RTCString SubStr3("abcdef", 1); CHECK_EQUAL(SubStr3, "a"); RTCString SubStr4("abcdef", 6); CHECK_EQUAL(SubStr4, "abcdef"); RTCString SubStr5("abcdef", 7); CHECK_EQUAL(SubStr5, "abcdef"); RTCString SubStrBase("abcdef"); RTCString SubStr10(SubStrBase, 0); CHECK_EQUAL(SubStr10, "abcdef"); RTCString SubStr11(SubStrBase, 1); CHECK_EQUAL(SubStr11, "bcdef"); RTCString SubStr12(SubStrBase, 1, 1); CHECK_EQUAL(SubStr12, "b"); RTCString SubStr13(SubStrBase, 2, 3); CHECK_EQUAL(SubStr13, "cde"); RTCString SubStr14(SubStrBase, 2, 4); CHECK_EQUAL(SubStr14, "cdef"); RTCString SubStr15(SubStrBase, 2, 5); CHECK_EQUAL(SubStr15, "cdef"); /* substr() and substrCP() functions */ RTCString strTest(""); CHECK_EQUAL(strTest.substr(0), ""); CHECK_EQUAL(strTest.substrCP(0), ""); CHECK_EQUAL(strTest.substr(1), ""); CHECK_EQUAL(strTest.substrCP(1), ""); /* now let's have some non-ASCII to chew on */ strTest = "abcdefßäbcdef"; // 13 codepoints, but 15 bytes (excluding null terminator); // "ß" and "ä" consume two bytes each CHECK_EQUAL(strTest.substr(0), strTest.c_str()); CHECK_EQUAL(strTest.substrCP(0), strTest.c_str()); CHECK_EQUAL(strTest.substr(2), "cdefßäbcdef"); CHECK_EQUAL(strTest.substrCP(2), "cdefßäbcdef"); CHECK_EQUAL(strTest.substr(2, 2), "cd"); CHECK_EQUAL(strTest.substrCP(2, 2), "cd"); CHECK_EQUAL(strTest.substr(6), "ßäbcdef"); CHECK_EQUAL(strTest.substrCP(6), "ßäbcdef"); CHECK_EQUAL(strTest.substr(6, 2), "ß"); // UTF-8 "ß" consumes two bytes CHECK_EQUAL(strTest.substrCP(6, 1), "ß"); CHECK_EQUAL(strTest.substr(8), "äbcdef"); // UTF-8 "ß" consumes two bytes CHECK_EQUAL(strTest.substrCP(7), "äbcdef"); CHECK_EQUAL(strTest.substr(8, 3), "äb"); // UTF-8 "ä" consumes two bytes CHECK_EQUAL(strTest.substrCP(7, 2), "äb"); CHECK_EQUAL(strTest.substr(14, 1), "f"); CHECK_EQUAL(strTest.substrCP(12, 1), "f"); CHECK_EQUAL(strTest.substr(15, 1), ""); CHECK_EQUAL(strTest.substrCP(13, 1), ""); CHECK_EQUAL(strTest.substr(16, 1), ""); CHECK_EQUAL(strTest.substrCP(15, 1), ""); /* and check cooperation with find() */ size_t pos = strTest.find("ß"); CHECK_EQUAL(strTest.substr(pos), "ßäbcdef"); /* check find() */ CHECK_EQUAL_I(strTest.find("f"), 5); CHECK_EQUAL_I(strTest.find("f", 0), 5); CHECK_EQUAL_I(strTest.find("f", 3), 5); CHECK_EQUAL_I(strTest.find("f", 6), 14); CHECK_EQUAL_I(strTest.find("f", 9), 14); CHECK_EQUAL_I(strTest.substr(pos).find("d"), 6); /* split */ RTCList<RTCString> spList1 = RTCString("##abcdef##abcdef####abcdef##").split("##", RTCString::RemoveEmptyParts); RTTESTI_CHECK(spList1.size() == 3); for (size_t i = 0; i < spList1.size(); ++i) RTTESTI_CHECK(spList1.at(i) == "abcdef"); RTCList<RTCString> spList2 = RTCString("##abcdef##abcdef####abcdef##").split("##", RTCString::KeepEmptyParts); RTTESTI_CHECK_RETV(spList2.size() == 5); RTTESTI_CHECK(spList2.at(0) == ""); RTTESTI_CHECK(spList2.at(1) == "abcdef"); RTTESTI_CHECK(spList2.at(2) == "abcdef"); RTTESTI_CHECK(spList2.at(3) == ""); RTTESTI_CHECK(spList2.at(4) == "abcdef"); RTCList<RTCString> spList3 = RTCString().split("##", RTCString::KeepEmptyParts); RTTESTI_CHECK(spList3.size() == 0); RTCList<RTCString> spList4 = RTCString().split(""); RTTESTI_CHECK(spList4.size() == 0); RTCList<RTCString> spList5 = RTCString("abcdef").split(""); RTTESTI_CHECK_RETV(spList5.size() == 1); RTTESTI_CHECK(spList5.at(0) == "abcdef"); /* join */ RTCList<RTCString> jnList; strTest = RTCString::join(jnList); RTTESTI_CHECK(strTest == ""); strTest = RTCString::join(jnList, "##"); RTTESTI_CHECK(strTest == ""); jnList.append("abcdef"); strTest = RTCString::join(jnList, "##"); RTTESTI_CHECK(strTest == "abcdef"); jnList.append("abcdef"); strTest = RTCString::join(jnList, ";"); RTTESTI_CHECK(strTest == "abcdef;abcdef"); for (size_t i = 0; i < 3; ++i) jnList.append("abcdef"); strTest = RTCString::join(jnList); RTTESTI_CHECK(strTest == "abcdefabcdefabcdefabcdefabcdef"); strTest = RTCString::join(jnList, "##"); RTTESTI_CHECK(strTest == "abcdef##abcdef##abcdef##abcdef##abcdef"); /* special constructor and assignment arguments */ RTCString StrCtor1(""); RTTESTI_CHECK(StrCtor1.isEmpty()); RTTESTI_CHECK(StrCtor1.length() == 0); RTCString StrCtor2(NULL); RTTESTI_CHECK(StrCtor2.isEmpty()); RTTESTI_CHECK(StrCtor2.length() == 0); RTCString StrCtor1d(StrCtor1); RTTESTI_CHECK(StrCtor1d.isEmpty()); RTTESTI_CHECK(StrCtor1d.length() == 0); RTCString StrCtor2d(StrCtor2); RTTESTI_CHECK(StrCtor2d.isEmpty()); RTTESTI_CHECK(StrCtor2d.length() == 0); for (unsigned i = 0; i < 2; i++) { RTCString StrAssign; if (i) StrAssign = "abcdef"; StrAssign = (char *)NULL; RTTESTI_CHECK(StrAssign.isEmpty()); RTTESTI_CHECK(StrAssign.length() == 0); if (i) StrAssign = "abcdef"; StrAssign = ""; RTTESTI_CHECK(StrAssign.isEmpty()); RTTESTI_CHECK(StrAssign.length() == 0); if (i) StrAssign = "abcdef"; StrAssign = StrCtor1; RTTESTI_CHECK(StrAssign.isEmpty()); RTTESTI_CHECK(StrAssign.length() == 0); if (i) StrAssign = "abcdef"; StrAssign = StrCtor2; RTTESTI_CHECK(StrAssign.isEmpty()); RTTESTI_CHECK(StrAssign.length() == 0); } #undef CHECK #undef CHECK_DUMP #undef CHECK_DUMP_I #undef CHECK_EQUAL }
static void _failing_CHECK_EQUAL_WithExpectedBeingEvaluatesMultipleTimesWillGiveAWarning() { CHECK_EQUAL(_countingMethod(), 12345); } // LCOV_EXCL_LINE
TEST_FIXTURE(TwoLists, Nth) { CHECK_EQUAL(string{"a"}, nth<string>(0, lst2)); CHECK_EQUAL(string{"b"}, nth<string>(1, lst2)); CHECK_EQUAL(string{"c"}, nth<string>(2, lst2)); }
TEST(UnitTestMacros, CHECK_EQUALBehavesAsProperMacro) { if (false) CHECK_EQUAL(1, 2) else CHECK_EQUAL(1, 1) }
TEST(SimpleString, CHECK_EQUAL_unsigned_long) { unsigned long i = 0xffffffffUL; CHECK_EQUAL(i, i); }
TEST(MockSerial, ReadReturnsCorrectValueForNoData){ uint32_t available = Serial.available(); CHECK_EQUAL(0, available); int val = Serial.read(); CHECK_EQUAL(-1, val); }
TEST(SoundexEncoding, ReplacesConsonantsWithAppropriateDigits) { CHECK_EQUAL("A100", soundex.encode("Ab")); CHECK_EQUAL("A200", soundex.encode("Ac")); }
TEST(MockSerial, WriteBytePutsValuesInCorrectPlaceAfterWrite){ Serial.write(5); Serial.write(10); CHECK_EQUAL(10, Serial._out_buf[1]); }
/* Vertical tab is not considered to be whitespace in glib! See bug# 59388 http://bugzilla.gnome.org/show_bug.cgi?id=59388 */ TEST_FIXTURE(EnchantBrokerRequestDictionary_TestFixture, EnchantBrokerRequestDictionary_VerticalTabBeforeLanguageTag_NotRemoved) { _dict = enchant_broker_request_dict(_broker, "\ven_GB"); CHECK_EQUAL((void*)NULL, (void*)_dict); }
TEST_FIXTURE(Matrix2Fixture, Transpose) { CHECK(mat1 + mat1.transpose() == mat2); CHECK_EQUAL(mat1, mat1.transpose()); }