TEST_F(DriverConductorNetworkTest, shouldBeAbleToAddAndRemoveSingleNetworkSubscription)
{
    int64_t client_id = nextCorrelationId();
    int64_t sub_id = nextCorrelationId();
    int64_t remove_correlation_id = nextCorrelationId();

    ASSERT_EQ(addNetworkSubscription(client_id, sub_id, CHANNEL_1, STREAM_ID_1, -1), 0);
    doWork();
    EXPECT_EQ(aeron_driver_conductor_num_network_subscriptions(&m_conductor.m_conductor), 1u);
    EXPECT_EQ(readAllBroadcastsFromConductor(null_handler), 1u);

    ASSERT_EQ(removeSubscription(client_id, remove_correlation_id, sub_id), 0);
    doWork();
    auto handler = [&](std::int32_t msgTypeId, AtomicBuffer& buffer, util::index_t offset, util::index_t length)
    {
        ASSERT_EQ(msgTypeId, AERON_RESPONSE_ON_OPERATION_SUCCESS);

        const command::OperationSucceededFlyweight response(buffer, offset);

        EXPECT_EQ(response.correlationId(), remove_correlation_id);
    };

    EXPECT_EQ(aeron_driver_conductor_num_network_subscriptions(&m_conductor.m_conductor), 0u);
    EXPECT_EQ(readAllBroadcastsFromConductor(handler), 1u);
}

int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int cmdShow)
{
    StringVector sv = Helper::split(lpCmdLine, '-');
    bool minimized = false;
    for (StringVector::iterator itr = sv.begin(); itr != sv.end(); ++ itr)
    {
        if (*itr == "minimized" || *itr == "m")
        {
            minimized = true;
            break;
        }
    }

    if (minimized)
    {
        return doWork();
    }
    else
    {
        if(AllocConsole())
        {
            freopen("CONOUT$", "w", stdout);
            SetConsoleTitle(SERVER_APP_NAME);
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED);
        }

        outbuf ob;
        std::streambuf *sb = std::cout.rdbuf(&ob);

        int result = doWork();

        std::cout.rdbuf(sb);
        return result;
    }
}

int main() {

    int x = 10, y = 50, z = 15, sum, max;
    doWork(x, y, z, &sum, &max);
    printf("Sum = %d, Max = %d\n", sum, max);
    return 0;
}

bool BlinkyTapeUploader::upgradeFirmware(int timeout) {
    QByteArray sketch = QByteArray(reinterpret_cast<const char*>(PRODUCTION_DATA),PRODUCTION_LENGTH);

    bootloaderPollTimeout = timeout;

    char buff[BUFF_LENGTH];
    snprintf(buff, BUFF_LENGTH, "Sketch size: %iB",
             sketch.length()),
    qDebug() << buff;

    // The entire sketch must fit into the available memory, minus a single page
    // at the end of flash for the configuration header
    // TODO: Could save ~100 bytes if we let the sketch spill into the unused portion
    // of the header.
    if(sketch.length() > FLASH_MEMORY_AVAILABLE) {
        qDebug() << "sketch can't fit into memory!";

        errorString = QString("Sorry! The Pattern is a bit too big to fit in BlinkyTape memory right now. We're working on improving this! Avaiable space=%1, Pattern size=%2")
                .arg(FLASH_MEMORY_AVAILABLE)
                .arg(sketch.length());
        return false;
    }

    // Put the sketch, pattern, and metadata into the programming queue.
    flashData.push_back(FlashSection(PRODUCTION_ADDRESS, sketch));

    setProgress(0);
    // TODO: Calculate this based on feedback from the programmer.
    setMaxProgress(300);

    stateStartTime = QDateTime::currentDateTime();
    state = State_WaitForBootloaderPort;
    bootloaderResetTimer->singleShot(0,this,SLOT(doWork()));
    return true;
}

void Parallel::run(int threadIndex)
{
    while (true)
    {
        // Wait for new work in a critical section
        {
            std::unique_lock<std::mutex> lock(_mutex);

            // Indicate that this thread is no longer doing work
            _active[threadIndex] = false;

            // Tell the main thread when all parallel threads are inactive
            if (!threadsActive()) _conditionMain.notify_all();

            // Wait for new work
            while (true)
            {
                _conditionExtra.wait(lock);

                // Check for termination request (don't bother with _active; it's no longer used)
                if (_terminate) return;

                // Check that we actually have new work
                if (_active[threadIndex]) break;
            }
        }

        // Do work as long as some is available
        doWork();
    }
}

//COnstructor
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    //Server object
    ser = new Server();

    //THread for server
    m_thread = new QThread;

    //Connection to signal the server class to start working and checking for messages
    connect(this, SIGNAL(startServer()), ser, SLOT(doWork()));

    //Connection to notify the GUI to update
    connect(ser, SIGNAL(sendText(QString)), this, SLOT(writeText(QString)));

    //Start the thread
    ser->moveToThread(m_thread);
    m_thread->start();

    //Start the server working to check for messages
    emit startServer();
}

int db2_access(test_req_t *req, test_req_t *resp)
{
	SQLHENV henv;	/* environment handle */
	SQLHDBC hdbc;	/* connection handle */
	SQLRETURN rc = SQL_ERROR;
	SQLHSTMT shdl;

	btlogger_debug("op=%c data=%s db=%s\n", req->op, req->data, req->db);

	if (init(req->db, &henv, &hdbc) != SQL_SUCCESS)
		return (int) rc;

	rc = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &shdl);

	if ( rc != SQL_SUCCESS ) {
		(void) check_error(SQL_HANDLE_STMT, shdl, rc, "SQLAllocHandle", (SQLCHAR *) "statement handle");
	} else {
		rc = doWork(req->op, req->data, henv, hdbc, shdl, resp);
		(void) SQLFreeStmt(shdl, SQL_DROP);
	}

	fini(henv, hdbc);

	return (int) rc;
}

void loop() {

	// do housekeeping
	doWork();

	// character received on serial port? may be a connection attempt
	if (Serial.available() > 0) {

		// indicate connected status
		digitalWrite(13, HIGH);   // set the LED on

		// start the OPDI protocol, passing a pointer to the housekeeping function
		// this call blocks until the slave is disconnected
		uint8_t result = Opdi->start(&doWork);

		// no regular disconnect?
		if (result != OPDI_DISCONNECTED) {
			digitalWrite(13, LOW);    // set the LED off
			delay(500);

			// flash error code on LED
			for (uint8_t i = 0; i < result; i++) {
				digitalWrite(13, HIGH);   // set the LED on
				delay(200);              // wait
				digitalWrite(13, LOW);    // set the LED off
				delay(200);              // wait
			}
		}

		digitalWrite(13, LOW);    // set the LED off
	}
}

HtmlParser::HtmlParser(const QUrl &url, const QString &text, QObject *parent)
    :
      QObject(parent),
      _info(new UrlInfo, [](UrlInfo* p){delete p;}),
      _downloaded(false),
      _text(text),
      _downloader(nullptr)
{
    _info->_url = url.toString();
    _info->_found = false;
    _info->_status = UrlInfo::DOWNLOADING;
    _info->_percentage = 0;
    emit processing(_info.data());
    QThread * thread = new QThread();
    _downloader = new HtmlDownloader(url);
    _downloader->moveToThread(thread);

    connect( thread, SIGNAL(started()), _downloader, SLOT(doWork()));

    connect( _downloader, SIGNAL(finished(QString)), thread, SLOT(quit()));
    connect( _downloader, SIGNAL(finished(QString)), this, SLOT(downloaded(QString)), Qt::ConnectionType::DirectConnection);
    connect(_downloader, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(downloadProgress(qint64,qint64)));

    connect( thread, SIGNAL(finished()), thread, SLOT(deleteLater()));

    thread->start();
}

void Worker::onGoFromService (InputParametersRS input)
{
    try {

        doWork( input);

    } catch ( Interrupt & ) {
        // std::cerr << "*** Worker interrupted ***\n";
        dbg(1) << "RS interrupted\n";
        emit interrupt ();
    } catch ( std::runtime_error & e) {
        std::cerr << "Worker runtime-exception: " << e.what() << "\n";
        emit error( QString("runtime-exception: %1").arg(e.what()));
    } catch ( std::exception & e) {
        std::cerr << "Worker std-exception: " << e.what() << "\n";
        emit error( QString("std-exception: %1").arg(e.what()));
    } catch ( std::string & s) {
        std::cerr << "Worker exception: " << s << "\n";
        emit error( QString("exception: %1").arg(s.c_str()));
    } catch ( QString & s) {
        std::cerr << "Worker exception: " << s << "\n";
        emit error( QString("exception: %1").arg(s));
    } catch ( char * s) {
        std::cerr << "Worker exception: " << s << "\n";
        emit error( QString("exception: %1").arg(s));
    } catch (...) {
        std::cerr << "Worker uncaught exception...\n";
        dbg(1) << "Worker uncaught exception\n";
        emit error ( "Uncaught exception");
//        throw;
    }
}

void OscListenerWorker::Start()
{
    if (!running) {
        running = true;
        doWork();
    }
}

void createProc(int number, pid_t* pid_array){
	int i = 0;
	pid_t pid;
	int *array;
	
	//Preparing random order squence
	array = (int*)malloc(sizeof(int)*number);

	for(i = 0; i < number; ++i)
		array[i] = i;
	shuffle(array, number);

	unlockSem(0); //aby mohol prvy bezat
	for(i = 0; i < number; ++i){
		switch(pid = fork()){
			case 0:
      			doWork(array[i], getNext(array, i + 1, number));
			exit(EXIT_SUCCESS);
    		case -1:
      			perror("fork");
      			exit(EXIT_FAILURE);
    		default:
				pid_array[i] = pid;
      			break;
		}
	}
	free(array);
}

void QuebrarSenha::quebrarSenhaZIP()
{
    QString text = ui->lineEdit->text();

    QThread *workerThread;
    CountWorker *worker;

    int i;
    //Esta é a parte mais importante do programa;
    //Está sendo criado 4 threads, onde cada thread é responsável por executar uma porção das senhas em paralelo
    //As senhas variam de 0 a 500000
    for(i = 0; i < 4; i++){
        workerThread = new QThread;
        QLabel *label;
        if(i==0) label=ui->thread0;
        else if(i==1) label=ui->thread1;
        else if(i==2) label=ui->thread2;
        else if(i==3) label=ui->thread3;

        worker = new CountWorker(i*125000, (i+1)*125000, text, label);
        worker->moveToThread(workerThread);
        connect(workerThread, SIGNAL(started()), worker, SLOT(doWork()));
        connect(worker, SIGNAL(finished()), workerThread, SLOT(quit()));
        connect(worker, SIGNAL(finished()), worker, SLOT(deleteLater()));
        connect(workerThread, SIGNAL(finished()), workerThread, SLOT(deleteLater()));
        connect(worker, SIGNAL(updateCount(int, QLabel*)), this, SLOT(updateCount(int, QLabel*)));
        connect(worker, SIGNAL(updateSenha(int)), this, SLOT(updateSenha(int)));
        connect(worker, SIGNAL(updateProgressBar(float)), this, SLOT(updateProgressBar(float)));

        workerThread->start();
    }
}

//========
// main()
//========
int main(int argc, char** argv) {
  bool isok = false;
  try {
    Input input(argc, argv);
    doWork(input);
    isok = true;
  } catch(const Help& h) {
    std::cout << prognm << std::endl;
    std::cout << "  citation: " + citation << std::endl;
    std::cout << "  version:  " + version << std::endl;
    std::cout << "  authors:  " + authors << std::endl;
    std::cout << usage() << std::endl;
    isok = true;
  } catch(const Version& v) {
    std::cout << prognm << std::endl;
    std::cout << "  citation: " + citation << std::endl;
    std::cout << "  version:  " + version << std::endl;
    std::cout << "  authors:  " + authors << std::endl;
    isok = true;
  } catch(std::string& msg) {
    std::cerr << prognm << std::endl;
    std::cerr << "  citation: " + citation << std::endl;
    std::cerr << "  version:  " + version << std::endl;
    std::cerr << "  authors:  " + authors << std::endl;
    std::cerr << usage() << std::endl;
    std::cerr << msg << std::endl;
  } catch(std::exception& e) {
    std::cerr << usage() << std::endl;
    std::cerr << e.what() << std::endl;
  } catch(...) {
    std::cerr << usage() << std::endl;
    std::cerr << "Unknown Error.  Aborting" << std::endl;
  }
  return(isok ? EXIT_SUCCESS : EXIT_FAILURE);
}

void Compute::receiveB(int indexX, float *data, int size) {
  for(int j=0; j<subBlockDimYx; j++)
    for(int k=0; k<blockDimZ; k++)
      B[indexX*subBlockDimYx*blockDimZ + j*blockDimZ + k] = data[j*blockDimZ + k];
  countB++;
  if(countA == num_chare_z-1 && countB == num_chare_x-1)
    doWork();
}

Scheduler::Scheduler()
{
	reload();

	connect(&m_timer, SIGNAL(timeout()), this, SLOT(doWork()));
	m_timer.start(60*1000);
	m_instance = this;
}

void SFTWorker::run()
{
	assert(m_pCT);

	while (true)
	{
		uint32 status = m_pCT->getStatus(m_uiId);
		int32 res = BZ_OK;

		while (status == BaseMCFThread::SF_STATUS_PAUSE)
		{
			gcSleep(500);
			status = m_pCT->getStatus(m_uiId);
		}

		if (status == BaseMCFThread::SF_STATUS_STOP)
		{
			break;
		}
		else if (status == BaseMCFThread::SF_STATUS_NULL)
		{
			if (!newTask())
				gcSleep(500);

			continue;
		}
		else if (status == BaseMCFThread::SF_STATUS_ENDFILE)
		{
			do
			{
				res = doWork();
				if (bzErrorCheck(res))
					break;
			}
			while (res != BZ_STREAM_END);
		}
		else if (status == BaseMCFThread::SF_STATUS_CONTINUE)
		{
			res = doWork();
			bzErrorCheck(res);
		}

		if (res == BZ_STREAM_END || status == BaseMCFThread::SF_STATUS_SKIP)
			finishFile();
	}
}

int main (int argc, char** argv) {

  MPI_Init (&argc, &argv);

  int numprocs;
  MPI_Comm_size (MPI_COMM_WORLD, &numprocs);

  int myid;
  MPI_Comm_rank (MPI_COMM_WORLD, &myid);
  
  printf ("Hello World from processor: %d out of %d\n", myid, numprocs);

  int namelen;
  char myname[MPI_MAX_PROCESSOR_NAME];
  MPI_Get_processor_name (myname, &namelen);
  printf ("processor id=%d, name=%s\n", myid, myname);

  double time = MPI_Wtime ();

  double d = doWork (1e7);

  time = MPI_Wtime() - time;

  printf ("Time taken by proc = %d is = %g\n", myid, time);

  printf("processor %d sending its time to proc 0\n", myid);
  MPI_Send (&time, 1, MPI_DOUBLE, 0, myid, MPI_COMM_WORLD);

  double totalTime = 0;
  double recvTime;
  if (myid == 0) { 
    int i;
    MPI_Status status;
    for (i = 0; i < numprocs; ++i) {
      MPI_Recv (&recvTime, 1, MPI_DOUBLE, i, i, MPI_COMM_WORLD, &status);
      totalTime += recvTime;
      printf ("received time = %g from proc = %d\n", recvTime, i);
    }

    printf ("time taken, total = %g, avg=%g\n", totalTime, (totalTime/numprocs));

    // proc 0 sends the average time to everyone
    double avgTime = totalTime / numprocs;
    for (i = 0; i < numprocs; ++i) {
      printf ("Proc 0 sending avgTime to proc = %d\n", i);
      MPI_Send (&avgTime, 1, MPI_DOUBLE, i, i, MPI_COMM_WORLD);
    }
  } // end if proc 0

  double avgTime;
  MPI_Status status;
  MPI_Recv (&avgTime, 1, MPI_DOUBLE, 0, myid, MPI_COMM_WORLD, &status);

  printf ("Proc = %d received average time = %g, from proc 0\n", myid, avgTime);

  MPI_Finalize ();
  
}

PingThread::PingThread(QObject * const parent, QString *host) : QObject(parent), 
    process(NULL), timer(new QTimer(this)), host(*host)
{
  this->lastPing = std::numeric_limits<float>::quiet_NaN();
  startProcess();
  connect(timer, SIGNAL(timeout()), this, SLOT(doWork()));
  timer->start(1000);
  qDebug() << "thread started";
}

void *rcrtoolDaemon(void* arg) {
    qthread_worker_t   *me_worker = (qthread_worker_t *)(swinfo.worker);
    qthread_shepherd_t *me        = (qthread_shepherd_t *)me_worker->shepherd;
    if (swinfo.qaffinity && (me->node != -1)) {
      qt_affinity_set(me_worker,swinfo.nworkerspershep);
    }
    doWork(swinfo.nshepherds, swinfo.nworkerspershep);
    return 0;
}