static bool compare_files(const char *pFilename1, const char* pFilename2) { FILE* pFile1 = open_file_with_retries(pFilename1, "rb"); if (!pFile1) { print_error("Failed opening file: %s\n", pFilename1); return false; } FILE* pFile2 = open_file_with_retries(pFilename2, "rb"); if (!pFile2) { print_error("Failed opening file: %s\n", pFilename2); fclose(pFile1); return false; } fseek(pFile1, 0, SEEK_END); int64 fileSize1 = _ftelli64(pFile1); fseek(pFile1, 0, SEEK_SET); fseek(pFile2, 0, SEEK_END); int64 fileSize2 = _ftelli64(pFile2); fseek(pFile2, 0, SEEK_SET); if (fileSize1 != fileSize2) { print_error("Files to compare are not the same size: %I64i vs. %I64i.\n", fileSize1, fileSize2); fclose(pFile1); fclose(pFile2); return false; } const uint cBufSize = 1024 * 1024; std::vector<uint8> buf1(cBufSize); std::vector<uint8> buf2(cBufSize); int64 bytes_remaining = fileSize1; while (bytes_remaining) { const uint bytes_to_read = static_cast<uint>(my_min(cBufSize, bytes_remaining)); if (fread(&buf1.front(), bytes_to_read, 1, pFile1) != 1) { print_error("Failed reading from file: %s\n", pFilename1); fclose(pFile1); fclose(pFile2); return false; } if (fread(&buf2.front(), bytes_to_read, 1, pFile2) != 1) { print_error("Failed reading from file: %s\n", pFilename2); fclose(pFile1); fclose(pFile2); return false; } if (memcmp(&buf1.front(), &buf2.front(), bytes_to_read) != 0) { print_error("File data comparison failed!\n"); fclose(pFile1); fclose(pFile2); return false; } bytes_remaining -= bytes_to_read; } fclose(pFile1); fclose(pFile2); return true; }
void Process() { PathListIt it = paths.begin(); while (it != paths.end()) { getFolderContent(*it); ++it; } logInfo(L"Files to process:\t%8llu\n", data.size()); logDebug(L""); std::sort(data.begin(), data.end(), CompareBySizeAndTime); std::pair<FilesListIt, FilesListIt> bounds; FilesListIt srch = data.begin(); while (srch != data.end()) { logCounter(L"Files left:\t%8llu", std::distance(srch, data.end())); bounds = std::equal_range(srch, data.end(), *srch, CompareBySize); if (std::distance(bounds.first, bounds.second) == 1) { ++Statistics::getInstance()->filesFoundUnique; data.erase(bounds.first); } else { while (srch != bounds.second) { FilesListIt it = srch; ++it; shared_ptr<File>& f1 = *srch; while (it != bounds.second) { shared_ptr<File>& f2 = *it; AutoUTF buf1(f1->path()); AutoUTF buf2(f2->path()); { ConsoleColor col(FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_GREEN); logDebug(L"Comparing files [size = %I64u]:\n", f1->size()); } logDebug(L" %s\n", buf1.c_str()); logDebug(L" %s\n", buf2.c_str()); ++Statistics::getInstance()->fileCompares; f1->refresh(); f2->refresh(); if (AttrMustMatch && f1->attr() != f2->attr()) { { ConsoleColor col(FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN); logDebug(L" Attributes of files do not match, skipping\n"); } Statistics::getInstance()->fileMetaDataMismatch++; ++it; break; } if (TimeMustMatch && f1->mtime() != f2->mtime()) { { ConsoleColor col(FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN); logDebug(L" Modification timestamps of files do not match, skipping\n"); } Statistics::getInstance()->fileMetaDataMismatch++; ++it; break; } if (!isSameVolume(*f1, *f2)) { { ConsoleColor col(FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN); logDebug(L" Files ignored - on different volumes\n"); } ++Statistics::getInstance()->filesOnDifferentVolumes; ++it; break; } if (f1 == f2) { ++Statistics::getInstance()->fileAlreadyLinked; { ConsoleColor col(FOREGROUND_INTENSITY | FOREGROUND_GREEN); logDebug(L" Files ignored - already linked\n"); } ++it; break; } if (f1->size() > FirstBlock) { if (!f1->LoadHashMini()) { break; } if (!f2->LoadHashMini()) { it = data.erase(it); continue; } } else { if (!f1->LoadHashFull()) { break; } if (!f2->LoadHashFull()) { it = data.erase(it); continue; } } if (isIdentical(*f1, *f2)) { ++Statistics::getInstance()->fileContentSame; if (logLevel == LOG_VERBOSE) { { ConsoleColor col(FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_GREEN); logVerbose(L"Comparing files [size = %I64u]:\n", f1->size()); } logVerbose(L" %s\n", buf1.c_str()); logVerbose(L" %s\n", buf2.c_str()); } { ConsoleColor col(FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN); logVerbose(L" Files are equal, hard link possible\n"); } if (hardlink) { f1->hardlink(*f2); } Statistics::getInstance()->FreeSpaceIncrease += f1->size(); it = data.erase(it); } else { { ConsoleColor col(FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN); logDebug(L" Files differ in content (hash)\n"); } Statistics::getInstance()->hashComparesHit1++; ++it; } } srch = data.erase(srch); } } srch = bounds.second; } logCounter(L" "); }
void DFAContentModel::checkUniqueParticleAttribution (SchemaGrammar* const pGrammar, GrammarResolver* const pGrammarResolver, XMLStringPool* const pStringPool, XMLValidator* const pValidator, unsigned int* const pContentSpecOrgURI, const XMLCh* pComplexTypeName /*= 0*/) { SubstitutionGroupComparator comparator(pGrammarResolver, pStringPool); unsigned int i, j, k; // Rename the URI back for (i = 0; i < fElemMapSize; i++) { unsigned int orgURIIndex = fElemMap[i]->getURI(); if ((orgURIIndex != XMLContentModel::gEOCFakeId) && (orgURIIndex != XMLContentModel::gEpsilonFakeId) && (orgURIIndex != XMLElementDecl::fgInvalidElemId) && (orgURIIndex != XMLElementDecl::fgPCDataElemId)) { fElemMap[i]->setURI(pContentSpecOrgURI[orgURIIndex]); } } // Unique Particle Attribution // store the conflict results between any two elements in fElemMap // XMLContentModel::gInvalidTrans: not compared; 0: no conflict; 1: conflict unsigned int** fConflictTable = (unsigned int**) fMemoryManager->allocate ( fElemMapSize * sizeof(unsigned int*) ); //new unsigned int*[fElemMapSize]; // initialize the conflict table for (j = 0; j < fElemMapSize; j++) { fConflictTable[j] = (unsigned int*) fMemoryManager->allocate ( fElemMapSize * sizeof(unsigned int) ); //new unsigned int[fElemMapSize]; for (k = j+1; k < fElemMapSize; k++) fConflictTable[j][k] = XMLContentModel::gInvalidTrans; } // for each state, check whether it has overlap transitions for (i = 0; i < fTransTableSize; i++) { for (j = 0; j < fElemMapSize; j++) { for (k = j+1; k < fElemMapSize; k++) { if (fTransTable[i][j] != XMLContentModel::gInvalidTrans && fTransTable[i][k] != XMLContentModel::gInvalidTrans && fConflictTable[j][k] == XMLContentModel::gInvalidTrans) { // If this is text in a Schema mixed content model, skip it. if ( fIsMixed && (( fElemMap[j]->getURI() == XMLElementDecl::fgPCDataElemId) || ( fElemMap[k]->getURI() == XMLElementDecl::fgPCDataElemId))) continue; if (XercesElementWildcard::conflict(pGrammar, fElemMapType[j], fElemMap[j], fElemMapType[k], fElemMap[k], &comparator)) { fConflictTable[j][k] = 1; XMLBuffer buf1(1023, fMemoryManager); if (((fElemMapType[j] & 0x0f) == ContentSpecNode::Any) || ((fElemMapType[j] & 0x0f) == ContentSpecNode::Any_NS)) buf1.set(SchemaSymbols::fgATTVAL_TWOPOUNDANY); else if ((fElemMapType[j] & 0x0f) == ContentSpecNode::Any_Other) buf1.set(SchemaSymbols::fgATTVAL_TWOPOUNDOTHER); else buf1.set(fElemMap[j]->getRawName()); XMLBuffer buf2(1023, fMemoryManager); if (((fElemMapType[k] & 0x0f) == ContentSpecNode::Any) || ((fElemMapType[k] & 0x0f) == ContentSpecNode::Any_NS)) buf2.set(SchemaSymbols::fgATTVAL_TWOPOUNDANY); else if ((fElemMapType[k] & 0x0f) == ContentSpecNode::Any_Other) buf2.set(SchemaSymbols::fgATTVAL_TWOPOUNDOTHER); else buf2.set(fElemMap[k]->getRawName()); pValidator->emitError(XMLValid::UniqueParticleAttributionFail, pComplexTypeName, buf1.getRawBuffer(), buf2.getRawBuffer()); } else fConflictTable[j][k] = 0; } } } } for (i = 0; i < fElemMapSize; i++) fMemoryManager->deallocate(fConflictTable[i]); //delete [] fConflictTable[i]; fMemoryManager->deallocate(fConflictTable); //delete [] fConflictTable; }
static bool test() { typedef CCharBuffer<Char> __Buffer; Char str[100] = {'a','b', 'c', 'd', 'e', 'f', 'g'}; //ctor __Buffer buf1; __Buffer buf2(__CharP"abcdefg"); const __Buffer buf3(str, sizeof str, 7); __Buffer buf4 = __CharP"abcdefg"; if(buf1 == buf2) return false; if(buf2 != buf3) return false; if(buf3 != buf4) return false; if(buf2 != buf4) return false; if(!buf1.empty()) return false; if(7 != buf2.size() || 7 != buf2.capacity()) return false; if(sizeof str != buf3.capacity()) return false; if(7 != buf4.capacity()) return false; if(7 != buf4.length()) return false; //assign buf1.assign(buf3); if(buf1 != buf3) return false; if(sizeof str != buf1.capacity()) return false; buf2.assign(str, sizeof str, 7); if(buf2 != buf3) return false; if(sizeof str != buf2.capacity()) return false; //copy Char str2[8] = {}; if(7 != buf2.copy(str2, 7)) return false; if(0 != strcmp((const char *)str, (const char *)str2)) return false; //get_allocator typename __Buffer::allocator_type a = buf1.get_allocator(); //begin, end typename __Buffer::value_type ch = 'A'; typedef typename __Buffer::iterator __Iter; typedef typename __Buffer::const_iterator __CIter; for(__Iter i = buf1.begin();i != buf1.end();++i) *i = ch++; ch = 'A'; for(__CIter i = buf3.begin();i != buf3.end();++i) if(*i != ch++) return false; //rbegin, rend typedef typename __Buffer::reverse_iterator __RIter; typedef typename __Buffer::const_reverse_iterator __CRIter; ch = 'A'; for(__RIter i = buf1.rbegin();i != buf1.rend();++i) *i = ch++; ch = 'A'; for(__CRIter i = buf3.rbegin();i != buf3.rend();++i) if(*i != ch++) return false; //operator [] ch = 'A'; for(size_t i = 0;i < buf1.size();++i) buf1[i] = ch++; ch = 'A'; for(size_t i = 0;i < buf3.size();++i) if(buf3[i] != ch++) return false; //back buf1.back() = 'x'; if(buf3.back() != 'x') return false; //at ch = 'A'; for(size_t i = 0;i < buf1.size();++i) buf1.at(i) = ch++; ch = 'A'; for(size_t i = 0;i < buf3.size();++i) if(buf3.at(i) != ch++) return false; //clear, empty if(buf2.empty()) return false; buf2.clear(); if(!buf2.empty()) return false; //resize buf2.resize(7); if(7 != buf2.size()) return false; //push_back buf2.clear(); if(buf2 == buf4) return false; ch = 'a'; for(int i = 0;i < 7;++i) buf2.push_back(ch + i); if(buf2 != buf4) return false; //swap buf2.swap(buf4); if(str == &buf2[0]) return false; if(str != &buf4[0]) return false; swap(buf4, buf2); if(str == &buf4[0]) return false; if(str != &buf2[0]) return false; //append buf1.clear(); for(size_t i = 0;i < 10;++i) buf1.append(10, 'd'); if(100 != buf1.size()) return false; for(size_t i = 0;i < buf1.size();++i) if(buf1[i] != 'd') return false; buf1.clear(); for(size_t i = 0;i < 20;++i) buf1.append(__CharP"ssdeb"); if(100 != buf1.size()) return false; for(size_t i = 0;i < buf1.size();i += 5) if(0 != memcmp(&buf1[i], "ssdeb", 5)) return false; buf4.assign(__CharP"gadfdengb"); buf1.clear(); for(size_t i = 0;i < 20;++i) buf1.append(buf4, 4, 5); if(100 != buf1.size()) return false; for(size_t i = 0;i < buf1.size();i += 5) if(0 != memcmp(&buf1[i], "dengb", 5)) return false; buf4.resize(5); buf1.clear(); for(size_t i = 0;i < 20;++i) buf1.append(buf4); if(100 != buf1.size()) return false; for(size_t i = 0;i < buf1.size();i += 5) if(0 != memcmp(&buf1[i], "gadfd", 5)) return false; //operator += buf1.clear(); for(size_t i = 0;i < 20;++i) buf1 += __CharP"sgdeb"; if(100 != buf1.size()) return false; for(size_t i = 0;i < buf1.size();i += 5) if(0 != memcmp(&buf1[i], "sgdeb", 5)) return false; buf4.assign(__CharP"f90rg"); buf1.clear(); for(size_t i = 0;i < 20;++i) buf1 += buf4; if(100 != buf1.size()) return false; for(size_t i = 0;i < buf1.size();i += 5) if(0 != memcmp(&buf1[i], "f90rg", 5)) return false; buf1.clear(); for(int i = 0;i < 100;++i) buf1 += 12 + i; if(100 != buf1.size()) return false; for(size_t i = 0;i < buf1.size();++i) if(buf1[i] != 12 + int(i)){ cerr<<"buf1["<<i<<"]="<<int(buf1[i])<<" is not "<<(12 + int(i))<<endl; return false; } //insert buf4.assign(__CharP"3e4r5"); buf1.clear(); buf1 += buf4; if(5 != buf1.size()) return false; for(int i = 0;i < 19;++i) buf1.insert(i * 5 + 3, 5, 'a'); if(100 != buf1.size()){ cerr<<"1: buf1.size()="<<buf1.size()<<" is not 100\n"; return false; } if(0 != memcmp(&buf1[0], &buf4[0], 3)){ cerr<<"1: buf1[0]="<<&buf1[0]<<", buf4[0]="<<&buf4[0]<<endl; return false; } for(int i = 3;i < 98;++i) if('a' != buf1[i]) return false; if(0 != memcmp(&buf1[98], &buf4[3], 2)) return false; buf1.clear(); buf1 += buf4; for(int i = 0;i < 19;++i) buf1.insert(i * 5 + 3, __CharP"3g89a", 5); if(100 != buf1.size()){ cerr<<"2: buf1.size()="<<buf1.size()<<" is not 100\n"; return false; } if(0 != memcmp(&buf1[0], &buf4[0], 3)){ cerr<<"2: buf1[0]="<<&buf1[0]<<", buf4[0]="<<&buf4[0]<<endl; return false; } for(int i = 0;i < 19;++i) if(0 != memcmp("3g89a", &buf1[i * 5 + 3], 5)) return false; if(0 != memcmp(&buf1[98], &buf4[3], 2)) return false; buf1.clear(); buf1 += buf4; for(int i = 0;i < 19;++i) buf1.insert(i * 5 + 3, __CharP"3g89a"); if(100 != buf1.size()){ cerr<<"3: buf1.size()="<<buf1.size()<<" is not 100\n"; return false; } if(0 != memcmp(&buf1[0], &buf4[0], 3)){ cerr<<"3: buf1[0]="<<&buf1[0]<<", buf4[0]="<<&buf4[0]<<endl; return false; } for(int i = 0;i < 19;++i) if(0 != memcmp("3g89a", &buf1[i * 5 + 3], 5)) return false; if(0 != memcmp(&buf1[98], &buf4[3], 2)) return false; buf4.assign(__CharP"23e32t2g22"); buf1.clear(); buf1.append(buf4, 0, 5); for(int i = 0;i < 19;++i) buf1.insert(i * 5 + 3, buf4, 4, 5); if(100 != buf1.size()){ cerr<<"4: buf1.size()="<<buf1.size()<<" is not 100\n"; return false; } if(0 != memcmp(&buf1[0], &buf4[0], 3)){ cerr<<"4: buf1[0]="<<&buf1[0]<<", buf4[0]="<<&buf4[0]<<endl; return false; } for(int i = 0;i < 19;++i) if(0 != memcmp(&buf4[4], &buf1[i * 5 + 3], 5)) return false; if(0 != memcmp(&buf1[98], &buf4[3], 2)) return false; buf4.resize(5); buf1.clear(); buf1.append(buf4); for(int i = 0;i < 19;++i) buf1.insert(i * 5 + 3, buf4); if(100 != buf1.size()){ cerr<<"5: buf1.size()="<<buf1.size()<<" is not 100\n"; return false; } if(0 != memcmp(&buf1[0], &buf4[0], 3)){ cerr<<"5: buf1[0]="<<&buf1[0]<<", buf4[0]="<<&buf4[0]<<endl; return false; } for(int i = 0;i < 19;++i) if(0 != memcmp(&buf4[0], &buf1[i * 5 + 3], 5)) return false; if(0 != memcmp(&buf1[98], &buf4[3], 2)) return false; buf1.clear(); buf1.append(buf4); for(int i = 0;i < 95;++i){ __Iter p = buf1.insert(buf1.begin() + i + 3, 12 + i); if(*p != 12 + i) return false; } if(100 != buf1.size()){ cerr<<"6: buf1.size()="<<buf1.size()<<" is not 100\n"; return false; } if(0 != memcmp(&buf1[0], &buf4[0], 3)){ cerr<<"6: buf1[0]="<<&buf1[0]<<", buf4[0]="<<&buf4[0]<<endl; return false; } for(int i = 0;i < 95;++i) if(12 + i != buf1[i + 3]) return false; if(0 != memcmp(&buf1[98], &buf4[3], 2)) return false; //replace buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; buf1.replace(4, 3, 3, '0'); if(10 != buf1.size()) return false; if(0 != memcmp("0123000789", &buf1[0], buf1.size())) return false; buf1.replace(4, 3, 5, '1'); if(12 != buf1.size()) return false; if(0 != memcmp("012311111789", &buf1[0], buf1.size())) return false; buf1.replace(4, 5, 3, 'a'); if(10 != buf1.size()) return false; if(0 != memcmp("0123aaa789", &buf1[0], buf1.size())) return false; buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; buf1.replace(4, 3, __CharP"000", 3); if(10 != buf1.size()) return false; if(0 != memcmp("0123000789", &buf1[0], buf1.size())) return false; buf1.replace(4, 3, __CharP"11111", 5); if(12 != buf1.size()) return false; if(0 != memcmp("012311111789", &buf1[0], buf1.size())) return false; buf1.replace(4, 5, __CharP"aaa", 3); if(10 != buf1.size()) return false; if(0 != memcmp("0123aaa789", &buf1[0], buf1.size())) return false; buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; buf1.replace(4, 3, __CharP"000"); if(10 != buf1.size()) return false; if(0 != memcmp("0123000789", &buf1[0], buf1.size())) return false; buf1.replace(4, 3, __CharP"11111"); if(12 != buf1.size()) return false; if(0 != memcmp("012311111789", &buf1[0], buf1.size())) return false; buf1.replace(4, 5, __CharP"aaa"); if(10 != buf1.size()) return false; if(0 != memcmp("0123aaa789", &buf1[0], buf1.size())) return false; buf4.assign(__CharP"00011111aaa"); buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; buf1.replace(4, 3, buf4, 0, 3); if(10 != buf1.size()) return false; if(0 != memcmp("0123000789", &buf1[0], buf1.size())) return false; buf1.replace(4, 3, buf4, 3, 5); if(12 != buf1.size()) return false; if(0 != memcmp("012311111789", &buf1[0], buf1.size())) return false; buf1.replace(4, 5, buf4, 8, 3); if(10 != buf1.size()) return false; if(0 != memcmp("0123aaa789", &buf1[0], buf1.size())) return false; buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; buf4.assign(__CharP"000"); buf1.replace(4, 3, buf4); if(10 != buf1.size()) return false; if(0 != memcmp("0123000789", &buf1[0], buf1.size())) return false; buf4.assign(__CharP"11111"); buf1.replace(4, 3, buf4); if(12 != buf1.size()) return false; if(0 != memcmp("012311111789", &buf1[0], buf1.size())) return false; buf4.assign(__CharP"aaa"); buf1.replace(4, 5, buf4); if(10 != buf1.size()) return false; if(0 != memcmp("0123aaa789", &buf1[0], buf1.size())) return false; buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; buf1.replace(buf1.begin() + 4, buf1.begin() + 7, 3, '0'); if(10 != buf1.size()) return false; if(0 != memcmp("0123000789", &buf1[0], buf1.size())) return false; buf1.replace(buf1.begin() + 4, buf1.begin() + 7, 5, '1'); if(12 != buf1.size()) return false; if(0 != memcmp("012311111789", &buf1[0], buf1.size())) return false; buf1.replace(buf1.begin() + 4, buf1.begin() + 9, 3, 'a'); if(10 != buf1.size()) return false; if(0 != memcmp("0123aaa789", &buf1[0], buf1.size())) return false; buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; buf1.replace(buf1.begin() + 4, buf1.begin() + 7, __CharP"000", 3); if(10 != buf1.size()) return false; if(0 != memcmp("0123000789", &buf1[0], buf1.size())) return false; buf1.replace(buf1.begin() + 4, buf1.begin() + 7, __CharP"11111", 5); if(12 != buf1.size()) return false; if(0 != memcmp("012311111789", &buf1[0], buf1.size())) return false; buf1.replace(buf1.begin() + 4, buf1.begin() + 9, __CharP"aaa", 3); if(10 != buf1.size()) return false; if(0 != memcmp("0123aaa789", &buf1[0], buf1.size())) return false; buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; buf1.replace(buf1.begin() + 4, buf1.begin() + 7, __CharP"000"); if(10 != buf1.size()) return false; if(0 != memcmp("0123000789", &buf1[0], buf1.size())) return false; buf1.replace(buf1.begin() + 4, buf1.begin() + 7, __CharP"11111"); if(12 != buf1.size()) return false; if(0 != memcmp("012311111789", &buf1[0], buf1.size())) return false; buf1.replace(buf1.begin() + 4, buf1.begin() + 9, __CharP"aaa"); if(10 != buf1.size()) return false; if(0 != memcmp("0123aaa789", &buf1[0], buf1.size())) return false; buf4.assign(__CharP"00011111aaa"); buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; buf1.replace(buf1.begin() + 4, buf1.begin() + 7, buf4, 0, 3); if(10 != buf1.size()) return false; if(0 != memcmp("0123000789", &buf1[0], buf1.size())) return false; buf1.replace(buf1.begin() + 4, buf1.begin() + 7, buf4, 3, 5); if(12 != buf1.size()) return false; if(0 != memcmp("012311111789", &buf1[0], buf1.size())) return false; buf1.replace(buf1.begin() + 4, buf1.begin() + 9, buf4, 8, 3); if(10 != buf1.size()) return false; if(0 != memcmp("0123aaa789", &buf1[0], buf1.size())) return false; buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; buf4.assign(__CharP"000"); buf1.replace(buf1.begin() + 4, buf1.begin() + 7, buf4); if(10 != buf1.size()) return false; if(0 != memcmp("0123000789", &buf1[0], buf1.size())) return false; buf4.assign(__CharP"11111"); buf1.replace(buf1.begin() + 4, buf1.begin() + 7, buf4); if(12 != buf1.size()) return false; if(0 != memcmp("012311111789", &buf1[0], buf1.size())) return false; buf4.assign(__CharP"aaa"); buf1.replace(buf1.begin() + 4, buf1.begin() + 9, buf4); if(10 != buf1.size()) return false; if(0 != memcmp("0123aaa789", &buf1[0], buf1.size())) return false; //erase buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; __Iter p = buf1.erase(buf1.begin() + 1, buf1.end() - 2); if(*p != '8') return false; if(3 != buf1.size()) return false; if(0 != memcmp("089", &buf1[0], buf1.size())) return false; buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; p = buf1.erase(buf1.begin() + 5); if(*p != '6') return false; if(9 != buf1.size()) return false; if(0 != memcmp("012346789", &buf1[0], buf1.size())) return false; buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; buf1.erase(3, 4); if(6 != buf1.size()) return false; if(0 != memcmp("012789", &buf1[0], buf1.size())) return false; buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; buf1.erase(6); if(6 != buf1.size()){ cerr<<"buf1.size()="<<buf1.size()<<" is not 6\n"; return false; } return true; if(0 != memcmp("012345", &buf1[0], buf1.size())) return false; //substr buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(0 != memcmp("0123456789", &buf1[0], buf1.size())) return false; buf4 = buf1.substr(2, 7); if(7 != buf4.size()) return false; if(0 != memcmp("2345678", &buf4[0], buf4.size())) return false; //compare buf1.clear(); buf1 += __CharP"0123456789"; if(10 != buf1.size()) return false; if(buf1.compare(2, 5, __CharP"256444", 5)) return false; if(!buf1.compare(2, 5, __CharP"23456444", 5)) return false; if(buf1.compare(2, 5, __CharP"256444")) return false; if(!buf1.compare(2, 5, __CharP"23456")) return false; if(buf1.compare(__CharP"23425")) return false; if(!buf1.compare(__CharP"0123456")) return false; buf4.assign(__CharP"238623456444"); if(buf1.compare(2, 6, buf4, 4, 8)) return false; if(!buf1.compare(2, 5, buf4, 4, 8)) return false; buf4.assign(__CharP"2345626234"); if(buf1.compare(2, 6, buf4)) return false; if(!buf1.compare(2, 5, buf4)) return false; buf4.assign(__CharP"2623424"); if(buf1.compare(buf4)) return false; if(buf1 == buf4) return false; buf4.assign(__CharP"0123456789"); if(!buf1.compare(buf4)) return false; if(buf1 != buf4) return false; //operators ==, !=, <, <=, >, >= buf4.assign(__CharP"0123455789ag"); if((buf1 == buf4)) return false; if(!(buf1 != buf4)) return false; if((buf1 < buf4)) return false; if((buf1 <= buf4)) return false; if(!(buf1 > buf4)) return false; if(!(buf1 >= buf4)) return false; buf4.assign(__CharP"012345678"); if((buf1 == buf4)) return false; if(!(buf1 != buf4)) return false; if((buf1 < buf4)) return false; if((buf1 <= buf4)) return false; if(!(buf1 > buf4)) return false; if(!(buf1 >= buf4)) return false; buf4.assign(__CharP"0123456789"); if(!(buf1 == buf4)) return false; if((buf1 != buf4)) return false; if((buf1 < buf4)) return false; if(!(buf1 <= buf4)) return false; if((buf1 > buf4)) return false; if(!(buf1 >= buf4)) return false; buf4.assign(__CharP"012345688"); if((buf1 == buf4)) return false; if(!(buf1 != buf4)) return false; if(!(buf1 < buf4)) return false; if(!(buf1 <= buf4)) return false; if((buf1 > buf4)) return false; if((buf1 >= buf4)) return false; buf4.assign(__CharP"01234567890"); if((buf1 == buf4)) return false; if(!(buf1 != buf4)) return false; if(!(buf1 < buf4)) return false; if(!(buf1 <= buf4)) return false; if((buf1 > buf4)) return false; if((buf1 >= buf4)) return false; const Char * cstr = __CharP"0123455789ag"; if((buf1 == cstr)) return false; if(!(buf1 != cstr)) return false; if((buf1 < cstr)) return false; if((buf1 <= cstr)) return false; if(!(buf1 > cstr)) return false; if(!(buf1 >= cstr)) return false; cstr = __CharP"012345678"; if((buf1 == cstr)) return false; if(!(buf1 != cstr)) return false; if((buf1 < cstr)) return false; if((buf1 <= cstr)) return false; if(!(buf1 > cstr)) return false; if(!(buf1 >= cstr)) return false; cstr = __CharP"0123456789"; if(!(buf1 == cstr)) return false; if((buf1 != cstr)) return false; if((buf1 < cstr)) return false; if(!(buf1 <= cstr)) return false; if((buf1 > cstr)) return false; if(!(buf1 >= cstr)) return false; cstr = __CharP"012345688"; if((buf1 == cstr)) return false; if(!(buf1 != cstr)) return false; if(!(buf1 < cstr)) return false; if(!(buf1 <= cstr)) return false; if((buf1 > cstr)) return false; if((buf1 >= cstr)) return false; cstr = __CharP"01234567890"; if((buf1 == cstr)) return false; if(!(buf1 != cstr)) return false; if(!(buf1 < cstr)) return false; if(!(buf1 <= cstr)) return false; if((buf1 > cstr)) return false; if((buf1 >= cstr)) return false; cstr = __CharP"0123455789"; buf4.assign(__CharP"0123455789ag"); if((cstr == buf4)) return false; if(!(cstr != buf4)) return false; if((cstr < buf4)) return false; if((cstr <= buf4)) return false; if(!(cstr > buf4)) return false; if(!(cstr >= buf4)) return false; buf4.assign(__CharP"012345678"); if((cstr == buf4)) return false; if(!(cstr != buf4)) return false; if((cstr < buf4)) return false; if((cstr <= buf4)) return false; if(!(cstr > buf4)) return false; if(!(cstr >= buf4)) return false; buf4.assign(__CharP"0123456789"); if(!(cstr == buf4)) return false; if((cstr != buf4)) return false; if((cstr < buf4)) return false; if(!(cstr <= buf4)) return false; if((cstr > buf4)) return false; if(!(cstr >= buf4)) return false; buf4.assign(__CharP"012345688"); if((cstr == buf4)) return false; if(!(cstr != buf4)) return false; if(!(cstr < buf4)) return false; if(!(cstr <= buf4)) return false; if((cstr > buf4)) return false; if((cstr >= buf4)) return false; buf4.assign(__CharP"01234567890"); if((cstr == buf4)) return false; if(!(cstr != buf4)) return false; if(!(cstr < buf4)) return false; if(!(cstr <= buf4)) return false; if((cstr > buf4)) return false; if((cstr >= buf4)) return false; return true; }
PXR_NAMESPACE_USING_DIRECTIVE ARCH_PRAGMA_DEPRECATED_POSIX_NAME int main() { std::string firstName = ArchMakeTmpFileName("archFS"); FILE *firstFile; char const * const testContent = "text in a file"; // Open a file, check that its length is 0, write to it, close it, and then // check that its length is now the number of characters written. ARCH_AXIOM((firstFile = ArchOpenFile(firstName.c_str(), "wb")) != NULL); fflush(firstFile); ARCH_AXIOM(ArchGetFileLength(firstName.c_str()) == 0); fputs(testContent, firstFile); fclose(firstFile); ARCH_AXIOM(ArchGetFileLength(firstName.c_str()) == strlen(testContent)); // Map the file and assert the bytes are what we expect they are. ARCH_AXIOM((firstFile = ArchOpenFile(firstName.c_str(), "rb")) != NULL); ArchConstFileMapping cfm = ArchMapFileReadOnly(firstFile); fclose(firstFile); ARCH_AXIOM(cfm); ARCH_AXIOM(memcmp(testContent, cfm.get(), strlen(testContent)) == 0); cfm.reset(); // Try again with a mutable mapping. ARCH_AXIOM((firstFile = ArchOpenFile(firstName.c_str(), "rb")) != NULL); ArchMutableFileMapping mfm = ArchMapFileReadWrite(firstFile); fclose(firstFile); ARCH_AXIOM(mfm); ARCH_AXIOM(memcmp(testContent, mfm.get(), strlen(testContent)) == 0); // Check that we can successfully mutate. mfm.get()[0] = 'T'; mfm.get()[2] = 's'; ARCH_AXIOM(memcmp("Test", mfm.get(), strlen("Test")) == 0); mfm.reset(); ArchUnlinkFile(firstName.c_str()); // Test ArchPWrite and ArchPRead. int64_t len = strlen(testContent); ARCH_AXIOM((firstFile = ArchOpenFile(firstName.c_str(), "w+b")) != NULL); ARCH_AXIOM(ArchPWrite(firstFile, testContent, len, 0) == len); std::unique_ptr<char[]> buf(new char[len]); ARCH_AXIOM(ArchPRead(firstFile, buf.get(), len, 0) == len); ARCH_AXIOM(memcmp(testContent, buf.get(), len) == 0); char const * const newText = "overwritten in a file"; ARCH_AXIOM(ArchPWrite(firstFile, newText, strlen(newText), 5/*index of 'in a file'*/) == strlen(newText)); std::unique_ptr<char[]> buf2(new char[strlen("written in a")]); ARCH_AXIOM(ArchPRead(firstFile, buf2.get(), strlen("written in a"), 9/*index of 'written in a'*/) == strlen("written in a")); ARCH_AXIOM(memcmp("written in a", buf2.get(), strlen("written in a")) == 0); // create and remove a tmp subdir std::string retpath; retpath = ArchMakeTmpSubdir(ArchGetTmpDir(), "myprefix"); ARCH_AXIOM (retpath != ""); ArchRmDir(retpath.c_str()); return 0; }
void ManyFields::deserialize(carbon::CarbonProtocolReader& reader) { reader.readStructBegin(); while (true) { const auto pr = reader.readFieldHeader(); const auto fieldType = pr.first; const auto fieldId = pr.second; if (fieldType == carbon::FieldType::Stop) { break; } switch (fieldId) { case 1: { reader.readField(buf1(), fieldType); break; } case 2: { reader.readField(buf2(), fieldType); break; } case 3: { reader.readField(buf3(), fieldType); break; } case 4: { reader.readField(buf4(), fieldType); break; } case 5: { reader.readField(buf5(), fieldType); break; } case 6: { reader.readField(buf6(), fieldType); break; } case 7: { reader.readField(buf7(), fieldType); break; } case 8: { reader.readField(buf8(), fieldType); break; } case 9: { reader.readField(buf9(), fieldType); break; } case 10: { reader.readField(buf10(), fieldType); break; } case 11: { reader.readField(buf11(), fieldType); break; } case 12: { reader.readField(buf12(), fieldType); break; } case 13: { reader.readField(buf13(), fieldType); break; } case 14: { reader.readField(buf14(), fieldType); break; } case 15: { reader.readField(buf15(), fieldType); break; } case 16: { reader.readField(buf16(), fieldType); break; } case 17: { reader.readField(buf17(), fieldType); break; } case 18: { reader.readField(buf18(), fieldType); break; } case 19: { reader.readField(buf19(), fieldType); break; } case 20: { reader.readField(buf20(), fieldType); break; } case 21: { reader.readField(buf21(), fieldType); break; } case 22: { reader.readField(buf22(), fieldType); break; } case 23: { reader.readField(buf23(), fieldType); break; } case 24: { reader.readField(buf24(), fieldType); break; } case 25: { reader.readField(buf25(), fieldType); break; } case 26: { reader.readField(buf26(), fieldType); break; } case 27: { reader.readField(buf27(), fieldType); break; } case 28: { reader.readField(buf28(), fieldType); break; } case 29: { reader.readField(buf29(), fieldType); break; } case 30: { reader.readField(buf30(), fieldType); break; } case 31: { reader.readField(buf31(), fieldType); break; } case 32: { reader.readField(buf32(), fieldType); break; } case 33: { reader.readField(buf33(), fieldType); break; } case 34: { reader.readField(buf34(), fieldType); break; } case 35: { reader.readField(buf35(), fieldType); break; } case 36: { reader.readField(buf36(), fieldType); break; } case 37: { reader.readField(buf37(), fieldType); break; } case 38: { reader.readField(buf38(), fieldType); break; } case 39: { reader.readField(buf39(), fieldType); break; } case 40: { reader.readField(buf40(), fieldType); break; } default: { reader.skip(fieldType); break; } } } reader.readStructEnd(); }
int main(int argc, char **argv) { time(); if (argc < 2) { printf("Usage: %s <exp> to Lucas-Lehmer test 2^exp - 1 \n", argv[0]); exit(1); } int exp = atoi(argv[1]); int words = SIZE / 2; int bitsPerWord = exp / words + 1; // 'exp' being prime, 'words' does not divide it. if (bitsPerWord < 2) { bitsPerWord = 2; } // Min 2 bits/word. int wordsUsed = exp / bitsPerWord + 1; printf("Lucas-Lehmer test for 2^%d - 1. %d words, %d bits/word, %d words used\n", exp, words, bitsPerWord, wordsUsed); Context c; Queue queue(c); Program program; time("OpenCL init"); program.compileCL2(c, "conv.cl"); K(program, dif2); K(program, dif4); K(program, dif8); K(program, dit2); K(program, dit4); K(program, dit8); K(program, dit8d); // K(program, sq2k); K(program, mul); time("Kernels compilation"); /* Buf bitsBuf(c, CL_MEM_READ_WRITE, sizeof(int) * words, 0); int data = 0; clEnqueueFillBuffer(queue.queue, bitsBuf.buf, &data, sizeof(data), 0, words, 0, 0, 0); data = 4; // LL seed queue.writeBlocking(bitsBuf, &data, sizeof(data)); */ int *data = new int[SIZE]; srandom(0); for (int i = 0; i < SIZE; ++i) { data[i] = (random() & 0xffffff) - (1 << 23); } time("random"); Buf buf1(c, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(int) * SIZE, data); Buf buf2(c, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(int) * SIZE, data); Buf bufTmp(c, CL_MEM_READ_WRITE, sizeof(int) * SIZE, 0); time("alloc gpu buffers"); mul.setArgs(buf1); queue.run(mul, 256, 8 * 1024 * 1024 / 4); queue.finish(); time("sq2k ini"); for (int i = 0; i < 1000; ++i) { mul.setArgs(buf1); queue.run(mul, 256, 8 * 1024 * 1024 / 4); } queue.finish(); time("sq2k"); exit(0); for (int round = 3; round >= 0; round -= 2) { dif8.setArgs(round, buf1, bufTmp); queue.run(dif8, GS, SIZE / 32); dif8.setArgs(round - 1, bufTmp, buf1); queue.run(dif8, GS, SIZE / 32); } std::unique_ptr<long[]> tmpLong1(new long[SIZE]); { std::unique_ptr<int[]> tmp1(new int[SIZE]); queue.readBlocking(&buf1, 0, sizeof(int) * SIZE, tmp1.get()); for (int i = 0; i < SIZE; ++i) { tmpLong1[i] = tmp1[i]; } } Buf bufLong1(c, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(long) * SIZE, tmpLong1.get()); Buf bufLongTmp(c, CL_MEM_READ_WRITE, sizeof(long) * SIZE, 0); for (int round = 0; round < 4; round += 2) { dit8.setArgs(round, bufLong1, bufLongTmp); queue.run(dit8, GS, SIZE / 32); dit8.setArgs(round + 1, bufLongTmp, bufLong1); queue.run(dit8, GS, SIZE / 32); } queue.readBlocking(&bufLong1, 0, sizeof(long) * SIZE, tmpLong1.get()); int err = 0; for (int i = 0; i < SIZE; ++i) { if (data[i] != tmpLong1[i]) { printf("%d %d %ld\n", i, data[i], tmpLong1[i]); if (++err >= 10) { exit(1); } } } time("OK FFT radix8 round-trip"); for (int i = 0; i < 100; ++i) { for (int round = 11; round > 0; round -= 2) { dif2.setArgs(round, buf2, bufTmp); queue.run(dif2, GS, words); dif2.setArgs(round - 1, bufTmp, buf2); queue.run(dif2, GS, words); } } queue.finish(); time("perf DIF2"); for (int i = 0; i < 100; ++i) { for (int round = 5; round > 0; round -= 2) { dif4.setArgs(round, buf1, bufTmp); queue.run(dif4, GS, (words * 2) / 8); dif4.setArgs(round - 1, bufTmp, buf1); queue.run(dif4, GS, (words * 2) / 8); } } queue.finish(); time("perf DIF4"); for (int i = 0; i < 100; ++i) { for (int round = 3; round > 0; round -= 2) { dif8.setArgs(round, buf1, bufTmp); queue.run(dif8, GS, SIZE / 32); dif8.setArgs(round - 1, bufTmp, buf1); queue.run(dif8, GS, SIZE / 32); } } queue.finish(); time("perf DIF8"); for (int i = 0; i < 100; ++i) { for (int round = 0; round < 12; round += 2) { dit2.setArgs(round, bufLong1, bufLongTmp); queue.run(dit2, GS, SIZE / 2); dit2.setArgs(round + 1, bufLongTmp, bufLong1); queue.run(dit2, GS, SIZE / 2); } } queue.finish(); time("perf DIT2"); for (int i = 0; i < 100; ++i) { for (int round = 0; round < 6; round += 2) { dit4.setArgs(round, bufLong1, bufLongTmp); queue.run(dit4, GS, SIZE / 8); dit4.setArgs(round + 1, bufLongTmp, bufLong1); queue.run(dit4, GS, SIZE / 8); } } queue.finish(); time("perf DIT4"); for (int i = 0; i < 100; ++i) { for (int round = 0; round < 4; round += 2) { dit8.setArgs(round, bufLong1, bufLongTmp); queue.run(dit8, GS, SIZE / 32); dit8.setArgs(round + 1, bufLongTmp, bufLong1); queue.run(dit8, GS, SIZE / 32); } } queue.finish(); time("perf DIT8"); for (int i = 0; i < 100; ++i) { for (int round = 0; round < 4; round += 2) { dit8d.setArgs(round, bufLong1, bufLongTmp); queue.run(dit8d, GS, SIZE / 32); dit8d.setArgs(round + 1, bufLongTmp, bufLong1); queue.run(dit8d, GS, SIZE / 32); } } queue.finish(); time("perf DIT8d"); /* sq4k.setArgs(buf1, buf2); for (int i = 0; i < 1000; ++i) { queue.run(sq4k, GS, words * GS / (64 * 64)); } queue.finish(); time("sq4k"); */ /* // Initial DIF round on zero-padded input. difIniZeropad.setArgs(bitsBuf, buf2); for (int i = 0; i < 100; ++i) { queue.run(difIniZeropad, GS, SIZE / 4); dif2.setArgs(10, buf2, buf1); queue.run(dif2, GS, SIZE / 2); for (int i = 0; i < 5; ++i) { dif2.setArgs(9 - i * 2, buf1, buf2); queue.run(dif2, GS, SIZE / 2); dif2.setArgs(8 - i * 2, buf2, buf1); queue.run(dif2, GS, SIZE / 2); } } queue.finish(); time("dif1"); */ //difIniZeropadShifted.setArgs(bitsBuf, buf2); /* for (int i = 0; i < 5; ++i) { dit2.setArgs(i * 2, bigBuf, tmpBuf); queue.run(dit2, GS, SIZE / 2); dit2.setArgs(i * 2 + 1, tmpBuf, bigBuf); queue.run(dit2, GS, SIZE / 2); } queue.finish(); time("dit2"); queue.readBlocking(bigBuf, 0, sizeof(int) * SIZE, big2); time("read from gpu"); */ /* int err = 0; for (int i = 0; i < SIZE; ++i) { if (big1[i] != big2[i]) { printf("%d %d %d\n", i, big1[i], big2[i]); ++err; if (err > 10) { break; } } } if (!err) { printf("OK\n"); } */ }
DWORD ServerHandler() { bool running = true; // Socket handler SOCKET socketHnd; // Winsock data WSADATA wsaData; // Check for error if (WSAStartup(WSCK_V2, &wsaData)) { errorFlags &= ERR_STARTUP; running = false; } // We want version 2 if (wsaData.wVersion != WSCK_V2) { errorFlags &= ERR_WRONGVERSION; running = false; } // For TCP... SOCKADDR_IN sckAddr; sckAddr.sin_family = AF_INET; sckAddr.sin_port = htons(9009); // Port 9009, will probably change to load from a config file later sckAddr.sin_addr.s_addr = htonl(INADDR_ANY); // Listen from connections from ANY computer // Create the socket socketHnd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (socketHnd == INVALID_SOCKET) { errorFlags &= ERR_SOCKETERR; running = false; } if (bind(socketHnd, (LPSOCKADDR)&sckAddr, sizeof(sckAddr)) == SOCKET_ERROR) { errorFlags &= ERR_BINDERR; running = false; } if (running && errorFlags == 0) { MessageBoxA(NULL, "Server initialized, close this window to begin listening!", "Info", MB_ICONINFORMATION); // Listen with one backlog max listen(socketHnd, 1); } // player X and Y, 4 bytes at 0049E654 and 0049E658 DWORD *playerX; DWORD *playerY; DWORD *playerMapID; PACKETHEADER PID; while (running) { playerX = (DWORD*)0x0049E654; playerY = (DWORD*)0x0049E658; playerMapID = (DWORD*)0x004A57F0; // Ctrl + F12 unloads the DLL if (GetKeyState(VK_CONTROL) && GetKeyState(VK_F12)) running = false; // If polled to exit then stop running if (poll_exit) running = false; /*========================================= /* Data sending /*=========================================*/ Buffer buf(13); // 13 bytes in length buf.WriteByte(ID_LOC); buf.WriteInt((int)&playerX); buf.WriteInt((int)&playerY); buf.WriteInt((int)&playerMapID); send(socketHnd, (char*)buf.GetBytes(), buf.GetLength(), 0); //buf.Clear(); Buffer buf2(80); // Pass the old buffer pointer recv(socketHnd, (char*)buf2.GetBytes(), sizeof(buf2.GetBytes())-1, 0); // Sleep to allow execution of other threads (and limit actions to about 30 FPS) Sleep(34); } //MessageBoxA(NULL, "test", "test", NULL); WSACleanup(); //if (errorFlags > 0) //{ // char errMsg[1024]; // strcpy(errMsg, "There were error(s):\n"); // if (errorFlags & ERR_STARTUP) // strcat(errMsg, "An error occurred while WinSock was initializing\n"); // if (errorFlags & ERR_WRONGVERSION) // strcat(errMsg, "WinSock initialized the wrong version\n"); // if (errorFlags & ERR_SOCKETERR) // strcat(errMsg, "Socket creation failed\n"); // if (errorFlags & ERR_BINDERR) // strcat(errMsg, "Socket bind failed\n"); // // MessageBoxA(NULL, errMsg, "Error", MB_ICONERROR); //} return 0; }
void Scheme::Load(CScintilla& sc, bool allSettings, LPCTSTR filename) { CFile cfile; SchemeHdrRec hdr; MsgRec Msg; TextRec Txt; PropRec Prp; char Next2; memset(&m_CommentSpec, 0, sizeof(CommentSpecRec)); if( filename ) { SetFileName(filename); } if( cfile.Open(m_SchemeFile) ) { // Check the file is OK and read the header. if(!InitialLoad(cfile, hdr)) { UNEXPECTED(_T("Tried to load invalid binary scheme file at run-time")); cfile.Close(); return; } // Set the defaults - these may be changed by the load. SetupScintilla(sc, allSettings); std::vector<char> buf; while (cfile.GetPosition() < cfile.GetLength()) { cfile.Read(&Next2, sizeof(char)); switch(Next2) { case nrMsgRec: cfile.Read(&Msg, sizeof(MsgRec)); sc.SPerform(Msg.MsgNum, Msg.wParam, Msg.lParam); break; case nrTextRec: { cfile.Read(&Txt, sizeof(TextRec)); buf.resize(Txt.TextLength + 1); cfile.Read(&buf[0], Txt.TextLength*sizeof(char)); buf[Txt.TextLength] = '\0'; switch(Txt.TextType) { case ttFontName : sc.SPerform(SCI_STYLESETFONT, Txt.wParam, (long)&buf[0]); break; case ttKeywords : sc.SetKeyWords(Txt.wParam, &buf[0]); break; case ttLexerLanguage : { sc.SPerform(SCI_SETLEXERLANGUAGE, 0, (long)&buf[0]); m_Lexer = &buf[0]; } break; case ttWordChars : { sc.SPerform(SCI_SETWORDCHARS, 0, (long)&buf[0]); } break; } } break; case nrPropRec: { cfile.Read(&Prp, sizeof(PropRec)); buf.resize(Prp.NameLength + 1); cfile.Read(&buf[0], Prp.NameLength * sizeof(char)); buf[Prp.NameLength] = '\0'; std::vector<char> buf2(Prp.ValueLength + 1); cfile.Read(&buf2[0], Prp.ValueLength * sizeof(char)); buf2[Prp.ValueLength] = '\0'; sc.SPerform(SCI_SETPROPERTY, (long)&buf[0], (long)&buf2[0]); } break; case nrCommentRec: { // skip here... cfile.Read(&m_CommentSpec, sizeof(CommentSpecRec)); } break; } } cfile.Close(); if((hdr.Flags & fldEnabled) && OPTIONS->GetCached(Options::OFoldingEnabled)) { ///@todo obviously these details need to come from settings somewhere... sc.SPerform(SCI_SETPROPERTY, (WPARAM)"fold", (LPARAM)"1"); sc.SPerform(SCI_SETMARGINTYPEN, 2, SC_MARGIN_SYMBOL); sc.SPerform(SCI_SETMARGINMASKN, 2, SC_MASK_FOLDERS); sc.SPerform(SCI_SETMARGINSENSITIVEN, 2, true); sc.SPerform(SCI_SETMARGINWIDTHN, 2, 14); sc.SPerform(SCI_SETFOLDFLAGS, 16, 0); sc.SetFoldingMargins(efsVSNet); sc.SPerform(SCI_SETPROPERTY, (WPARAM)"fold.compact", (LPARAM)((hdr.Flags & fldCompact) ? "1" : "0")); if(hdr.Flags & fldComments) sc.SPerform(SCI_SETPROPERTY, (WPARAM)"fold.comment", (LPARAM)"1"); if(hdr.Flags & fldPreProc) sc.SPerform(SCI_SETPROPERTY, (WPARAM)"fold.preprocessor", (LPARAM)"1"); if(hdr.Flags & fldElse) sc.SPerform(SCI_SETPROPERTY, (WPARAM)"fold.at.else", (LPARAM)"1"); } if(hdr.Flags & schOverrideTabs) { if(hdr.Flags & schUseTabs) sc.SPerform(SCI_SETUSETABS, 1, 0); else sc.SPerform(SCI_SETUSETABS, 0, 0); } if(hdr.Flags & schOverrideTabSize) { sc.SPerform(SCI_SETTABWIDTH, hdr.TabWidth, 0); } } else { // Show an error or something... } }
// Based on routines in gdb/remote.c int CeCosTestDownloadFilter::put_binary (unsigned char* buf, int len, unsigned long dl_address, int packet_size, CeCosSerial& serial) { int i; unsigned char csum; Buffer buf2(packet_size); unsigned char ch; int tcount = 0; unsigned char *p, *p2, *plen; while (len > 0) { /* Subtract header overhead from MAX payload size: $M<memaddr>,<len>:#nn */ int max_buf_size = buf2.Size() - ( 2 + hexnumlen(dl_address) + 1 + hexnumlen(buf2.Size()) + 4); /* Copy the packet into buffer BUF2, encapsulating it and giving it a checksum. */ int todo = MIN (len, max_buf_size); p = (unsigned char*) buf2.Data(); *p++ = '$'; // Add X header. *p++ = 'X'; p += hexnumstr(p, dl_address); *p++ = ','; plen = p; /* remember where len field goes */ p += hexnumstr(p, todo); *p++ = ':'; int escaped = 0; for (i = 0; (i < todo) && (i + escaped) < (max_buf_size - 2); i++) { switch (buf[i] & 0xff) { case '$': case '#': case 0x7d: /* These must be escaped */ escaped++; *p++ = 0x7d; *p++ = (unsigned char) ((buf[i] & 0xff) ^ 0x20); break; default: *p++ = (unsigned char) (buf[i] & 0xff); break; } } if (i < todo) { /* Escape chars have filled up the buffer prematurely, and we have actually sent fewer bytes than planned. Fix-up the length field of the packet. */ /* FIXME: will fail if new len is a shorter string than old len. */ plen += hexnumstr (plen, i); *plen++ = ':'; } // Calculate checksum p2 = (unsigned char*)buf2.Data(); p2++; // skip $ csum = 0; while (p2 < p) csum = (unsigned char)(csum + *p2++); *p++ = '#'; *p++ = (unsigned char) tohex ((csum >> 4) & 0xf); *p++ = (unsigned char) tohex (csum & 0xf); /* Send it over and over until we get a positive ack. */ int resend = 1; const unsigned char* write_ptr = (const unsigned char*) buf2.Data(); int write_len = (int)p-(int)buf2.Data(); while (resend) { unsigned int __written; Trace("Sending bytes for %p-%p\n", dl_address, dl_address+i); TargetWrite(serial, write_ptr, write_len); /* read until either a timeout occurs (-2) or '+' is read */ for(;;) { unsigned int __read; serial.Read(&ch, 1, __read); if (0 == __read) { tcount ++; if (tcount > 3) { Trace("Timeout in putpkt_binary\n"); return 0; } break; /* Retransmit buffer */ } switch (ch) { case '+': // Now expect OK packet from target unsigned char ok_msg[6];// $OK#9a serial.Read(ok_msg, 6, __read); // Reply with ACK serial.Write((void*)"+", 1, __written); // And process next packet. resend = 0; break; case '-': // Bad packet CRC. Retransmit. Trace ("Bad CRC\n"); break; default: Trace("Got junk..%02x\n", ch); continue; // keep reading } break; /* Here to retransmit */ } } len -= i; dl_address += i; buf += i; } return 1; }
void nta::ArrayTest::testArrayCreation() { boost::scoped_ptr<ArrayBase> arrayP; TestCaseIterator testCase; for(testCase = testCases_.begin(); testCase != testCases_.end(); testCase++) { char *buf = (char *) -1; if(testCase->second.testUsesInvalidParameters) { bool caughtException = false; try { arrayP.reset(new ArrayBase(testCase->second.dataType)); } catch(nta::Exception) { caughtException = true; } TEST2("Test case: " + testCase->first + " - Should throw an exception on trying to create an invalid " "ArrayBase", caughtException); } else { arrayP.reset(new ArrayBase(testCase->second.dataType)); buf = (char *) arrayP->getBuffer(); TEST2("Test case: " + testCase->first + " - When not passed a size, a newly created ArrayBase should " "have a NULL buffer", buf == NULL); TESTEQUAL2("Test case: " + testCase->first + " - When not passed a size, a newly created ArrayBase should " "have a count equal to zero", (size_t) 0, arrayP->getCount()); boost::scoped_array<char> buf2(new char[testCase->second.dataTypeSize * testCase->second.allocationSize]); arrayP.reset(new ArrayBase(testCase->second.dataType, buf2.get(), testCase->second.allocationSize)); buf = (char *) arrayP->getBuffer(); TEST2("Test case: " + testCase->first + " - Preallocating a buffer for a newly created ArrayBase should " "use the provided buffer", buf == buf2.get()); TESTEQUAL2("Test case: " + testCase->first + " - Preallocating a buffer should have a count equal to our " "allocation size", (size_t) testCase->second.allocationSize, arrayP->getCount()); } } }
int main() { #if 1 const char* sss = "[{\"DataKey1\": \"BindRule\", \"DataValue\": {\"waittime\": \"7\"}, \"null_key\": \"null\"},\r\n" "{\"DataKey2\": \"BindRule\", \"DataValue\": {\"waittime\": \"7\"}, \"null_key\": \"null\"},\r\n" "{\"member\": [25, 26, 27, 28, 29, true, false]},\r\n" "{\"max_uint64\": 18446744073709551615},\r\n" "[\"string\", true, false, 100, 200, 300, null, null],\r\n" "{\"hello world\": true, \"name\": null, \"age\": 25}]\r\n" "{\"hello\" : \"world\"} \r\n"; #else const char* sss = "{\"name\": \"100\"}"; #endif acl::json json; const char* ptr = json.update(sss); printf("-------------------------------------------------------\r\n"); printf("%s\r\n", sss); printf("-------------------------------------------------------\r\n"); printf("json finish: %s, left char: %s\r\n", json.finish() ? "yes" : "no", ptr); printf(">>>to string: %s\r\n", json.to_string().c_str()); const char* ss = "[{\"DataKey1\": \"BindRule\", \"DataValue\": {\"waittime\": \"7\"}, \"null_key\": \"null\"}, " "{\"DataKey2\": \"BindRule\", \"DataValue\": {\"waittime\": \"7\"}, \"null_key\": \"null\"}, " "{\"member\": [25, 26, 27, 28, 29, true, false]}, " "{\"max_uint64\": 18446744073709551615 }, " "[\"string\", true, false, 100, 200, 300, null, null], " "{\"hello world\": true, \"name\": null, \"age\": 25}]"; printf("-------------------------------------------------------\r\n"); acl::string buf1(json.to_string()), buf2(ss); buf1.trim_space().trim_line(); buf2.trim_space().trim_line(); if (buf1 == buf2) printf("All OK\r\n\r\n"); else { printf("Error\r\n"); printf("-------------------------------------------------------\r\n"); printf("%s\r\n", ss); printf("-------------------------------------------------------\r\n"); printf("%s\r\n", json.to_string().c_str()); printf("\r\n"); exit (1); } test_type(json, "hello world"); test_type(json, "name"); test_type(json, "age"); test_type(json, "member"); test_type(json, "DataKey1"); test_type(json, "DataValue"); test_type(json, "null_key"); test_type(json, "string"); test_type(json, "waittime"); test_type(json, "max_uint64"); test_int64(json, "age"); test_int64(json, "max_uint64"); #if defined(_WIN32) || defined(_WIN64) printf("Enter any key to exit ..."); fflush(stdout); getchar(); #endif return 0; }
bool buffer_test(const char* archive_type, const char* io_type) { // binary: 4(header) + 4(string length) +21(string)= 29 // text : 5(header) +1(space) + 2(string length) + 1(space) +21(string) = 30 static const char str1[] = "intrusive buffer test"; yas::intrusive_buffer buf1(str1, sizeof(str1)-1); typename archive_traits::oarchive oa1; archive_traits::ocreate(oa1, archive_type, io_type); oa1 & buf1; // binary if ( yas::is_binary_archive<typename archive_traits::oarchive_type>::value ) { static const unsigned char _res64_le[] = { _HEADER_BYTES(),0x43,0x15,0x00,0x00,0x00,0x69,0x6e,0x74,0x72,0x75,0x73 ,0x69,0x76,0x65,0x20,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x74,0x65,0x73,0x74 }; static const unsigned char _res32_le[] = { _HEADER_BYTES(),0x03,0x15,0x00,0x00,0x00,0x69,0x6e,0x74,0x72,0x75,0x73 ,0x69,0x76,0x65,0x20,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x74,0x65,0x73,0x74 }; static const unsigned char _res64_be[] = { _HEADER_BYTES(),0x44,0x00,0x00,0x00,0x15,0x69,0x6e,0x74,0x72,0x75,0x73 ,0x69,0x76,0x65,0x20,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x74,0x65,0x73,0x74 }; static const unsigned char _res32_be[] = { _HEADER_BYTES(),0x03,0x00,0x00,0x00,0x15,0x69,0x6e,0x74,0x72,0x75,0x73 ,0x69,0x76,0x65,0x20,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x74,0x65,0x73,0x74 }; const unsigned char *res_ptr = ( YAS_PLATFORM_BITS_IS_64() ? oa1.is_little_endian() ? _res64_le : _res64_be : oa1.is_little_endian() ? _res32_le : _res32_be ); const unsigned int res_size= ( YAS_PLATFORM_BITS_IS_64() ? oa1.is_little_endian() ? sizeof(_res64_le) : sizeof(_res64_be) : oa1.is_little_endian() ? sizeof(_res32_le) : sizeof(_res32_be) ); if ( oa1.size() != res_size ) { std::cout << "BUFFER intrusive serialization error! [1]" << std::endl; return false; } if ( !oa1.compare(res_ptr, res_size) ) { std::cout << "BUFFER intrusive serialization error! [2]" << std::endl; return false; } // text } else if ( yas::is_text_archive<typename archive_traits::oarchive_type>::value ) { static const unsigned char res64[] = { // "yas49 0221intrusive buffer test" _HEADER_BYTES(),0x34,0x39,0x20,0x30,0x32,0x32,0x31,0x69,0x6e,0x74,0x72,0x75,0x73 ,0x69,0x76,0x65,0x20,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x74,0x65,0x73,0x74 }; static const unsigned char res32[] = { // "yas09 0221intrusive buffer test" _HEADER_BYTES(),0x30,0x39,0x20,0x30,0x32,0x32,0x31,0x69,0x6e,0x74,0x72,0x75,0x73 ,0x69,0x76,0x65,0x20,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x74,0x65,0x73,0x74 }; const unsigned char *res_ptr = (YAS_PLATFORM_BITS_IS_64()) ? res64 : res32; const unsigned int res_size = (YAS_PLATFORM_BITS_IS_64()) ? sizeof(res64) : sizeof(res32); if ( oa1.size() != res_size ) { std::cout << "BUFFER intrusive serialization error! [3]" << std::endl; return false; } if ( !oa1.compare(res_ptr, res_size) ) { std::cout << "BUFFER intrusive serialization error! [4]" << std::endl; return false; } // json } else if ( yas::is_json_archive<typename archive_traits::oarchive_type>::value ) { std::cout << "BUFFER intrusive serialization error! json is not implemented!" << std::endl; return false; } static const char str2[] = "shared buffer test"; // 18 + 4(header) + 4(size of array) = 26 yas::shared_buffer buf2(str2, sizeof(str2)-1); typename archive_traits::oarchive oa2; archive_traits::ocreate(oa2, archive_type, io_type); oa2 & buf2; if ( yas::is_binary_archive<typename archive_traits::oarchive_type>::value ) { static const unsigned char _res64_le[] = { _HEADER_BYTES(),0x43,0x12,0x00,0x00,0x00,0x73,0x68,0x61 ,0x72,0x65,0x64,0x20,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x74,0x65,0x73,0x74 }; static const unsigned char _res32_le[] = { _HEADER_BYTES(),0x03,0x12,0x00,0x00,0x00,0x73,0x68,0x61 ,0x72,0x65,0x64,0x20,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x74,0x65,0x73,0x74 }; static const unsigned char _res64_be[] = { _HEADER_BYTES(),0x44,0x00,0x00,0x00,0x12,0x73,0x68,0x61 ,0x72,0x65,0x64,0x20,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x74,0x65,0x73,0x74 }; static const unsigned char _res32_be[] = { _HEADER_BYTES(),0x03,0x00,0x00,0x00,0x12,0x73,0x68,0x61 ,0x72,0x65,0x64,0x20,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x74,0x65,0x73,0x74 }; const unsigned char *res_ptr = ( YAS_PLATFORM_BITS_IS_64() ? oa2.is_little_endian() ? _res64_le : _res64_be : oa2.is_little_endian() ? _res32_le : _res32_be ); const unsigned int res_size= ( YAS_PLATFORM_BITS_IS_64() ? oa2.is_little_endian() ? sizeof(_res64_le) : sizeof(_res64_be) : oa2.is_little_endian() ? sizeof(_res32_le) : sizeof(_res32_be) ); if ( oa2.size() != res_size ) { std::cout << "BUFFER shared serialization error! [5]" << std::endl; return false; } if ( !oa2.compare(res_ptr, res_size) ) { std::cout << "BUFFER shared serialization error! [6]" << std::endl; return false; } } else if ( yas::is_text_archive<typename archive_traits::oarchive_type>::value ) { static const unsigned char res64[] = { // "yas4A 0218shared buffer test" _HEADER_BYTES(),0x34,0x39,0x20,0x30,0x32,0x31,0x38,0x73,0x68 ,0x61,0x72,0x65,0x64,0x20,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x74,0x65,0x73,0x74 }; static const unsigned char res32[] = { // "yas09 0218shared buffer test" _HEADER_BYTES(),0x30,0x39,0x20,0x30,0x32,0x31,0x38,0x73,0x68 ,0x61,0x72,0x65,0x64,0x20,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x74,0x65,0x73,0x74 }; const unsigned char* res_ptr = (YAS_PLATFORM_BITS_IS_64() ? res64 : res32); const unsigned int res_size= (YAS_PLATFORM_BITS_IS_64() ? sizeof(res64) : sizeof(res32)); if ( oa2.size() != res_size ) { std::cout << "BUFFER shared serialization error! [7]" << std::endl; return false; } if ( !oa2.compare(res_ptr, res_size) ) { std::cout << "BUFFER shared serialization error! [8]" << std::endl; return false; } typename archive_traits::iarchive ia1; archive_traits::icreate(ia1, oa2, archive_type, io_type); yas::shared_buffer buf4; ia1 & buf4; if ( buf4.size != sizeof(str2)-1 || memcmp(str2, buf4.data.get(), buf4.size) ) { std::cout << "BUFFER shared deserialization error! [9]" << std::endl; return false; } } return true; }
/** Generate random permutations of code points in each string * * @param str character vector * @return character vector * * @version 0.2-1 (Marek Gagolewski, 2014-04-04) * * @version 0.3-1 (Marek Gagolewski, 2014-11-04) * Issue #112: str_prepare_arg* retvals were not PROTECTed from gc * * @version 1.2.5 (Marek Gagolewski, 2019-07-23) * #319: Fixed overflow in `stri_rand_shuffle()`. */ SEXP stri_rand_shuffle(SEXP str) { PROTECT(str = stri_prepare_arg_string(str, "str")); R_len_t n = LENGTH(str); GetRNGstate(); STRI__ERROR_HANDLER_BEGIN(1) StriContainerUTF8 str_cont(str, n); R_len_t bufsize = 0; for (R_len_t i=0; i<n; ++i) { if (str_cont.isNA(i)) continue; R_len_t ni = str_cont.get(i).length(); if (ni > bufsize) bufsize = ni; } std::vector<UChar32> buf1(bufsize); // at most bufsize UChars32 (bufsize/4 min.) String8buf buf2(bufsize); SEXP ret; STRI__PROTECT(ret = Rf_allocVector(STRSXP, n)); for (R_len_t i=0; i<n; ++i) { if (str_cont.isNA(i)) { SET_STRING_ELT(ret, i, NA_STRING); continue; } // fill buf1 UChar32 c = (UChar32)0; const char* s = str_cont.get(i).c_str(); R_len_t sn = str_cont.get(i).length(); R_len_t j = 0; R_len_t k = 0; while (c >= 0 && j < sn) { U8_NEXT(s, j, sn, c); buf1[k++] = (int)c; } if (c < 0) { Rf_warning(MSG__INVALID_UTF8); SET_STRING_ELT(ret, i, NA_STRING); continue; } // do shuffle buf1 at pos 0..k-1: (Fisher-Yates shuffle) R_len_t cur_n = k; for (j=0; j<cur_n-1; ++j) { // rand from i to cur_n-1 R_len_t r = (R_len_t)floor(unif_rand()*(double)(cur_n-j)+(double)j); UChar32 tmp = buf1[r]; buf1[r] = buf1[j]; buf1[j] = tmp; } // create string: char* buf2data = buf2.data(); c = (UChar32)0; j = 0; k = 0; UBool err = FALSE; while (!err && k < cur_n) { c = buf1[k++]; U8_APPEND((uint8_t*)buf2data, j, bufsize, c, err); } if (err) throw StriException(MSG__INTERNAL_ERROR); SET_STRING_ELT(ret, i, Rf_mkCharLenCE(buf2data, j, CE_UTF8)); } PutRNGstate(); STRI__UNPROTECT_ALL return ret; STRI__ERROR_HANDLER_END({ PutRNGstate(); }) }
int main() try { typedef std::vector<uint8> Buffer; Buffer buf(1024); Buffer buf2(11024); // ----------- init char psetid[] = "1234567890123456"; char test_value[] = "This is a test, This is a"; char test_value_event[] = "This is a test Event, This is a"; Strings hlt_names; Strings l1_names; hlt_names.push_back("a"); hlt_names.push_back("b"); hlt_names.push_back("c"); hlt_names.push_back("d"); hlt_names.push_back("e"); hlt_names.push_back("f"); hlt_names.push_back("g"); hlt_names.push_back("h"); hlt_names.push_back("i"); l1_names.push_back("t10"); l1_names.push_back("t11"); l1_names.push_back("t12"); l1_names.push_back("t13"); l1_names.push_back("t14"); l1_names.push_back("t15"); l1_names.push_back("t16"); l1_names.push_back("t17"); l1_names.push_back("t18"); l1_names.push_back("t19"); l1_names.push_back("t20"); char reltag[]="CMSSW_0_8_0_pre7"; std::string processName = "HLT"; std::string outputModuleLabel = "HLTOutput"; uLong crc = crc32(0L, Z_NULL, 0); Bytef* crcbuf = (Bytef*) outputModuleLabel.data(); crc = crc32(crc, crcbuf, outputModuleLabel.length()); uint32 adler32_chksum = (uint32)cms::Adler32((char*)&test_value[0], sizeof(test_value)); std::string host_name = "mytestnode.cms"; InitMsgBuilder init(&buf[0],buf.size(),12, Version((const uint8*)psetid), (const char*)reltag, processName.c_str(), outputModuleLabel.c_str(), crc, hlt_names,hlt_names,l1_names, adler32_chksum, host_name.c_str()); init.setDataLength(sizeof(test_value)); std::copy(&test_value[0],&test_value[0]+sizeof(test_value), init.dataAddress()); //Do a dumpInit here if you need to see the event. //Start the Streamer file std::cout <<"Trying to Write a Streamer file"<< std::endl; std::string initfilename = "teststreamfile.dat"; StreamerOutputFile stream_writer(initfilename); std::cout << "Trying to Write Out The Init message into Streamer File: " << initfilename << std::endl; stream_writer.write(init); // ------- event std::vector<bool> l1bit(11); uint8 hltbits[] = "4567"; const int hltsize = 9; /** I am interested in 9 bits only */ l1bit[0]=true; l1bit[4]=true; l1bit[8]=false; //l1bit[12]=true; l1bit[1]=true; l1bit[5]=false; l1bit[9]=false; //l1bit[13]=false; l1bit[2]=false; l1bit[6]=true; l1bit[10]=true; //l1bit[14]=false; l1bit[3]=false; l1bit[7]=false; //l1bit[11]=true; //l1bit[15]=true; //l1bit[16]=false; l1bit[17]=false; l1bit[18]=true; l1bit[19]=true; //Lets Build 10 Events and then Write them into Streamer file. adler32_chksum = (uint32)cms::Adler32((char*)&test_value_event[0], sizeof(test_value_event)); //host_name = "mytestnode.cms"; for (uint32 eventId = 2000; eventId != 2000+NO_OF_EVENTS; ++eventId) { EventMsgBuilder emb(&buf2[0],buf2.size(),45,eventId,2,0xdeadbeef,3, l1bit,hltbits,hltsize,adler32_chksum, host_name.c_str()); emb.setOrigDataSize(78); emb.setEventLength(sizeof(test_value_event)); std::copy(&test_value_event[0],&test_value_event[0]+sizeof(test_value_event), emb.eventAddr()); //Lets write this to our streamer file . std::cout<<"Writing Event# : "<<eventId<<" To Streamer file"<< std::endl; stream_writer.write(emb); } //Write the EOF Record Both at the end of Streamer file uint32 dummyStatusCode = 1234; std::vector<uint32> hltStats; hltStats.push_back(32); hltStats.push_back(33); hltStats.push_back(34); stream_writer.writeEOF(dummyStatusCode, hltStats); return 0; } catch(cms::Exception const& e) { std::cerr << e.explainSelf() << std::endl; return 1; }
TVerdict CWriteStringStep::doTestStepL() /** * @return - TVerdict code * Override of base class pure virtual * Our implementation only gets called if the base class doTestStepPreambleL() did * not leave. That being the case, the current test result value will be EPass. */ { INFO_PRINTF1(_L("This step tests WriteStringToConfig function.")); SetTestStepResult(EFail); TPtrC originalValue; TBool ret = EFalse; if(!GetStringFromConfig(ConfigSection(),KTe_RegStepTestSuiteString, originalValue)) { // Leave if there's any error. User::Leave(KErrNotFound); } INFO_PRINTF2(_L("The Original String is %S"), &originalValue); // Block end RBuf buf; buf.Create(originalValue.Length()); buf.Copy(originalValue); _LIT(KText,"GoodBye Jason"); TBufC<16> buf1(KText); TPtrC TheString1(buf1); if (WriteStringToConfig(ConfigSection(), KTe_RegStepTestSuiteString, TheString1)) { if (GetStringFromConfig(ConfigSection(), KTe_RegStepTestSuiteString, TheString1) && 0==TheString1.Compare(KText())) { INFO_PRINTF2(_L("Changed String To %S"),&TheString1); ret = ETrue; } } _LIT(KText2,"Hello Jason"); TBufC<16> buf2(KText2); TPtrC TheString2(buf2); if (WriteStringToConfig(ConfigSection(), KTe_RegStepTestSuiteString, TheString2)) { if (GetStringFromConfig(ConfigSection(), KTe_RegStepTestSuiteString, TheString2) && 0==TheString2.Compare(KText2())) { INFO_PRINTF2(_L("Changed String To %S"), &TheString2); } } else { ret = EFalse; } if (!WriteStringToConfig(ConfigSection(), KTe_RegStepTestSuiteString, buf)) { ret = EFalse; } buf.Close(); if (ret) { SetTestStepResult(EPass); } return TestStepResult(); }
int main () { try { /********** Setup ************/ saga::session s; saga::context c ("opencloud"); s.add_context (c) ; /********** Write File************/ std::cout << std::endl ; std::cout << std::endl ; saga::filesystem::file f (s, "sector://test", saga::filesystem::ReadWrite ) ; std::string towrite ("hello world !\n") ; saga::const_buffer buf ( towrite.c_str(), towrite.length()) ; f.write( buf, towrite.length()) ; std::cout << "Written data: " << towrite ; /********** Read File************/ saga::mutable_buffer bufread ( towrite.length()) ; f.read( bufread, towrite.length()) ; std::cout << "Data read: " << (char*) bufread.get_data() ; /********* Seek File ************/ std::cout << "Seek to the end .. " << std::endl ; f.seek( towrite.length(), saga::filesystem::Start ) ; std::string w2 (" clouds!") ; std::cout << "Write some more: " << w2 << std::endl ; saga::const_buffer buf2( w2.c_str(), w2.length()) ; f.write( buf2, w2.length()) ; /********* Read new data ************/ f.seek( 0, saga::filesystem::Start ) ; saga::mutable_buffer bufread2( towrite.length() + w2.length() + 1 ) ; f.read( bufread2, towrite.length() + w2.length() + 1 ) ; std::cout << "Data read after seek and write: " << (char*) bufread2.get_data() << std::endl ; f.close() ; /********* Directory ***************/ /*Create directories */ std::cout << std::endl ; std::cout << "Create directory my_dir..." << std::endl ; std::cout << "Create directory my_dir/another_dir..." << std::endl ; saga::url dir ("sector://my_dir") ; saga::url dir2 ("sector://my_dir/another_dir") ; saga::filesystem::directory d( s, dir ) ; saga::filesystem::directory d2( s, dir2 ) ; /* Change working directory */ std::cout << "Changing cwd to my_dir/another_dir..." << std::endl ; d.change_dir("another_dir") ; std::cout << "Creating my_dir/another_dir/nested_dir ... " << std::endl ; d.make_dir("nested_dir") ; /* Populate Directories */ std::cout << "Populate files in nested_dir ... " << std::endl ; saga::filesystem::file f2 (s, "my_dir/another_dir/nested_dir/file1", saga::filesystem::ReadWrite ) ; saga::filesystem::file f3 (s, "my_dir/another_dir/nested_dir/file2", saga::filesystem::ReadWrite ) ; saga::filesystem::file f4 (s, "my_dir/another_dir/nested_dir/file3", saga::filesystem::ReadWrite ) ; saga::filesystem::file f5 (s, "/makeme/file3", saga::filesystem::ReadWrite ) ; f2.close() ; f3.close() ; f4.close() ; f5.close() ; /* List directory */ d.change_dir("nested_dir") ; std::vector <saga::url> listing = d.list() ; std::cout << "List nested_dir ..." << std::endl ; for ( std::vector<saga::url>::iterator i = listing.begin(); i != listing.end(); ++ i) { std::cout << i->get_string() << std::endl ; } /* Copy Files */ d.copy( "file1", "sector:///" ) ; return 0 ; } catch ( const saga::exception & e ) { std::cerr << e.what (); } }