torstenrobitzki / sioux Goto Github PK

provide a single rake target which runs all unit tests with all flavors (or at least debug/release). Additional target for all component tests, and for unit tests and component tests.

The test doesn't comes to an end under linux and looks like there must be some target and that could not be hard coded 192.168.1.1:88

separate unit tests and component tests at the rake level:
rake unit_tests
rake component_tests

This isn't a biggie but when calling boost::asio::async_write() with the test socket and a buffer of 0 bytes while having set an output callback this code fails:

if ( !output_callback_.empty() )
    output_callback_( boost::asio::buffer( &output_[ output_.size() - size ], size ) );

( It is part of void socket<Iterator, Timer, Trait>::impl::undelayed_async_write_some. )

As size == 0,

output_[ output_.size() - size ] 

is out of bounds.

One might of cause reason that one shouldn't call async_write_some(...) with a 0 length buffer but it is always nice to not have it crash.

An upcall to the ruby adapters pubsub() function will block the C++ server thread.

Move the http proxy implementation and tests into its own folder and namespace

Add a rake task, to create a CMake makefille to build all libraries, examples and tests. The rake task should use the information provided to rake by the current build system.

An IE9 sending a UA-CPU header with the value AMD64 causes a Nil-Class access. Rack-Lint reports a variable nil with a value of AMD64.

If in the rack_chat.rb example, the message array is not empty, the client get no initial data, nor updates.

A second subscription to an node, where the validation failed, will not get an error message using pubsub.http

If two arrays are compared and the elements of the arrays are large (40 bytes), the A* algorithm evaluates a lot of delete operations. This delete operations are very cheap (operation code + index) compared with a previous applies update, insert or edit operation of one array element (larger than 40 bytes).

The used heuristic doesn't add much to push the algorithm faster than dijkstra towards a solution, as it just estimates very small amounts for differences in the length of the arrays.

during rack_test:
Assertion failed: (pos != index_.end()), function idle_session, file /Users/todi/sioux/source/bayeux/bayeux.cpp, line 95.

Hi,

I've been playing around with your test socket class and I found that if it is used with Asio's async_read_until(), it will cause Asio to call the handler before the actual delimiter is found even though there is no delimiter in the data.

What happens is that Asio will repeatedly call undelayed_async_read_some() on the test socket and when the data is exhaused you will post an** ec(boost::system::errc::success)** and size(0) to the io_service queue. This will cause Asio to stop reading and call the handler because size==0. But since there is no error, the handler is called as if everything is OK and a delimiter was found.

Am I doing something wrong or should your undelayed_async_read_some() either not post a result or post an error when the test data is exhaused?

Thanks for letting us use this test code.

Cheers,

Tim

For faster tests

It should be possible to assign a ruby value to a pubsub subscriber and change that value within call backs.

use bundler to install perquisites

JSONP is needed to support cross side pushing.

not user-agent is translated to HTTP_USER-AGENT and should be translated to HTTP_USER_AGENT