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 );
}
}
