BOOST_FIXTURE_TEST_CASE(UnregisterWithoutConnection, RemoteRegistratorFixture)
{
  connectToHub();

  disconnectToHub();

  Name indentity("/remote/register");
  remoteRegistrator->m_regEntries.insert(
            nfd::rib::RemoteRegistrator::RegisteredEntry(indentity, scheduler::EventId()));

  eraseEntryWithIdentity(indentity);

  BOOST_REQUIRE_EQUAL(face->sentInterests.size(), 0);
}

BOOST_FIXTURE_TEST_CASE( previous, previous_fixture )
{
    it_u8 = enc_u8_end;

    for (size_t i = dec.size( ); i > 0; --i)
    {
        std::string::const_iterator last = it_u8;
        BOOST_TEST_CHECKPOINT( "i=" << i << " cp=U+" << std::hex << (uint32_t)dec[i - 1] );

        char32_t cp = lib::previous( it_u8 );
        BOOST_REQUIRE_EQUAL( cp, dec[i - 1] );
        BOOST_REQUIRE( it_u8 == last - enc_u8_cp_size[i - 1] );
    }
}

BOOST_FIXTURE_TEST_CASE(BlockedPaths, WorldFixtureEmpty0P)
{
    MapPoint startPt(10, 10);
    // Create a circle of stones so the path is completely blocked
    std::vector<MapPoint> surroundingPts = world.GetPointsInRadius(startPt, 1);
    BOOST_FOREACH(const MapPoint& pt, surroundingPts)
        world.SetNO(pt, new noGranite(GT_1, 1));
    std::vector<MapPoint> surroundingPts2;
    for(unsigned i=0; i<12; i++)
        surroundingPts2.push_back(world.GetNeighbour2(startPt, i));
    BOOST_FOREACH(const MapPoint& pt, surroundingPts2)
        BOOST_REQUIRE_EQUAL(world.FindHumanPath(startPt, pt), INVALID_DIR);
    // Allow left exit
    world.DestroyNO(surroundingPts[0]);
    BOOST_REQUIRE_EQUAL(world.FindHumanPath(startPt, surroundingPts2[0]), 0);
    BOOST_REQUIRE(checkWalkOnTerrain(world, startPt, surroundingPts2[0], Direction::WEST, TT_WATER, true));
    BOOST_REQUIRE(checkWalkOnTerrain(world, startPt, surroundingPts2[0], Direction::WEST, TT_SWAMPLAND, true));
    BOOST_REQUIRE(checkWalkOnTerrain(world, startPt, surroundingPts2[0], Direction::WEST, TT_LAVA, false));
    BOOST_REQUIRE(checkWalkOnTerrain(world, startPt, surroundingPts2[0], Direction::WEST, TT_SNOW, false));

    BOOST_REQUIRE(checkWalkOnPoint(world, startPt, surroundingPts2[0], Direction::WEST, TT_WATER));
    BOOST_REQUIRE(checkWalkOnPoint(world, startPt, surroundingPts2[0], Direction::WEST, TT_SWAMPLAND));
}

BOOST_FIXTURE_TEST_CASE(read_by_two_bits, Fixture)
{
    v_t shift_results = {0x0, 0x0, 0x3, 0x3, 0x3, 0x3, 0x0, 0x0, 0x3, 0x3, 0x3, 0x3};
    v_t deref_results = {0xf0, 0xf3, 0xff, 0xcf, 0x0f, 0x0f, 0x0f, 0x3f, 0xff, 0xfc, 0xf0, 0xc0};
    for (size_t i = 0; i < shift_results.size(); ++i)
    {
        BOOST_TEST_CHECKPOINT("Shifted " << i << " times so far");
        BOOST_CHECK_EQUAL(*bit, deref_results[i]);
        unsigned char shifted = bit.shift(2);
        BOOST_REQUIRE_EQUAL(bit.shift(), ((i+1)*2)%8);
        BOOST_REQUIRE_LT(shifted, 4);
        BOOST_CHECK_EQUAL(shifted, shift_results[i]);
    }
}

void checkGet(const openfluid::utils::RESTClient& Client)
{
  openfluid::utils::RESTClient::Reply Reply;

  Reply = Client.getResource("/users");
  std::cout << "GET /users : " << Reply.getStatusCode() << std::endl;
  BOOST_REQUIRE(Reply.isOK());
  BOOST_REQUIRE_EQUAL(Reply.getStatusCode(),200);
  BOOST_REQUIRE_NE(Reply.getContent().indexOf("\"username\": \"Bret\""),-1);

  Reply = Client.getResource("/users/23");
  std::cout << "GET /users/23 : " << Reply.getStatusCode() << std::endl;
  std::cout << "  - " << Reply.getNetworkErrorCode() << ": " <<
               Reply.getNetworkErrorString().toStdString() << std::endl;
  BOOST_REQUIRE(!Reply.isOK());
  BOOST_REQUIRE_EQUAL(Reply.getStatusCode(),404);

  Reply = Client.getResource("/users/2");
  std::cout << "GET /users/2 : " << Reply.getStatusCode() << std::endl;
  BOOST_REQUIRE(Reply.isOK());
  BOOST_REQUIRE_EQUAL(Reply.getStatusCode(),200);
  BOOST_REQUIRE_NE(Reply.getContent().indexOf("\"username\": \"Antonette\""),-1);
}

void * msg_alloc3(size_t msg_i ,size_t total_msg, size_t total_p, size_t i, size_t ri, void * ptr)
{
	openfpm::vector<openfpm::vector<unsigned char>> * v = static_cast<openfpm::vector<openfpm::vector<unsigned char>> *>(ptr);

	v->add();

	prc_recv.add();

	BOOST_REQUIRE_EQUAL(msg_i, global_step);

	v->last().resize(msg_i);
	prc_recv.last() = i;
	return &(v->last().get(0));
}

static void test_set_backend_ids_for_enabled(session &sess)
{
	server_node &node = global_data->nodes.back();

	auto ids = generate_ids(16);

	ELLIPTICS_REQUIRE(async_set_result, sess.set_backend_ids(node.remote(), 4, ids));

	backend_status_result_entry result = async_set_result.get_one();
	BOOST_REQUIRE(result.is_valid());
	BOOST_REQUIRE_EQUAL(result.count(), 1);

	dnet_backend_status *status = result.backend(0);
	BOOST_REQUIRE_EQUAL(status->backend_id, 4);
	BOOST_REQUIRE_EQUAL(status->state, DNET_BACKEND_ENABLED);

	// Wait 0.1 secs to ensure that route list was changed
	usleep(100 * 1000);

	auto route_ids = backend_ids(sess, node.remote(), 4);
	BOOST_REQUIRE_EQUAL(ids.size(), route_ids.size());
	BOOST_REQUIRE(compare_ids(ids, route_ids));
}

void * msg_alloc2(size_t msg_i ,size_t total_msg, size_t total_p, size_t i, size_t ri, void * ptr)
{
	openfpm::vector<openfpm::vector<unsigned char>> * v = static_cast<openfpm::vector<openfpm::vector<unsigned char>> *>(ptr);

	v->resize(total_p);
	prc_recv.resize(total_p);

	BOOST_REQUIRE_EQUAL(msg_i, global_step);

	id++;
	v->get(id-1).resize(msg_i);
	prc_recv.get(id-1) = i;
	return &(v->get(id-1).get(0));
}

static void test_backend_status(session &sess)
{
	server_node &node = global_data->nodes[0];

	ELLIPTICS_REQUIRE(async_status_result, sess.request_backends_status(node.remote()));
	sync_backend_status_result result = async_status_result;

	BOOST_REQUIRE_EQUAL(result.size(), 1);

	backend_status_result_entry entry = result.front();

	BOOST_REQUIRE_EQUAL(entry.count(), backends_count);

	for (size_t i = 0; i < backends_count; ++i) {
		dnet_backend_status *status = entry.backend(i);
		BOOST_REQUIRE_EQUAL(status->backend_id, i);
		if (i < 2 || i == 3) {
			BOOST_REQUIRE_EQUAL(status->state, DNET_BACKEND_ENABLED);
		} else {
			BOOST_REQUIRE_EQUAL(status->state, DNET_BACKEND_DISABLED);
		}
	}
}

static void test_make_backend_readonly(session &sess)
{
	server_node &node = global_data->nodes.back();
	const key id = std::string("read_only_key");
	const std::string data = "read_only_data";

	ELLIPTICS_REQUIRE(async_readonly_result, sess.make_readonly(node.remote(), 4));

	backend_status_result_entry result = async_readonly_result.get_one();
	BOOST_REQUIRE(result.is_valid());
	BOOST_REQUIRE_EQUAL(result.count(), 1);

	dnet_backend_status *status = result.backend(0);
	BOOST_REQUIRE_EQUAL(status->backend_id, 4);
	BOOST_REQUIRE_EQUAL(status->read_only, true);

	session new_sess = sess.clone();
	new_sess.set_direct_id(node.remote(), 4);

	ELLIPTICS_REQUIRE_ERROR(write_result, new_sess.write_data(id, data, 0), -EROFS);

	ELLIPTICS_REQUIRE_ERROR(second_async_readonly_result, sess.make_readonly(node.remote(), 4), -EALREADY);
}

static void test_check_initial_config(session &sess) {
	auto &node = get_setup()->nodes.back();
	static const uint32_t backend_id = 4;

	ELLIPTICS_REQUIRE(result, sess.monitor_stat(node.remote(), DNET_MONITOR_BACKEND));
	BOOST_REQUIRE_EQUAL(result.get().size(), 1);

	auto monitor_initial_config = [&] () {
		std::istringstream stream(result.get().front().statistics());
		auto monitor_statistics = kora::dynamic::read_json(stream);
		return monitor_statistics.as_object()["backends"]
			.as_object()[std::to_string(backend_id)]
			.as_object()["backend"]
			.as_object()["initial_config"];
	} ();

	auto config_initial_config = [&] () {
		std::ifstream stream(node.config_path());
		auto config = kora::dynamic::read_json(stream);
		return config.as_object()["backends"].as_array()[backend_id];
	} ();
	BOOST_REQUIRE_EQUAL(monitor_initial_config, config_initial_config);
}

void assert_output_equals(const std::string& file, const std::string& output, const std::string& param1, const std::string& param2, const std::string& param3){
    auto configuration = parse_options("test/cases/" + file, param1, param2, param3);

    eddic::Compiler compiler;
    int code = compiler.compile("test/cases/" + file, configuration);

    BOOST_REQUIRE_EQUAL (code, 0);

    std::string out = eddic::execCommand("./" + param3); 
    
    BOOST_CHECK_EQUAL (output, out);
    
    remove("./" + param3);
}

  /**
   * Check the column count of a bound statement before and after adding a
   * column to a table.
   *
   * @param expected_column_count_after_update
   */
  void prepared_check_column_count_after_alter(size_t expected_column_count_after_update) {
    test_utils::CassSessionPtr session(test_utils::create_session(cluster));

    test_utils::execute_query(session.get(), str(boost::format("USE %s") % keyspace));

    test_utils::CassFuturePtr future(cass_session_prepare(session.get(), "SELECT * FROM test WHERE k = 'key1'"));
    BOOST_REQUIRE_EQUAL(cass_future_error_code(future.get()), CASS_OK);

    test_utils::CassPreparedPtr prepared(cass_future_get_prepared(future.get()));
    BOOST_REQUIRE(prepared);

    test_utils::CassStatementPtr bound_statement(cass_prepared_bind(prepared.get()));
    BOOST_REQUIRE(bound_statement);

    // Verify that the table has two columns in the metadata
    {
      test_utils::CassFuturePtr result_future(cass_session_execute(session.get(), bound_statement.get()));
      BOOST_REQUIRE_EQUAL(cass_future_error_code(result_future.get()), CASS_OK);

      test_utils::CassResultPtr result(cass_future_get_result(result_future.get()));

      BOOST_CHECK_EQUAL(cass_result_column_count(result.get()), 2u);
    }

    // Add a column to the table
    test_utils::execute_query(session.get(), "ALTER TABLE test ADD v2 int");

    // The column count shouldn't have changed
    {
      test_utils::CassFuturePtr result_future(cass_session_execute(session.get(), bound_statement.get()));
      BOOST_REQUIRE_EQUAL(cass_future_error_code(result_future.get()), CASS_OK);

      test_utils::CassResultPtr result(cass_future_get_result(result_future.get()));

      BOOST_CHECK_EQUAL(cass_result_column_count(result.get()), expected_column_count_after_update);
    }
  }

void run_test_6(void)
{
    typedef nova::dsp_thread_queue_item<dummy_runnable, Alloc> dsp_thread_queue_item;
    typedef nova::dsp_thread_queue<dummy_runnable, Alloc> dsp_thread_queue;
    typedef nova::dsp_threads<dummy_runnable, nova::nop_thread_init, Alloc> dsp_threads;

    typedef std::auto_ptr<dsp_thread_queue> dsp_thread_queue_ptr;

    dsp_threads t(2);
    t.start_threads();

    dsp_thread_queue_ptr q (new dsp_thread_queue(20));

    std::vector<dsp_thread_queue_item*> items;

    for (int i = 0; i != 20; ++i)
    {
        items.push_back(q->allocate_queue_item(dummy, typename dsp_thread_queue_item::successor_list(), 0));
        q->add_initially_runnable(items.back());
    }

    t.reset_queue(MOVE(q));

    const int iterations = 10000;

    for (int i = 0; i != iterations; ++i)
    {
        for (int item = 0; item != 20; ++item)
            BOOST_REQUIRE_EQUAL(items[item]->get_job().i, i);
        t.run();
    }

    t.terminate_threads();

    for (int i = 0; i != 20; ++i)
        BOOST_REQUIRE_EQUAL(items[i]->get_job().i, iterations);
}

/* Run two small non-overlapping rings with different delays */
void
runDoubleRing(backend_t backend)
{
	/* Make sure we go around the ring at least a couple of times */
	const unsigned ncount = 512;
	const unsigned duration = ncount * 5 / 2;

	nemo::Configuration conf = configuration(false, 1024);
	setBackend(backend, conf);

	boost::scoped_ptr<nemo::Network> net(new nemo::Network);

	createRing(net.get(), ncount, 0, false, 1, 1);
	createRing(net.get(), ncount, ncount, false, 1, 2);

	boost::scoped_ptr<nemo::Simulation> sim(nemo::simulation(*net, conf));

	/* Stimulate a single neuron in each ring to get them going */
	std::vector<unsigned> fstim;
	fstim.push_back(0);
	fstim.push_back(ncount);

	sim->step(fstim);

	for(unsigned ms=1; ms < duration; ++ms) {
		const std::vector<unsigned>& fired = sim->step();
		if(ms % 2 == 0) {
			BOOST_CHECK_EQUAL(fired.size(), 2U);
			BOOST_REQUIRE_EQUAL(fired[0], ms % ncount);
			BOOST_REQUIRE_EQUAL(fired[1], ncount + (ms / 2) % ncount);
		} else {
			BOOST_CHECK_EQUAL(fired.size(), 1U);
			BOOST_REQUIRE_EQUAL(fired.front(), ms % ncount);
		}
	}
}

//-----------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE_TEMPLATE(
    eventTestShouldBeFalseWhileInQueueAndTrueAfterBeingProcessed,
    TDevStream,
    TestStreams)
{
    using Fixture = alpaka::test::stream::StreamTestFixture<TDevStream>;
    using Stream = typename Fixture::Stream;
    using Dev = typename Fixture::Dev;

    Fixture f1;
    auto s1 = f1.m_stream;
    alpaka::event::Event<Stream> e1(f1.m_dev);
    alpaka::test::event::EventHostManualTrigger<Dev> k1(f1.m_dev);

    if(!alpaka::test::stream::IsSyncStream<Stream>::value)
    {
        alpaka::stream::enqueue(s1, k1);
    }

    alpaka::stream::enqueue(s1, e1);

    if(!alpaka::test::stream::IsSyncStream<Stream>::value)
    {
        BOOST_REQUIRE_EQUAL(
            false,
            alpaka::event::test(e1));

        k1.trigger();

        alpaka::wait::wait(s1);
    }

    BOOST_REQUIRE_EQUAL(
        true,
        alpaka::event::test(e1));
}

		void ExpectActionSucceeds(Fn && action, bool expectEngineIsOn, CCar::Gear expectedGear, int expectedSpeed)
		{
			BOOST_REQUIRE_NO_THROW(action());
			BOOST_REQUIRE_EQUAL(car.IsEngineOn(), expectEngineIsOn);
			if (expectEngineIsOn)
			{
				BOOST_CHECK(car.GetGear() == expectedGear);
				BOOST_CHECK_EQUAL(car.GetSpeed(), expectedSpeed);
				auto expectedDirection =
					(expectedSpeed > 0) ? Direction::Forward :
					(expectedSpeed < 0) ? Direction::Backward :
					Direction::StandStill;
				BOOST_CHECK(car.GetDirection() == expectedDirection);
			}
		}

  /**
   * Verify the address UDT field names
   *
   * @param value The address UDT value to iterate over
   */
  void verify_address_udt_field_names(const CassValue* value) {
    // Ensure the value is a UDT and create the iterator for the validation
    BOOST_REQUIRE_EQUAL(cass_value_type(value), CASS_VALUE_TYPE_UDT);
    BOOST_REQUIRE_EQUAL(cass_value_item_count(value), 3);
    test_utils::CassIteratorPtr iterator(cass_iterator_from_user_type(value));

    // Verify street field name
    BOOST_REQUIRE(cass_iterator_next(iterator.get()));
    CassString street_field_name;
    BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(), &street_field_name.data, &street_field_name.length), CASS_OK);
    BOOST_REQUIRE(test_utils::Value<CassString>::equal("street", street_field_name));

    // Verify zip field name
    BOOST_REQUIRE(cass_iterator_next(iterator.get()));
    CassString zip_field_name;
    BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(), &zip_field_name.data, &zip_field_name.length), CASS_OK);
    BOOST_REQUIRE(test_utils::Value<CassString>::equal("ZIP", zip_field_name));

    // Verify phone numbers field name
    BOOST_REQUIRE(cass_iterator_next(iterator.get()));
    CassString phone_numbers_field_name;
    BOOST_REQUIRE_EQUAL(cass_iterator_get_user_type_field_name(iterator.get(), &phone_numbers_field_name.data, &phone_numbers_field_name.length), CASS_OK);
    BOOST_REQUIRE(test_utils::Value<CassString>::equal("phone_numbers", phone_numbers_field_name));
  }

void checkContainersSize(const JPetParamBank& bank)
{
  JPetDBParamGetter::clearParamCache();
  BOOST_REQUIRE_EQUAL(bank.getScintillatorsSize(), 2);
  BOOST_REQUIRE_EQUAL(bank.getPMsSize(), 4);
  BOOST_REQUIRE_EQUAL(bank.getFEBsSize(), 1);
  BOOST_REQUIRE_EQUAL(bank.getTRBsSize(), 1);
  BOOST_REQUIRE_EQUAL(bank.getBarrelSlotsSize(), 2);
  BOOST_REQUIRE_EQUAL(bank.getTOMBChannelsSize(), 4);
}

BOOST_FIXTURE_TEST_CASE(Triple, Fixture)
{
  ValidatorNull nullValidator;
  SegmentFetcher::fetch(face, Interest("/hello/world", time::seconds(1000)),
                        nullValidator,
                        bind(&Fixture::onComplete, this, _1),
                        bind(&Fixture::onError, this, _1));

  advanceClocks(time::milliseconds(1), 10);
  face.receive(*makeDataSegment("/hello/world/version0", 0, false));

  advanceClocks(time::milliseconds(1), 10);
  face.receive(*makeDataSegment("/hello/world/version0", 1, false));

  advanceClocks(time::milliseconds(1), 10);
  face.receive(*makeDataSegment("/hello/world/version0", 2, true));

  advanceClocks(time::milliseconds(1), 10);

  BOOST_CHECK_EQUAL(nErrors, 0);
  BOOST_CHECK_EQUAL(nDatas, 1);

  BOOST_CHECK_EQUAL(dataSize, 42);

  BOOST_REQUIRE_EQUAL(face.sentInterests.size(), 3);
  BOOST_CHECK_EQUAL(face.sentData.size(), 0);

  {
    const Interest& interest = face.sentInterests[0];
    BOOST_CHECK_EQUAL(interest.getName(), "/hello/world");
    BOOST_CHECK_EQUAL(interest.getMustBeFresh(), true);
    BOOST_CHECK_EQUAL(interest.getChildSelector(), 1);
  }

  {
    const Interest& interest = face.sentInterests[1];
    BOOST_CHECK_EQUAL(interest.getName(), "/hello/world/version0/%00%01");
    BOOST_CHECK_EQUAL(interest.getMustBeFresh(), false);
    BOOST_CHECK_EQUAL(interest.getChildSelector(), 0);
  }

  {
    const Interest& interest = face.sentInterests[2];
    BOOST_CHECK_EQUAL(interest.getName(),  "/hello/world/version0/%00%02");
    BOOST_CHECK_EQUAL(interest.getMustBeFresh(), false);
    BOOST_CHECK_EQUAL(interest.getChildSelector(), 0);
  }
}