bool buildGamingComputerTest3() { ComputerBuilder *builder = new GamingComputerBuilder(); builder->createComputer(); Computer *computer = builder->getResult(); Part** list = computer->getAdditionalPartsList(); for (int i = 0; i < computer->getNumberOfAdditionalParts(); ++i) { Part* part = list[i]; if (part != 0) { // tests if Part is a BluRay drive if(dynamic_cast<BluRayDrive*>(part)) { delete builder; delete computer; return true; } } } delete builder; delete computer; return false; }
bool buildGamingComputerTest2() { ComputerBuilder *builder = new GamingComputerBuilder(); builder->createComputer(); Computer *computer = builder->getResult(); Ram* ram = computer->getRamSet().getRamSticks(); int amountOfRam = 0; for (int i = 0; i < computer->getRamSet().getNumberOfRamSticks(); ++i) { amountOfRam += ram[i].getRamSize(); } if (amountOfRam >= 16) { delete builder; delete computer; return true; } delete builder; delete computer; return false; }
int main() { // unit_test(); auto instructionsInText = readStrings(INPUT_FILE); auto program = parseInstructions(instructionsInText); Computer c; c.program = program; // Part1 { c.reset(); c.start(); auto regA = c.registers.registerValues[0]; cout << "Day 12 part 1 answer: " << regA << endl; } // Part 2 { c.reset(); c.registers.registerValues[2 /* c */] = 1; c.start(); auto regA = c.registers.registerValues[0]; cout << "Day 12 part 2 answer: " << regA << endl; } return 0; }
void dealDeck(Player& user, Computer& comp, Cards& deck, int count) { if (count % EVEN_ODD == EMPTY) // Deal to user first { unsigned int i = EMPTY; while (i < EVEN_ODD*CARDS_DEALT) { user.InsertIntoHand(deck.TopDeckCard()); deck.PopOffCard(); i++; comp.InsertIntoHand(deck.TopDeckCard()); deck.PopOffCard(); i++; } deck.AdjustPickPile(); } else // Deal to computer first { unsigned int j = EMPTY; while (j < EVEN_ODD*CARDS_DEALT) { comp.InsertIntoHand(deck.TopDeckCard()); deck.PopOffCard(); j++; user.InsertIntoHand(deck.TopDeckCard()); deck.PopOffCard(); j++; } deck.AdjustPickPile(); } }
bool buildOfficeComputerTest1() { ComputerBuilder *builder = new OfficeComputerBuilder(); builder->createComputer(); Computer *computer = builder->getResult(); delete builder; std::string actual = computer->getComputerSpecifications(); std::string expected = "Office Computer\n"; expected += "CPU: Intel Celeron G1610 Ivy Bridge Dual-Core, Clock Speed: 2.6 Ghz, Socket: LGA 1155\n"; expected += "Motherboard: ASUS P8H61-M LE/CSM R2.0, Socket: LGA 1155\n"; expected += "No. of Ram Slots: 2, No. of Graphics Cards Permitted: 1\n"; expected += "Ram: Number Of Sticks: 2\n"; expected += "Slot 1: CORSAIR Vengeance, Frequency: 1600 Mhz, Size: 4 GB\n"; expected += "Slot 2: CORSAIR Vengeance, Frequency: 1600 Mhz, Size: 4 GB\n"; expected += "Hard Drives: Number Of Drives: 1\n"; expected += "Drive 1: Western Digital Blue WD5000AAKX, Size: 500 GB, 7200 RPM\n"; expected += "Graphics Cards: Number Of Cards: 1\n"; expected += "Slot 1: On board graphics, Frequency: 650 Mhz, Size: 1 GB\n"; expected += "Case: Corsair Obsidian 750D Black Aluminum, Case Type: BaseUnit\n"; expected += "Power Supply: Be Quiet! Power Zone, Maximum Power: 650 Watts\n"; expected += "Additional Parts\n"; expected += "DVD Drive: ASUS 24X DVD Burner, Read Speed: 24X"; delete computer; return actual == expected; }
void func(chessboard *chess, int depth,int turn,Vector2i* bestmove,Vector2i start,Vector2i end) { Computer temp; if(turn==2) //If the computer is playing for player 2 then calling minSearch and trying to find largest value of board for each value returned by minsearch { int value = temp.minSearch( depth-1 , *chess ,-INFINITY,INFINITY); //Finding all the minimum values of board if( value > bestvalue ) //Selecting the best move by finding the maximum of the values obtained { bestvalue = value; bestmove[0].x = start.x; bestmove[0].y = start.y; bestmove[1].x = end.x; bestmove[1].y = end.y; } } else //Opposite of that for player 1 { int value = temp.maxSearch( depth-1 , *chess,-INFINITY,INFINITY ); //Finds all maximum values of board if( value < bestvalue ) //Selects the lowest of those values { bestvalue = value; bestmove[0].x = start.x; bestmove[0].y = start.y; bestmove[1].x = end.x; bestmove[1].y = end.y; } } delete chess; //Chess board obtained is deleted as no longer needed }
void ScoreOutput(Player& user, Computer& comp, int roundCount) { cout << "After " << roundCount << " rounds:\n" << "Your current score: " << user.GetScore() << "\n" << comp.GetName() << "'s current score: " << comp.GetScore() << "\n" << "And the game continues...\n\n"; }
int main() { Computer A; A.input(); Computer B = A; A.display(); B.display(); }
void Model::nextPlayer() { this->incrementActivePlayerId(); Player* player = this->activePlayer(); this->notify(); // check if this player has any cards to play // if not, end the turn and notify if (player->hand().size() == 0) { std::cerr << "Setting round to ended" << std::endl; this->roundEnded_ = true; std::cerr << "Notifying user" << std::endl; this->notify(); if (!this->hasWinner()) { std::cerr << "Game didn't have a winner, so we start another round" << std::endl; this->startRound(); } else { std::cerr << "Game had a winner" << std::endl; this->endGame(); } std::cerr << "Updating the view after either starting another round or ending the game" << std::endl; return; } if (player->type() == "Computer") { Computer* computer = (Computer*)player; Card* card = computer->play(this->legalPlaysInHand(computer->hand())); if (card != NULL) { this->cardsOnTable_[card->getSuit()][card->getRank()] = card; } this->notify(); this->nextPlayer(); } }
int main() { Computer compute; compute.setSpeed(100); cout << compute.readSpeed() << endl; }
bool buildGamingComputerTest1() { ComputerBuilder *builder = new GamingComputerBuilder(); builder->createComputer(); Computer *computer = builder->getResult(); HardDrive** hardDrives = computer->getHardDriveSet().getHardDrives(); int hardDriveSpace = 0; for (int i = 0; i < computer->getHardDriveSet().getNumberOfHardDrives(); ++i) { hardDriveSpace += hardDrives[i]->getHardDriveSize(); } if (hardDriveSpace >= 5000) { delete builder; delete computer; return true; } delete builder; delete computer; return false; }
Computer* createProduct(int tipo) { Computer* myComputer = factoryMethod(tipo); myComputer->componentSelection(); myComputer->componentEnsambling(); myComputer->SWInstalation(); myComputer->computerPacking(); return myComputer; }
void MainWindow::displayComputersForScientistConnections(vector<Computer> computers) { ui->computer_list_scientist_connections->clear(); for (unsigned int i = 0; i < computers.size(); i++) { Computer currentComputer = computers.at(i); QString name = QString::fromStdString(currentComputer.getName()); ui->computer_list_scientist_connections->addItem(name); } }
int main() { Computer computer; ComputerPartDisplayVoistor visitor; computer.accept(&visitor); cout << "Hello World!" << endl; return 0; }
bool computerCPUTest() { Computer* computer = new Computer(); computer->setCPU(CPU("Intel Core i7-3770K Ivy Bridge Quad-Core", 3.5, "LGA 1155")); std::string expected = "CPU: Intel Core i7-3770K Ivy Bridge Quad-Core, Clock Speed: 3.5 Ghz, Socket: LGA 1155"; std::string actual = std::string(computer->getCPU().getPartInformation()); delete computer; return expected == actual; }
void ComputerRepository::addToDatabase(Computer computer) { QSqlQuery query(datab); query.prepare("INSERT INTO Computers(Name, Type, WasBuilt, YearBuilt) VALUES (:Name, :Type, :WasBuilt, :YearBuilt)"); query.bindValue(":Name", QString::fromStdString(computer.getName())); query.bindValue(":Type", QString::fromStdString(computer.getType())); query.bindValue(":WasBuilt", QString::fromStdString(computer.getWasBuilt())); query.bindValue(":YearBuilt", QString::fromStdString(computer.getYear())); query.exec(); }
bool computerMotherboardTest() { Computer* computer = new Computer(); computer->setMotherboard(Motherboard("ASUS Maximus V EXTREME", "LGA 1155", 4, 2)); std::string expected = "Motherboard: ASUS Maximus V EXTREME, Socket: LGA 1155\nNo. of Ram Slots: 4, No. of Graphics Cards Permitted: 2"; std::string actual = std::string(computer->getMotherboard().getPartInformation()); delete computer; return expected == actual; }
bool computerPowerSupplyTest() { Computer* computer = new Computer(); computer->setPowerSupply(PowerSupply("Cougar CMX1000 V3", 1000)); std::string expected = "Power Supply: Cougar CMX1000 V3, Maximum Power: 1000 Watts"; std::string actual = std::string(computer->getPowerSupply().getPartInformation()); delete computer; return expected == actual; }
unsigned int __stdcall MonitorAsClientToo(void *) { myself_computer.ConncetWithServer(); myself_computer.SendHostname(); myself_computer.BegintoWork(); myself_computer.SendDeviation(); return 0; }
void MainWindow::on_button_see_connections_computer_clicked() { int currentlySelectedComputerIndex = ui->computer_list_computer_connections->currentIndex().row(); Computer currentlySelectedComputer = currentlyDisplayedComputers.at(currentlySelectedComputerIndex); int idOfComputer = currentlySelectedComputer.getId(); string StringIdOfComputer = static_cast<ostringstream*>(&(ostringstream() << idOfComputer) )->str(); vector<Scientist> scientists = sciService.getScientistsByComputerId(StringIdOfComputer); displayScientistsForComputerConnections(scientists); ui->button_see_connections_computer->setEnabled(false); }
bool computerCaseTest() { Computer* computer = new Computer(); computer->setCase(Case("NZXT Phantom 240", Tower)); std::string expected = "Case: NZXT Phantom 240, Case Type: Tower"; std::string actual = std::string(computer->getCase().getPartInformation()); delete computer; return expected == actual; }
void Scientist::setComputers(std::vector<Computer> newComputers) { destroyComputers(); for (unsigned int i = 0; i < newComputers.size(); i++) { Computer currentComputer = newComputers.at(i); this->computers.push_back(new Computer(currentComputer.getId(), currentComputer.getName(), currentComputer.getType(), currentComputer.getYearBuilt())); } }
void ComputerRepository::add(Computer &comp) { auto query = SQLConnection::getInstance()->getQuery(); query->prepare("INSERT INTO computers (name, type, build_year, built) VALUES (?,?,?,?)"); query->addBindValue(QString::fromStdString(comp.getName())); query->addBindValue(QString::fromStdString(comp.getType())); query->addBindValue(comp.getBuildYear()); query->addBindValue(comp.getBuilt()); if(!query->exec()) throw std::runtime_error(query->lastError().text().toStdString()); }
void ComputerManager::startComputerControlInterface( Computer& computer ) { computer.controlInterface().start( computerScreenSize(), &m_builtinFeatures.userSessionControl() ); connect( &computer.controlInterface(), &ComputerControlInterface::featureMessageReceived, &m_featureManager, &FeatureManager::handleMasterFeatureMessage ); connect( &computer.controlInterface(), &ComputerControlInterface::userChanged, [&] () { updateUser( computer ); } ); }
void Database::addComputer(Computer computer) { QSqlQuery query(connectDatabase()); query.prepare("INSERT INTO Computers (ComputersName, YearBuilt, Type, WasItBuilt) VALUES (:name, :year, :type, :built)"); query.bindValue(":name", QString::fromStdString(computer.getName())); query.bindValue(":year", QString::number(computer.getYear())); query.bindValue(":type", QString::fromStdString(computer.getType())); query.bindValue(":built", QString::number(computer.getwasItBuilt())); query.exec(); }
void ComputerRepository::update(Computer &comp, Computer &replace) { auto query = SQLConnection::getInstance()->getQuery(); query->prepare("UPDATE computers SET name = ?, type = ?, build_year = ?, built = ? WHERE id = ?"); query->addBindValue(QString::fromStdString(replace.getName())); query->addBindValue(QString::fromStdString(replace.getType())); query->addBindValue(replace.getBuildYear()); query->addBindValue(replace.getBuilt()); query->addBindValue(comp.getID()); if(!query->exec()) throw std::runtime_error(query->lastError().text().toStdString()); }
int main() { Computer *lenovo = new Microsoft(); lenovo->InstallOS(new Windows()); Computer *Mac = new Apple(); Mac->InstallOS(new IOS()); delete lenovo; delete Mac; }
int SQLITEHandler::addEntry( Computer c ) { // Add Computer to database if( !status ) // If not connected, fail return 1; q.prepare( "INSERT INTO computers (name, creation, type, constructed) VALUES (:name, :creation, :type, :constructed)" ); q.bindValue( ":name", c.getName() ); q.bindValue( ":creation", c.getYear() ); q.bindValue( ":type", c.getType() ); q.bindValue( ":constructed", c.getWasBuilt() ); if( !q.exec() ) // Attempt to execute query return 1; return 0; // Return Success }
Computer* Computer::fromString(const QString& string) { Computer* computer = new Computer; QByteArray ba = QByteArray::fromBase64(string.toUtf8()); QDataStream ds(&ba, QIODevice::ReadOnly); QVariant pk; ds >> pk >> computer->_user_id >> computer->_ip >> computer->_lastActivity; computer->setPk(pk); return computer; }
void ComputerManager::updateUser( Computer& computer ) { QModelIndex networkObjectIndex = findNetworkObject( computer.networkObjectUid() ); if( networkObjectIndex.isValid() ) { networkObjectIndex = m_networkObjectOverlayDataModel->index( networkObjectIndex.row(), 1, networkObjectIndex.parent() ); m_networkObjectOverlayDataModel->setData( networkObjectIndex, computer.controlInterface().user(), Qt::DisplayRole ); } }