rails-devel — List for discussion of Rails development

[Rails-devel] Bugs at Game Start (was: [Rails-users] A few bugs)

[Stefan F. <ste...@we...>]

Are-Harald:
thanks for your report.

I can confirm both bugs, however on first glance it seems that they are 
not related.

For reference I have attached save files that belong to the two bugs, 
maybe Erik will be interested into the save on start bug.

Stefan


On 06/10/2012 11:40 PM, Are-Harald Brenne wrote:
> Two bugs:
>
> - If you try to add a comment at the start of the game before any move
> has been made, the game stops working. You can make a bid or purchase
> a private, but the round never progresses to the next player.
> - If you save the game at the start before any move has been made, the
> game bugs on reloading, similar symptoms as above.
>
> This came up when I tried to start a game for play through dropbox and
> email, where I'm not the first player out.
>
> Thanks to the developers for making this very nice piece of software!
>
> Cheers,
> Are-Harald
>
> ------------------------------------------------------------------------------
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and
> threat landscape has changed and how IT managers can respond. Discussions
> will include endpoint security, mobile security and the latest in malware
> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Rails-users mailing list
> Rai...@li...
> https://lists.sourceforge.net/lists/listinfo/rails-users

[Rails-devel] Minor bug, 1835, 1.7.6

[John D. G. <jd...@di...>]

The BY just used the Pfalz to place a token, which is supposed to close the
Pfalz but didn't.  (The BA laid its own home tile.)

Perhaps a "close private" menu option is called for as in 1856.

Re: [Rails-devel] Rails-devel Digest, Vol 55, Issue 7

[Erik V. <eri...@xs...>]

I agree.

Erik.

 

From: kos petoussis [mailto:kos...@gm...] 
Sent: Saturday, June 09, 2012 10:39 AM
To: eri...@xs...
Subject: Fwd: Rails-devel Digest, Vol 55, Issue 7

 

about "Message 1": 
json is the modern way to go. You still will need to make objects that map
1:1 to the json representation, but it is not slow and readable.
If you have a backlog of xml, you can consider xstream.
http://xstream.codehaus.org/json-tutorial.html

gl,
kos

---------- Forwarded message ----------
From: <rai...@li...>
Date: 2012/6/8
Subject: Rails-devel Digest, Vol 55, Issue 7
To: rai...@li...


Send Rails-devel mailing list submissions to
       rai...@li...

To subscribe or unsubscribe via the World Wide Web, visit
       https://lists.sourceforge.net/lists/listinfo/rails-devel
or, via email, send a message with subject or body 'help' to
       rai...@li...

You can reach the person managing the list at
       rai...@li...

When replying, please edit your Subject line so it is more specific
than "Re: Contents of Rails-devel digest..."


Today's Topics:

  1. Re: Another library to add? (Erik Vos)
  2. Re: Mocking library chosen (brett lentz)
  3. Re: Mocking library chosen (Stefan Frey)
  4. Re: Another library to add? (Stefan Frey)


----------------------------------------------------------------------

Message: 1
Date: Wed, 6 Jun 2012 22:47:21 +0200
From: "Erik Vos" <eri...@xs...>
Subject: Re: [Rails-devel] Another library to add?
To: "'Development list for Rails: an 18xx game'"
       <rai...@li...>
Message-ID: <001301cd4425$921dd600$b6598200$@xs4all.nl>
Content-Type: text/plain;       charset="US-ASCII"

What problems would this solve?

For initialization: it would be nice if XML data and objects were anywhere
near have a to 1:1 relationship, but in many cases that is far from being
the case.
So I suppose this would cause much rework.

For communication: I would tend to consider XML too verbose for such a
purpose.  It's not for nothing that (I believe) Google has invented a more
compact format.
And for all I know XML parsing and creation is slooow, but perhaps that is
due to the old libraries we now use?
Indeed we need something, but I can't provide much insight.
I had in mind something like uuencoded Serialized objects (the Java way),
but I suppose that is way too primitive for these days.
And of course it would be a big benefit if the transmission is readable.

Anyway, don't be put off by my (as usual) somewhat sceptical attitude.  I'm
way backwards in most of these matters.

Erik

Re: [Rails-devel] Mocking library chosen

[Erik V. <eri...@xs...>]

> So my conclusion is: In a perfectly designed program everything appears to
> be trivial.

That's indeed the most important quality of a good design.  The big problem
is: how to get there.  But that's another story (or perhaps not).

Erik.

Re: [Rails-devel] Mocking library chosen

[Stefan F. <ste...@we...>]

Erik,
yes it is easy to create a lot of trivial test cases (e.g. testing 
getters and setters), so I usually will skip those. However sometimes 
e.g. the setter checks conditions or the getter itself does a 
calculation before returning, then it is worth testing.

I am not a specialist in the subtleties of the definitions of various 
types of testing, but the scenario you mentioned below is in my opinion 
still unit testing.

The more interesting question is how you setup the scenario:
Do you try a simple realistic scenario where you have e.g. a fully 
defined TrainManager etc. or do you everything except
the Phase object mocked? The first case is more difficult to setup, the 
latter is closer to being trivial (e.g. only testing that Phase is 
calling the TrainManager.releaseTrain() method, just guessing I do not 
know how it works in practice).

The trade-off between complexity and trivial reminds me of the following 
anecdote: I had the pleasure to hear a lecture of a noble prize winner 
on a smaller conference shortly after the official ceremony where he got 
the price officially awarded.

He was in a press conference where the journalists were asking him, oh 
could you please explain what your contribution was. So he simplified 
things a little bit, press people were still confused: A little simpler 
please. And he did that too, but this was not enough. In the end he was 
able to summarize things a few sentences. The next question then was: 
"How is it possible to get a noble prize with something that easy?"

So my conclusion is: In a perfectly designed program everything appears 
to be trivial.

Stefan

On 06/08/2012 04:12 PM, Erik Vos wrote:
> Stefan,
>
> Thanks for your informational lecture.  Unit testing is an old concept, of
> which I was well aware, but I have not really used it  in practice
> throughout my professional life, and certainly not in an OO environment.
> Mocking and stubbing are new to me, but I understand their purpose now.
>
> The (superficial) impression I'm getting is that it is easy to test the
> things that are hard to get wrong, but a lot more difficult to test complex
> stuff that is easy to get wrong.
> For instance, how would you test that on a phase change a new train type
> does become available?  Or does such a test already go beyond unit testing?
>
> Of course, a good design reduces the existence of such complexities as much
> as possible.  But we all know that Rails has grown in a different way.
> Hopefully Rails 2.0 will improve that a great deal.
>
> Erik.
>
>> -----Original Message-----
>> From: Stefan Frey [mailto:ste...@we...]
>> Sent: Friday, June 08, 2012 2:56 PM
>> To: Development list for Rails: an 18xx game
>> Subject: Re: [Rails-devel] Mocking library chosen
>>
>> Brett and Erik:
>>
>> Some comments see below:
>>
>> * Test location:
>> Yes as mentioned below in Rails 2.0 there are now two top-level
> directories:
>> /src
>> /junit
>>
>> where below src is all of the existing code and below junit everything for
>> testing will be added.
>>
>> The hierarchy in junit will mirror that of src so that the tests are easy
> to find.
>>
>> * Code/Release size:
>> Code size of Rails (below src) itself is not effected directly, but I hope
> to
>> reduce the code by removing code duplication. However this will be easily
>> offset by new functionality.
>>
>> The release size does not change as well as neither the test jars nor the
> test
>> source is part of the release package.
>>
>> * Some more details for Erik:
>>
>> * Unit tests
>> The main idea behind unit tests is that of "never change a running
> system".
>> This is correct observation, however not changing a system is bad too,
>> because this will easily lead to code duplication. So unit tests allow to
> "change
>> a system, but keep it running".
>> If you have automated tests that run before you changed the systems and
>> after you changed the system, in fact you kept the system running, but you
>> are still able to re-factor
>>
>> Another nice term I found for unit tests is "necessary waste":
>> For perfect coders it is a waste of time, but as most of us are not of
> that kind,
>> it is necessary.
>>
>> Actually unit testing and mocking is not that is not too difficult
> conceptually.
>> Someone who got a graphical 1830 moderator working as you did, should
>> have no problem to understand them.
>>
>> Unit testing itself mirrors the tests which are possible in an interpreted
>> language:
>> A) Write a function add(x,y) = x+y
>> B) Call the function with foo(10, 15) in the console
>> C) Check manually that the result is 25 and that no error was raised
>>
>> A unit test is:
>> A) Write a function add(x,y) = x+y
>> B) Write a test addTest(): assert(add(x,y),25)
>> C) Start the test runner which reports passed if add(x,y) == 25 or fails
> if
>> add(x,y) != 25 or returns an error.
>>
>> If you reverse A and B, thus you write the test before the actual code it
> is
>> called TestDrivenDevelopment (TDD)
>>
>> * Mocks
>> Usually you want to test classes as independent entities. And you want to
>> configure setup the class to test alone.
>>
>> However often a method call requires or the construction of a class
> requires
>> other objects.
>>
>> A mock library allows you to create a "phantom" object that pretends to be
> a
>> object of the class, however actually does nothing at all.
>>
>> Example:
>> If you create a Player mock using
>> Player p = mock(Player.class)
>> the variable p now can be passed as a player object and all methods of a
>> player class can be called on p and everything compiles correctly.
>> But in fact nothing happens if one calls methods on p.
>>
>> Or more precise nearly nothing happens:
>> It is possible to ask the mock later if the methods got called.
>>
>> Assume that you test a function that adds a train to a player. It has two
> tasks:
>> A) Add the train to the player
>> B) Change the owner of the train to the player
>>
>> Now you can either create fully initialized player and train objects.
>>
>> However it might be easier to mock both player and train using Player p =
>> mock(Player.class) and Train t = mock(Train.class)
>>
>> The function is called transferTrain(Player p, Train t).
>>
>> You pass both mocks to the function and then check that the function has
>> called the according methods of player and train:
>>
>> verify(player).addTrain(t)
>> verify(train).setOwner(p)
>>
>> Here it is easy to see why a test with fully initialized objects might be
> a little
>> stronger:
>> Then you would check that the train and player really have changed e.g.
>> by assert(train.getOwner(),p), however this is would be already a joint
> test
>> of both the function under test and the train object.
>>
>> There is a related technique called stubbing: In that case you not only
> create
>> a phantom object, but more a skeleton object. A stub for a Player would be
> a
>> minimal but working implementation.
>>
>> Mockito supports simple/basic stubbing as well: Assume that function would
>> only succeed if the addTrain method of player returns a True value. This
> is
>> possible by instructing the mock object to return that on a call of
> addTrain by:
>> when(p.addTrain(t)).thenReturn(True)
>>
>> Feel free to ask more questions if you like.
>>
>> Stefan
>
>
> ------------------------------------------------------------------------------
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and
> threat landscape has changed and how IT managers can respond. Discussions
> will include endpoint security, mobile security and the latest in malware
> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Rails-devel mailing list
> Rai...@li...
> https://lists.sourceforge.net/lists/listinfo/rails-devel

Re: [Rails-devel] Mocking library chosen

[brett l. <bre...@gm...>]

On Fri, Jun 8, 2012 at 10:12 AM, Erik Vos <eri...@xs...> wrote:
> Stefan,
>
> Thanks for your informational lecture.  Unit testing is an old concept, of
> which I was well aware, but I have not really used it  in practice
> throughout my professional life, and certainly not in an OO environment.
> Mocking and stubbing are new to me, but I understand their purpose now.
>
> The (superficial) impression I'm getting is that it is easy to test the
> things that are hard to get wrong, but a lot more difficult to test complex
> stuff that is easy to get wrong.
> For instance, how would you test that on a phase change a new train type
> does become available?  Or does such a test already go beyond unit testing?
>

This is an area where it's important to have good OO design.

The idea would be to mock/stub out dependencies of the Phase object,
possibly all the way up to a mocked up GameManager. Then you'd
instantiate a real Phase object (or set of Phase objects) with the
mocked input data/objects. Finally, you'd call the sequence of methods
that represents a phase change, and validate that the Phase object or
the other appropriate mocked objects contain the data you expect.

It's more complicated, and not everything is easy to mock or test, but
sometimes just by going through the process of trying to test it you
might realize that there's a change needed to the code that will make
it more testable and less bug-prone. This extends into TDD where, by
designing the test up front, you're spending time thinking through the
design and the tests describe how you'd expect the code to operate.


> Of course, a good design reduces the existence of such complexities as much
> as possible.  But we all know that Rails has grown in a different way.
> Hopefully Rails 2.0 will improve that a great deal.
>
> Erik.
>

---Brett.

>> -----Original Message-----
>> From: Stefan Frey [mailto:ste...@we...]
>> Sent: Friday, June 08, 2012 2:56 PM
>> To: Development list for Rails: an 18xx game
>> Subject: Re: [Rails-devel] Mocking library chosen
>>
>> Brett and Erik:
>>
>> Some comments see below:
>>
>> * Test location:
>> Yes as mentioned below in Rails 2.0 there are now two top-level
> directories:
>> /src
>> /junit
>>
>> where below src is all of the existing code and below junit everything for
>> testing will be added.
>>
>> The hierarchy in junit will mirror that of src so that the tests are easy
> to find.
>>
>> * Code/Release size:
>> Code size of Rails (below src) itself is not effected directly, but I hope
> to
>> reduce the code by removing code duplication. However this will be easily
>> offset by new functionality.
>>
>> The release size does not change as well as neither the test jars nor the
> test
>> source is part of the release package.
>>
>> * Some more details for Erik:
>>
>> * Unit tests
>> The main idea behind unit tests is that of "never change a running
> system".
>> This is correct observation, however not changing a system is bad too,
>> because this will easily lead to code duplication. So unit tests allow to
> "change
>> a system, but keep it running".
>> If you have automated tests that run before you changed the systems and
>> after you changed the system, in fact you kept the system running, but you
>> are still able to re-factor
>>
>> Another nice term I found for unit tests is "necessary waste":
>> For perfect coders it is a waste of time, but as most of us are not of
> that kind,
>> it is necessary.
>>
>> Actually unit testing and mocking is not that is not too difficult
> conceptually.
>> Someone who got a graphical 1830 moderator working as you did, should
>> have no problem to understand them.
>>
>> Unit testing itself mirrors the tests which are possible in an interpreted
>> language:
>> A) Write a function add(x,y) = x+y
>> B) Call the function with foo(10, 15) in the console
>> C) Check manually that the result is 25 and that no error was raised
>>
>> A unit test is:
>> A) Write a function add(x,y) = x+y
>> B) Write a test addTest(): assert(add(x,y),25)
>> C) Start the test runner which reports passed if add(x,y) == 25 or fails
> if
>> add(x,y) != 25 or returns an error.
>>
>> If you reverse A and B, thus you write the test before the actual code it
> is
>> called TestDrivenDevelopment (TDD)
>>
>> * Mocks
>> Usually you want to test classes as independent entities. And you want to
>> configure setup the class to test alone.
>>
>> However often a method call requires or the construction of a class
> requires
>> other objects.
>>
>> A mock library allows you to create a "phantom" object that pretends to be
> a
>> object of the class, however actually does nothing at all.
>>
>> Example:
>> If you create a Player mock using
>> Player p = mock(Player.class)
>> the variable p now can be passed as a player object and all methods of a
>> player class can be called on p and everything compiles correctly.
>> But in fact nothing happens if one calls methods on p.
>>
>> Or more precise nearly nothing happens:
>> It is possible to ask the mock later if the methods got called.
>>
>> Assume that you test a function that adds a train to a player. It has two
> tasks:
>> A) Add the train to the player
>> B) Change the owner of the train to the player
>>
>> Now you can either create fully initialized player and train objects.
>>
>> However it might be easier to mock both player and train using Player p =
>> mock(Player.class) and Train t = mock(Train.class)
>>
>> The function is called transferTrain(Player p, Train t).
>>
>> You pass both mocks to the function and then check that the function has
>> called the according methods of player and train:
>>
>> verify(player).addTrain(t)
>> verify(train).setOwner(p)
>>
>> Here it is easy to see why a test with fully initialized objects might be
> a little
>> stronger:
>> Then you would check that the train and player really have changed e.g.
>> by assert(train.getOwner(),p), however this is would be already a joint
> test
>> of both the function under test and the train object.
>>
>> There is a related technique called stubbing: In that case you not only
> create
>> a phantom object, but more a skeleton object. A stub for a Player would be
> a
>> minimal but working implementation.
>>
>> Mockito supports simple/basic stubbing as well: Assume that function would
>> only succeed if the addTrain method of player returns a True value. This
> is
>> possible by instructing the mock object to return that on a call of
> addTrain by:
>> when(p.addTrain(t)).thenReturn(True)
>>
>> Feel free to ask more questions if you like.
>>
>> Stefan
>
>
> ------------------------------------------------------------------------------
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and
> threat landscape has changed and how IT managers can respond. Discussions
> will include endpoint security, mobile security and the latest in malware
> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Rails-devel mailing list
> Rai...@li...
> https://lists.sourceforge.net/lists/listinfo/rails-devel

Re: [Rails-devel] Mocking library chosen

[Erik V. <eri...@xs...>]

Stefan,

Thanks for your informational lecture.  Unit testing is an old concept, of
which I was well aware, but I have not really used it  in practice
throughout my professional life, and certainly not in an OO environment.
Mocking and stubbing are new to me, but I understand their purpose now.

The (superficial) impression I'm getting is that it is easy to test the
things that are hard to get wrong, but a lot more difficult to test complex
stuff that is easy to get wrong.
For instance, how would you test that on a phase change a new train type
does become available?  Or does such a test already go beyond unit testing?

Of course, a good design reduces the existence of such complexities as much
as possible.  But we all know that Rails has grown in a different way.
Hopefully Rails 2.0 will improve that a great deal.

Erik.

> -----Original Message-----
> From: Stefan Frey [mailto:ste...@we...]
> Sent: Friday, June 08, 2012 2:56 PM
> To: Development list for Rails: an 18xx game
> Subject: Re: [Rails-devel] Mocking library chosen
> 
> Brett and Erik:
> 
> Some comments see below:
> 
> * Test location:
> Yes as mentioned below in Rails 2.0 there are now two top-level
directories:
> /src
> /junit
> 
> where below src is all of the existing code and below junit everything for
> testing will be added.
> 
> The hierarchy in junit will mirror that of src so that the tests are easy
to find.
> 
> * Code/Release size:
> Code size of Rails (below src) itself is not effected directly, but I hope
to
> reduce the code by removing code duplication. However this will be easily
> offset by new functionality.
> 
> The release size does not change as well as neither the test jars nor the
test
> source is part of the release package.
> 
> * Some more details for Erik:
> 
> * Unit tests
> The main idea behind unit tests is that of "never change a running
system".
> This is correct observation, however not changing a system is bad too,
> because this will easily lead to code duplication. So unit tests allow to
"change
> a system, but keep it running".
> If you have automated tests that run before you changed the systems and
> after you changed the system, in fact you kept the system running, but you
> are still able to re-factor
> 
> Another nice term I found for unit tests is "necessary waste":
> For perfect coders it is a waste of time, but as most of us are not of
that kind,
> it is necessary.
> 
> Actually unit testing and mocking is not that is not too difficult
conceptually.
> Someone who got a graphical 1830 moderator working as you did, should
> have no problem to understand them.
> 
> Unit testing itself mirrors the tests which are possible in an interpreted
> language:
> A) Write a function add(x,y) = x+y
> B) Call the function with foo(10, 15) in the console
> C) Check manually that the result is 25 and that no error was raised
> 
> A unit test is:
> A) Write a function add(x,y) = x+y
> B) Write a test addTest(): assert(add(x,y),25)
> C) Start the test runner which reports passed if add(x,y) == 25 or fails
if
> add(x,y) != 25 or returns an error.
> 
> If you reverse A and B, thus you write the test before the actual code it
is
> called TestDrivenDevelopment (TDD)
> 
> * Mocks
> Usually you want to test classes as independent entities. And you want to
> configure setup the class to test alone.
> 
> However often a method call requires or the construction of a class
requires
> other objects.
> 
> A mock library allows you to create a "phantom" object that pretends to be
a
> object of the class, however actually does nothing at all.
> 
> Example:
> If you create a Player mock using
> Player p = mock(Player.class)
> the variable p now can be passed as a player object and all methods of a
> player class can be called on p and everything compiles correctly.
> But in fact nothing happens if one calls methods on p.
> 
> Or more precise nearly nothing happens:
> It is possible to ask the mock later if the methods got called.
> 
> Assume that you test a function that adds a train to a player. It has two
tasks:
> A) Add the train to the player
> B) Change the owner of the train to the player
> 
> Now you can either create fully initialized player and train objects.
> 
> However it might be easier to mock both player and train using Player p =
> mock(Player.class) and Train t = mock(Train.class)
> 
> The function is called transferTrain(Player p, Train t).
> 
> You pass both mocks to the function and then check that the function has
> called the according methods of player and train:
> 
> verify(player).addTrain(t)
> verify(train).setOwner(p)
> 
> Here it is easy to see why a test with fully initialized objects might be
a little
> stronger:
> Then you would check that the train and player really have changed e.g.
> by assert(train.getOwner(),p), however this is would be already a joint
test
> of both the function under test and the train object.
> 
> There is a related technique called stubbing: In that case you not only
create
> a phantom object, but more a skeleton object. A stub for a Player would be
a
> minimal but working implementation.
> 
> Mockito supports simple/basic stubbing as well: Assume that function would
> only succeed if the addTrain method of player returns a True value. This
is
> possible by instructing the mock object to return that on a call of
addTrain by:
> when(p.addTrain(t)).thenReturn(True)
> 
> Feel free to ask more questions if you like.
> 
> Stefan

Re: [Rails-devel] Another library to add?

[Stefan F. <ste...@we...>]

Erik:
first of all it could help to solve the problem you describe below.
Currently the xml encoding and the rails classes are far from being a
one:to:one relationship.
Even if there is good reason to have that, it would be easier to 
support, test and code if the xml gets first read into a java object 
that closely resembles that structure and then translate that into the 
object that is used later on inside Rails.

Example:
You would first create a CompanyDefinition object which is very close 
the XML and then this is converted into the true Rails Company object.
This would allow disconnect the creation of a Rails company from the xml 
code an thus make it easier to create a company by code directly for 
testing.

And your question what does including a new technology helps us solving 
is always a relevant one, there is nothing backwards with that approach.
Stefan

On 06/06/2012 10:47 PM, Erik Vos wrote:
> What problems would this solve?
>
> For initialization: it would be nice if XML data and objects were anywhere
> near have a to 1:1 relationship, but in many cases that is far from being
> the case.
> So I suppose this would cause much rework.
>
> For communication: I would tend to consider XML too verbose for such a
> purpose.  It's not for nothing that (I believe) Google has invented a more
> compact format.
> And for all I know XML parsing and creation is slooow, but perhaps that is
> due to the old libraries we now use?
> Indeed we need something, but I can't provide much insight.
> I had in mind something like uuencoded Serialized objects (the Java way),
> but I suppose that is way too primitive for these days.
> And of course it would be a big benefit if the transmission is readable.
>
> Anyway, don't be put off by my (as usual) somewhat sceptical attitude.  I'm
> way backwards in most of these matters.
>
> Erik
>
>> -----Original Message-----
>> From: brett lentz [mailto:bre...@gm...]
>> Sent: Wednesday, June 06, 2012 7:05 PM
>> To: Development list for Rails: an 18xx game
>> Subject: Re: [Rails-devel] Another library to add?
>>
>> On Wed, Jun 6, 2012 at 12:55 PM, Stefan Frey<ste...@we...>  wrote:
>>> Brett&  Erik,
>>> going forward I am considering refactoring the xml initialization of
>>> Rails. Further I did a short comparison of the feature and syntax of a
>>> few xml serialization libraries for java and very quickly found one
>>> that pleases me.
>>>
>>> The idea of the newer libraries add is that it is possible to align
>>> the java classes and xml elements, so that in effect you do not have
>>> to write anymore manually for parsing. Most of them use annotations to
>>> control this mechanism.
>>>
>>
>> +1 from me. Annotation/Decorators are a fantastic way to handle this.
>> Also, the removal of manual parsing code is a huge win, IMO.
>>
>>> So my proposal is to use Simple Serialization Library (see
>>> http://simple.sourceforge.net/home.php)
>>>
>>> Checkout
>>> http://simple.sourceforge.net/download/stream/doc/tutorial/tutorial.ph
>>> p
>>> for documentation and code examples).
>>>
>>> (Reasonable Alternatives were XStream and Jackson with XML extension
>>> and Protostuff, I do not like JAXB)
>>>
>>> I am still considering to choose a more compact format (like Json or
>>> even a binary one like Kryo or Smile) for the planned network play.
>>
>> Given the choice, I'd opt for JSON or YAML over binary formats.
>> They're well-known, well-supported, and (most importantly) easier to
>> debug.
>>
>> Over the wire, we can use compression to slim down the bandwidth
>> requirements of transmitting plain-text data.
>>
>>>
>>> Stefan
>>>
>>
>> ---Brett.
>>
>>
> ----------------------------------------------------------------------------
> --
>> Live Security Virtual Conference
>> Exclusive live event will cover all the ways today's security and threat
>> landscape has changed and how IT managers can respond. Discussions will
>> include endpoint security, mobile security and the latest in malware
> threats.
>> http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
>> _______________________________________________
>> Rails-devel mailing list
>> Rai...@li...
>> https://lists.sourceforge.net/lists/listinfo/rails-devel
>
>
> ------------------------------------------------------------------------------
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and
> threat landscape has changed and how IT managers can respond. Discussions
> will include endpoint security, mobile security and the latest in malware
> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Rails-devel mailing list
> Rai...@li...
> https://lists.sourceforge.net/lists/listinfo/rails-devel

Re: [Rails-devel] Mocking library chosen

[Stefan F. <ste...@we...>]

Brett and Erik:

Some comments see below:

* Test location:
Yes as mentioned below in Rails 2.0 there are now two top-level directories:
/src
/junit

where below src is all of the existing code and below junit everything
for testing will be added.

The hierarchy in junit will mirror that of src so that the tests are 
easy to find.

* Code/Release size:
Code size of Rails (below src) itself is not effected directly, but I 
hope to reduce the code by removing code duplication. However this will 
be easily offset by new functionality.

The release size does not change as well as neither the test jars nor 
the test source is part of the release package.

* Some more details for Erik:

* Unit tests
The main idea behind unit tests is that of "never change a running 
system". This is correct observation, however not changing a system is 
bad too, because this will easily lead to code duplication. So unit 
tests allow to "change a system, but keep it running".
If you have automated tests that run before you changed the systems and 
after you changed the system, in fact you kept the system running, but 
you are still able to re-factor

Another nice term I found for unit tests is "necessary waste":
For perfect coders it is a waste of time, but as most of us are not of 
that kind, it is necessary.

Actually unit testing and mocking is not that is not too difficult 
conceptually. Someone who got a graphical 1830 moderator working as you 
did, should have no problem to understand them.

Unit testing itself mirrors the tests which are possible in an 
interpreted language:
A) Write a function add(x,y) = x+y
B) Call the function with foo(10, 15) in the console
C) Check manually that the result is 25 and that no error was raised

A unit test is:
A) Write a function add(x,y) = x+y
B) Write a test addTest(): assert(add(x,y),25)
C) Start the test runner which reports passed if add(x,y) == 25 or fails 
if add(x,y) != 25 or returns an error.

If you reverse A and B, thus you write the test before the actual code 
it is called TestDrivenDevelopment (TDD)

* Mocks
Usually you want to test classes as independent entities. And you want 
to configure setup the class to test alone.

However often a method call requires or the construction of a class 
requires other objects.

A mock library allows you to create a "phantom" object that pretends
to be a object of the class, however actually does nothing at all.

Example:
If you create a Player mock using
Player p = mock(Player.class)
the variable p now can be passed as a player object and all methods of a 
player class can be called on p and everything compiles correctly.
But in fact nothing happens if one calls methods on p.

Or more precise nearly nothing happens:
It is possible to ask the mock later if the methods got called.

Assume that you test a function that adds a train to a player. It has 
two tasks:
A) Add the train to the player
B) Change the owner of the train to the player

Now you can either create fully initialized player and train objects.

However it might be easier to mock both player and train using
Player p = mock(Player.class) and Train t = mock(Train.class)

The function is called transferTrain(Player p, Train t).

You pass both mocks to the function and then check that the function
has called the according methods of player and train:

verify(player).addTrain(t)
verify(train).setOwner(p)

Here it is easy to see why a test with fully initialized objects might 
be a little stronger:
Then you would check that the train and player really have changed e.g. 
by assert(train.getOwner(),p), however this is would be already a joint 
test of both the function under test and the train object.

There is a related technique called stubbing: In that case you not only 
create a phantom object, but more a skeleton object. A stub for a Player 
would be a minimal but working implementation.

Mockito supports simple/basic stubbing as well: Assume that function 
would only succeed if the addTrain method of player returns a True 
value. This is possible by instructing the mock object to return that
on a call of addTrain by:
when(p.addTrain(t)).thenReturn(True)

Feel free to ask more questions if you like.

Stefan



On 06/06/2012 11:04 PM, brett lentz wrote:
> Typically, the test code and the application code are separate entities.
>
> Ideally, all tests and mocked objects should be off to the side in a
> 'test/' directory. This way, they are in the same repository, but can
> be removed from the released JARs and not cause unnecessary bloat.
>
> ---Brett.
>
>
> On Wed, Jun 6, 2012 at 4:27 PM, Erik Vos<eri...@xs...>  wrote:
>> This all is way beyond my understanding, but if the two of you say that it's useful, I'm fine.
>> Just wondering with what factor this will multiply the size of the Rails code.
>>
>> Erik.
>>
>>> -----Original Message-----
>>> From: brett lentz [mailto:bre...@gm...]
>>> Sent: Wednesday, June 06, 2012 7:07 PM
>>> To: Development list for Rails: an 18xx game
>>> Subject: Re: [Rails-devel] Mocking library chosen
>>>
>>> I have no objections to Mockito.
>>>
>>> One thing I'd like to see is just a central mocked data set that we can use for
>>> exercising the code. Eventually, it would be nice to grow our test case
>>> coverage.
>>>
>>> ---Brett.
>>>
>>>
>>> On Wed, Jun 6, 2012 at 12:33 PM, Stefan Frey<ste...@we...>  wrote:
>>>> Erik&  Brett:
>>>> recently I have mailed that I would like to add a mock library to
>>>> support testing. At that time I preferred JMock (mostly above EasyMock).
>>>> However I did reevaluate my choice again and realized that the library
>>>> that suited my tastes best is Mockito.
>>>> see http://code.google.com/p/mockito/
>>>>
>>>> Checkout the documentation at
>>>> http://docs.mockito.googlecode.com/hg/latest/org/mockito/Mockito.html
>>>> which really shows very well the very simple but powerful style used.
>>>>
>>>> Or compare to the first test example which I have pushed to the
>>>> rails2.0 branch (ActionChangeTest.java) in the junit folder with the
>>>> identical hierachy as rails below (the source code itself is under src folder).
>>>>
>>>> It is really easy to create mock objects by simply annotate private
>>>> fields in the test classes with @Mock or directly with Player player =
>>>> mock(Player.class)
>>>>
>>>> Verifying that a method of the mock is called (once) requires:
>>>> verify(mock).method()
>>>>
>>>> And stubbing a method of the mock is initialized with:
>>>> when(mock.method()).thenReturn(value)
>>>>
>>>> Avoiding using strings also ensures that autocompletion of Eclipse-IDe
>>>> still works.
>>>>
>>>> This syntactical sugar simplifies unit tests substantially (at least
>>>> in my opinion).
>>>>
>>>> Stefan
>>>>
>>>> ----------------------------------------------------------------------
>>>> --------
>>>> Live Security Virtual Conference
>>>> Exclusive live event will cover all the ways today's security and
>>>> threat landscape has changed and how IT managers can respond.
>>>> Discussions will include endpoint security, mobile security and the
>>>> latest in malware threats.
>>>> http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
>>>> _______________________________________________
>>>> Rails-devel mailing list
>>>> Rai...@li...
>>>> https://lists.sourceforge.net/lists/listinfo/rails-devel
>>>
>>> ------------------------------------------------------------------------------
>>> Live Security Virtual Conference
>>> Exclusive live event will cover all the ways today's security and threat
>>> landscape has changed and how IT managers can respond. Discussions will
>>> include endpoint security, mobile security and the latest in malware threats.
>>> http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
>>> _______________________________________________
>>> Rails-devel mailing list
>>> Rai...@li...
>>> https://lists.sourceforge.net/lists/listinfo/rails-devel
>>
>>
>> ------------------------------------------------------------------------------
>> Live Security Virtual Conference
>> Exclusive live event will cover all the ways today's security and
>> threat landscape has changed and how IT managers can respond. Discussions
>> will include endpoint security, mobile security and the latest in malware
>> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
>> _______________________________________________
>> Rails-devel mailing list
>> Rai...@li...
>> https://lists.sourceforge.net/lists/listinfo/rails-devel
>
> ------------------------------------------------------------------------------
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and
> threat landscape has changed and how IT managers can respond. Discussions
> will include endpoint security, mobile security and the latest in malware
> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Rails-devel mailing list
> Rai...@li...
> https://lists.sourceforge.net/lists/listinfo/rails-devel

Re: [Rails-devel] Mocking library chosen

[brett l. <bre...@gm...>]

Typically, the test code and the application code are separate entities.

Ideally, all tests and mocked objects should be off to the side in a
'test/' directory. This way, they are in the same repository, but can
be removed from the released JARs and not cause unnecessary bloat.

---Brett.


On Wed, Jun 6, 2012 at 4:27 PM, Erik Vos <eri...@xs...> wrote:
> This all is way beyond my understanding, but if the two of you say that it's useful, I'm fine.
> Just wondering with what factor this will multiply the size of the Rails code.
>
> Erik.
>
>> -----Original Message-----
>> From: brett lentz [mailto:bre...@gm...]
>> Sent: Wednesday, June 06, 2012 7:07 PM
>> To: Development list for Rails: an 18xx game
>> Subject: Re: [Rails-devel] Mocking library chosen
>>
>> I have no objections to Mockito.
>>
>> One thing I'd like to see is just a central mocked data set that we can use for
>> exercising the code. Eventually, it would be nice to grow our test case
>> coverage.
>>
>> ---Brett.
>>
>>
>> On Wed, Jun 6, 2012 at 12:33 PM, Stefan Frey <ste...@we...> wrote:
>> > Erik & Brett:
>> > recently I have mailed that I would like to add a mock library to
>> > support testing. At that time I preferred JMock (mostly above EasyMock).
>> > However I did reevaluate my choice again and realized that the library
>> > that suited my tastes best is Mockito.
>> > see http://code.google.com/p/mockito/
>> >
>> > Checkout the documentation at
>> > http://docs.mockito.googlecode.com/hg/latest/org/mockito/Mockito.html
>> > which really shows very well the very simple but powerful style used.
>> >
>> > Or compare to the first test example which I have pushed to the
>> > rails2.0 branch (ActionChangeTest.java) in the junit folder with the
>> > identical hierachy as rails below (the source code itself is under src folder).
>> >
>> > It is really easy to create mock objects by simply annotate private
>> > fields in the test classes with @Mock or directly with Player player =
>> > mock(Player.class)
>> >
>> > Verifying that a method of the mock is called (once) requires:
>> > verify(mock).method()
>> >
>> > And stubbing a method of the mock is initialized with:
>> > when(mock.method()).thenReturn(value)
>> >
>> > Avoiding using strings also ensures that autocompletion of Eclipse-IDe
>> > still works.
>> >
>> > This syntactical sugar simplifies unit tests substantially (at least
>> > in my opinion).
>> >
>> > Stefan
>> >
>> > ----------------------------------------------------------------------
>> > --------
>> > Live Security Virtual Conference
>> > Exclusive live event will cover all the ways today's security and
>> > threat landscape has changed and how IT managers can respond.
>> > Discussions will include endpoint security, mobile security and the
>> > latest in malware threats.
>> > http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
>> > _______________________________________________
>> > Rails-devel mailing list
>> > Rai...@li...
>> > https://lists.sourceforge.net/lists/listinfo/rails-devel
>>
>> ------------------------------------------------------------------------------
>> Live Security Virtual Conference
>> Exclusive live event will cover all the ways today's security and threat
>> landscape has changed and how IT managers can respond. Discussions will
>> include endpoint security, mobile security and the latest in malware threats.
>> http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
>> _______________________________________________
>> Rails-devel mailing list
>> Rai...@li...
>> https://lists.sourceforge.net/lists/listinfo/rails-devel
>
>
> ------------------------------------------------------------------------------
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and
> threat landscape has changed and how IT managers can respond. Discussions
> will include endpoint security, mobile security and the latest in malware
> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Rails-devel mailing list
> Rai...@li...
> https://lists.sourceforge.net/lists/listinfo/rails-devel

Re: [Rails-devel] Another library to add?

[Erik V. <eri...@xs...>]

What problems would this solve?

For initialization: it would be nice if XML data and objects were anywhere
near have a to 1:1 relationship, but in many cases that is far from being
the case. 
So I suppose this would cause much rework.

For communication: I would tend to consider XML too verbose for such a
purpose.  It's not for nothing that (I believe) Google has invented a more
compact format.
And for all I know XML parsing and creation is slooow, but perhaps that is
due to the old libraries we now use?
Indeed we need something, but I can't provide much insight.
I had in mind something like uuencoded Serialized objects (the Java way),
but I suppose that is way too primitive for these days. 
And of course it would be a big benefit if the transmission is readable.

Anyway, don't be put off by my (as usual) somewhat sceptical attitude.  I'm
way backwards in most of these matters.

Erik

> -----Original Message-----
> From: brett lentz [mailto:bre...@gm...]
> Sent: Wednesday, June 06, 2012 7:05 PM
> To: Development list for Rails: an 18xx game
> Subject: Re: [Rails-devel] Another library to add?
> 
> On Wed, Jun 6, 2012 at 12:55 PM, Stefan Frey <ste...@we...> wrote:
> > Brett & Erik,
> > going forward I am considering refactoring the xml initialization of
> > Rails. Further I did a short comparison of the feature and syntax of a
> > few xml serialization libraries for java and very quickly found one
> > that pleases me.
> >
> > The idea of the newer libraries add is that it is possible to align
> > the java classes and xml elements, so that in effect you do not have
> > to write anymore manually for parsing. Most of them use annotations to
> > control this mechanism.
> >
> 
> +1 from me. Annotation/Decorators are a fantastic way to handle this.
> Also, the removal of manual parsing code is a huge win, IMO.
> 
> > So my proposal is to use Simple Serialization Library (see
> > http://simple.sourceforge.net/home.php)
> >
> > Checkout
> > http://simple.sourceforge.net/download/stream/doc/tutorial/tutorial.ph
> > p
> > for documentation and code examples).
> >
> > (Reasonable Alternatives were XStream and Jackson with XML extension
> > and Protostuff, I do not like JAXB)
> >
> > I am still considering to choose a more compact format (like Json or
> > even a binary one like Kryo or Smile) for the planned network play.
> 
> Given the choice, I'd opt for JSON or YAML over binary formats.
> They're well-known, well-supported, and (most importantly) easier to
> debug.
> 
> Over the wire, we can use compression to slim down the bandwidth
> requirements of transmitting plain-text data.
> 
> >
> > Stefan
> >
> 
> ---Brett.
> 
>
----------------------------------------------------------------------------
--
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and threat
> landscape has changed and how IT managers can respond. Discussions will
> include endpoint security, mobile security and the latest in malware
threats.
> http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Rails-devel mailing list
> Rai...@li...
> https://lists.sourceforge.net/lists/listinfo/rails-devel

Re: [Rails-devel] Mocking library chosen

[Erik V. <eri...@xs...>]

This all is way beyond my understanding, but if the two of you say that it's useful, I'm fine.
Just wondering with what factor this will multiply the size of the Rails code.

Erik.

> -----Original Message-----
> From: brett lentz [mailto:bre...@gm...]
> Sent: Wednesday, June 06, 2012 7:07 PM
> To: Development list for Rails: an 18xx game
> Subject: Re: [Rails-devel] Mocking library chosen
> 
> I have no objections to Mockito.
> 
> One thing I'd like to see is just a central mocked data set that we can use for
> exercising the code. Eventually, it would be nice to grow our test case
> coverage.
> 
> ---Brett.
> 
> 
> On Wed, Jun 6, 2012 at 12:33 PM, Stefan Frey <ste...@we...> wrote:
> > Erik & Brett:
> > recently I have mailed that I would like to add a mock library to
> > support testing. At that time I preferred JMock (mostly above EasyMock).
> > However I did reevaluate my choice again and realized that the library
> > that suited my tastes best is Mockito.
> > see http://code.google.com/p/mockito/
> >
> > Checkout the documentation at
> > http://docs.mockito.googlecode.com/hg/latest/org/mockito/Mockito.html
> > which really shows very well the very simple but powerful style used.
> >
> > Or compare to the first test example which I have pushed to the
> > rails2.0 branch (ActionChangeTest.java) in the junit folder with the
> > identical hierachy as rails below (the source code itself is under src folder).
> >
> > It is really easy to create mock objects by simply annotate private
> > fields in the test classes with @Mock or directly with Player player =
> > mock(Player.class)
> >
> > Verifying that a method of the mock is called (once) requires:
> > verify(mock).method()
> >
> > And stubbing a method of the mock is initialized with:
> > when(mock.method()).thenReturn(value)
> >
> > Avoiding using strings also ensures that autocompletion of Eclipse-IDe
> > still works.
> >
> > This syntactical sugar simplifies unit tests substantially (at least
> > in my opinion).
> >
> > Stefan
> >
> > ----------------------------------------------------------------------
> > --------
> > Live Security Virtual Conference
> > Exclusive live event will cover all the ways today's security and
> > threat landscape has changed and how IT managers can respond.
> > Discussions will include endpoint security, mobile security and the
> > latest in malware threats.
> > http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> > _______________________________________________
> > Rails-devel mailing list
> > Rai...@li...
> > https://lists.sourceforge.net/lists/listinfo/rails-devel
> 
> ------------------------------------------------------------------------------
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and threat
> landscape has changed and how IT managers can respond. Discussions will
> include endpoint security, mobile security and the latest in malware threats.
> http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Rails-devel mailing list
> Rai...@li...
> https://lists.sourceforge.net/lists/listinfo/rails-devel

Re: [Rails-devel] Mocking library chosen

[brett l. <bre...@gm...>]

I have no objections to Mockito.

One thing I'd like to see is just a central mocked data set that we
can use for exercising the code. Eventually, it would be nice to grow
our test case coverage.

---Brett.


On Wed, Jun 6, 2012 at 12:33 PM, Stefan Frey <ste...@we...> wrote:
> Erik & Brett:
> recently I have mailed that I would like to add a mock library to
> support testing. At that time I preferred JMock (mostly above EasyMock).
> However I did reevaluate my choice again and realized that the library
> that suited my tastes best is Mockito.
> see http://code.google.com/p/mockito/
>
> Checkout the documentation at
> http://docs.mockito.googlecode.com/hg/latest/org/mockito/Mockito.html
> which really shows very well the very simple but powerful style used.
>
> Or compare to the first test example which I have pushed to the rails2.0
> branch (ActionChangeTest.java) in the junit folder with the identical
> hierachy as rails below (the source code itself is under src folder).
>
> It is really easy to create mock objects by simply annotate private
> fields in the test classes with @Mock
> or directly with Player player =  mock(Player.class)
>
> Verifying that a method of the mock is called (once) requires:
> verify(mock).method()
>
> And stubbing a method of the mock is initialized with:
> when(mock.method()).thenReturn(value)
>
> Avoiding using strings also ensures that autocompletion of Eclipse-IDe
> still works.
>
> This syntactical sugar simplifies unit tests substantially (at least in
> my opinion).
>
> Stefan
>
> ------------------------------------------------------------------------------
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and
> threat landscape has changed and how IT managers can respond. Discussions
> will include endpoint security, mobile security and the latest in malware
> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Rails-devel mailing list
> Rai...@li...
> https://lists.sourceforge.net/lists/listinfo/rails-devel

Re: [Rails-devel] Another library to add?

[brett l. <bre...@gm...>]

On Wed, Jun 6, 2012 at 12:55 PM, Stefan Frey <ste...@we...> wrote:
> Brett & Erik,
> going forward I am considering refactoring the xml initialization of
> Rails. Further I did a short comparison of the feature and syntax of a
> few xml serialization libraries for java and very quickly found one that
> pleases me.
>
> The idea of the newer libraries add is that it is possible to align the
> java classes and xml elements, so that in effect you do not have to
> write anymore manually for parsing. Most of them use annotations to
> control this mechanism.
>

+1 from me. Annotation/Decorators are a fantastic way to handle this.
Also, the removal of manual parsing code is a huge win, IMO.

> So my proposal is to use Simple Serialization Library
> (see http://simple.sourceforge.net/home.php)
>
> Checkout
> http://simple.sourceforge.net/download/stream/doc/tutorial/tutorial.php
> for documentation and code examples).
>
> (Reasonable Alternatives were XStream and Jackson with XML extension and
> Protostuff, I do not like JAXB)
>
> I am still considering to choose a more compact format (like Json or
> even a binary one like Kryo or Smile) for the planned network play.

Given the choice, I'd opt for JSON or YAML over binary formats.
They're well-known, well-supported, and (most importantly) easier to
debug.

Over the wire, we can use compression to slim down the bandwidth
requirements of transmitting plain-text data.

>
> Stefan
>

---Brett.

[Rails-devel] Another library to add?

[Stefan F. <ste...@we...>]

Brett & Erik,
going forward I am considering refactoring the xml initialization of 
Rails. Further I did a short comparison of the feature and syntax of a 
few xml serialization libraries for java and very quickly found one that 
pleases me.

The idea of the newer libraries add is that it is possible to align the 
java classes and xml elements, so that in effect you do not have to 
write anymore manually for parsing. Most of them use annotations to 
control this mechanism.

So my proposal is to use Simple Serialization Library
(see http://simple.sourceforge.net/home.php)

Checkout 
http://simple.sourceforge.net/download/stream/doc/tutorial/tutorial.php 
for documentation and code examples).

(Reasonable Alternatives were XStream and Jackson with XML extension and 
Protostuff, I do not like JAXB)

I am still considering to choose a more compact format (like Json or 
even a binary one like Kryo or Smile) for the planned network play.

Stefan

[Rails-devel] Mocking library chosen

[Stefan F. <ste...@we...>]

Erik & Brett:
recently I have mailed that I would like to add a mock library to 
support testing. At that time I preferred JMock (mostly above EasyMock).
However I did reevaluate my choice again and realized that the library 
that suited my tastes best is Mockito.
see http://code.google.com/p/mockito/

Checkout the documentation at
http://docs.mockito.googlecode.com/hg/latest/org/mockito/Mockito.html
which really shows very well the very simple but powerful style used.

Or compare to the first test example which I have pushed to the rails2.0 
branch (ActionChangeTest.java) in the junit folder with the identical 
hierachy as rails below (the source code itself is under src folder).

It is really easy to create mock objects by simply annotate private 
fields in the test classes with @Mock
or directly with Player player =  mock(Player.class)

Verifying that a method of the mock is called (once) requires: 
verify(mock).method()

And stubbing a method of the mock is initialized with:
when(mock.method()).thenReturn(value)

Avoiding using strings also ensures that autocompletion of Eclipse-IDe 
still works.

This syntactical sugar simplifies unit tests substantially (at least in 
my opinion).

Stefan

[Rails-devel] 18Lummer added

[Stefan F. <ste...@we...>]

Today I have added 18Lummer which is a tiny fun variant based on 1830 
which was inspired by the book "Jim Knopf" written by Michael Ende.

Author is Kay-Viktor Stegmann and the best description is on the website 
of Adam Romoth:
http://www.adam-romoth.de/18xx/index.php?was=1830
(scroll down to 18Lummerland with both english rules and the map).

Main reason was not to make it available for serious play, but to have
a test kit to create rails1.x save files for rails2.0 testing in
the near future.

I have added it to the GameList as fully playable, however sorted it to 
the end of the playable games.

Stefan

Re: [Rails-devel] Patch

[Erik V. <eri...@xs...>]

Thanks for the patch, this is indeed required for 1837.  It's now in the
'master' repository.

Your code didn't compile because the initialisation of 'index' was missing.
I have added that line, as well as a comment.

Erik.

> -----Original Message-----
> From: John David Galt [mailto:jd...@di...]
> Sent: Sunday, June 03, 2012 6:13 AM
> To: rai...@li...
> Subject: [Rails-devel] Patch
> 
> This adds code to PublicCompany.getBaseTokenLayCost() so that the
> "distance"
> factor (cost per hex distance) can be different for each token in
sequence.
> 
> rails/game/PublicCompany.java
> 1753        /**
> 1754         * Calculate the cost of laying a token, given the hex where
> 1755         * the token is laid. This only makes a difference for the
"distance"
> method.
> 1756         * @param hex The hex where the token is to be laid.
> 1757         * @return The cost of laying that token.
> 1758         */
> 1759        public int getBaseTokenLayCost(MapHex hex) {
> 1760
> 1761            if (baseTokenLayCost == null) return 0;
> 1762
>      +          if (index >= baseTokenLayCost.length) {
>      +              index = baseTokenLayCost.length - 1;
>      +          } else if (index < 0) {
>      +              index = 0;
>      +          }
> 1763            if (baseTokenLayCostMethod.equals(BASE_COST_SEQUENCE)) {
> 1764 -              int index = getNumberOfLaidBaseTokens();
> 1765 -
> 1766 -              if (index >= baseTokenLayCost.length) {
> 1767 -                  index = baseTokenLayCost.length - 1;
> 1768 -              } else if (index < 0) {
> 1769 -                  index = 0;
> 1770 -              }
> 1771                return baseTokenLayCost[index];
> 1772            } else if
> (baseTokenLayCostMethod.equals(BASE_COST_DISTANCE)) {
> 1773                if (hex == null) {
> 1774 -                  return baseTokenLayCost[0];
>      +                  return baseTokenLayCost[index];
> 1775                } else {
> 1776                    // WARNING: no provision yet for multiple home
hexes.
> 1777 -                  return mapManager.getHexDistance(homeHexes.get(0),
hex)
> * baseTokenLayCost[0];
>      +                  return mapManager.getHexDistance(homeHexes.get(0),
hex) *
> baseTokenLayCost[index];
> 1778                }
> 1779            } else {
> 1780                return 0;
> 1781            }
> 1782        }
> 
>
----------------------------------------------------------------------------
--
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and threat
> landscape has changed and how IT managers can respond. Discussions will
> include endpoint security, mobile security and the latest in malware
threats.
> http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Rails-devel mailing list
> Rai...@li...
> https://lists.sourceforge.net/lists/listinfo/rails-devel

[Rails-devel] Release Rails 1.7.6 available

[Stefan F. <ste...@we...>]

A new maintenance release for Rails 1.x series

Downloads are available at http://rails.sourceforge.net/ or by the
direct link http://sourceforge.net/projects/rails/files/Rails/1.7.6/

Contributors: Erik Vos

Bug reported by Antonio Baracca

1856: Allowing selling a share just bought by the president.
(According to Steve Thomas rule clarification).

Re: [Rails-devel] 1856 revenue bug (1.7.5)

[Stefan F. <ste...@we...>]

I stand corrected: This is mainly an undo/redo related bug. On my 
computer if replaying from scratch on first try everything looks ok, but 
various undo/redo actions can create all kind of weird effects.
(Even adding multiple bonuses etc.)

As the combination of the 1856 bonuses, the undo/redo effects and 
revenue triggering is a pretty bad combination to resolve, I will not
fix that in the Rails1.x branch. The movement of bonuses in Rails2.0 is 
part of the refactoring and thus will change anyway.

So I have to ask for patience with this bug that has two easy 
work-arounds: Either manual calculation or reloading.

Stefan


On 06/04/2012 09:35 AM, Stefan Frey wrote:
> On reload first everything going backwards everything looks ok, but then
> going forward again there seems to be an update issue after the Purchase
> of the Private (this includes displaying the bonus in the company table
> as well).
>
> So this should be easy to resolve, however should best be done after
> checking that the previous calculation thread is stopped correctly if a
> new one is triggered.
> Stefan
>
>
>
> On 06/02/2012 12:21 AM, John David Galt wrote:
>> In this saved game, LPS bought in the tunnel private just before declaring its
>> dividend.  However, the calculated revenue did not increase to 120 because LPS
>> now has tunnel rights.  I had to make that change manually.
>>
>>
>>
>> ------------------------------------------------------------------------------
>> Live Security Virtual Conference
>> Exclusive live event will cover all the ways today's security and
>> threat landscape has changed and how IT managers can respond. Discussions
>> will include endpoint security, mobile security and the latest in malware
>> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
>>
>>
>>
>> _______________________________________________
>> Rails-devel mailing list
>> Rai...@li...
>> https://lists.sourceforge.net/lists/listinfo/rails-devel
>
>
> ------------------------------------------------------------------------------
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and
> threat landscape has changed and how IT managers can respond. Discussions
> will include endpoint security, mobile security and the latest in malware
> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Rails-devel mailing list
> Rai...@li...
> https://lists.sourceforge.net/lists/listinfo/rails-devel

Re: [Rails-devel] Fwd: 18xx Bug report

[Erik V. <eri...@xs...>]

Fixed and pushed to master.

I presume it does not matter in a case like this, that the presidency cannot
actually be dumped, because no one else owns 20%.
The change effectively means, that a company president may now sell a just
bought certificate, unless the number of held shares would become zero.
All other limitations of course still apply.

In the reported case, Fontana can now sell up to 30% instead of 20%.

Erik.

> -----Original Message-----
> From: Stefan Frey [mailto:ste...@we...]
> Sent: Monday, June 04, 2012 9:33 AM
> To: Development list for Rails: an 18xx game
> Subject: Re: [Rails-devel] Fwd: 18xx Bug report
> 
> Erik:
> sounds reasonable, however I am not an 1856 expert.
> The good thing is that it enlarges action space only, so the other
> interpretation could be enforced by players.
> 
> If you want to check for more (and more qualified) opinions, you should
> forward the issue to the 18xx yahoo group.
> 
> Stefan
> 
> PS: Maybe we could collect resolved rules issues on the wiki and maybe
even
> state what rules and clarifications we use as the basis of our
implementation
> (I know we do not link to rules, but stating a bibliography and link to
public
> available rules clarification should be possible - Maybe someone of non-
> developer contributors would like to volunteer... :-) ?
> 
> On 06/03/2012 09:13 PM, Erik Vos wrote:
> > How Rails does work is as follows:
> > - if a share has been bought in the same turn, the maximum number of
> > shares that can be sold is unconditionally reduced by one.
> >
> > How Rails should work is open for discussion here, but given Steve
Thomas'
> > clarification I think the above should be reformulated as follows:
> > - if a share has been bought in the same turn, at least one share
> > should remain after selling.  So the number of sellable shares is only
> > reduced by one if the number of remaining shares would otherwise
> become zero.
> >
> > If we agree that this interpretation is correct, I'll change the code
> > accordingly.
> >
> > Erik.
> >
> >> -----Original Message-----
> >> From: Stefan Frey [mailto:ste...@we...]
> >> Sent: Sunday, June 03, 2012 5:47 PM
> >> To: Development list for Rails: an 18xx game; Ing. Antonio Baracca
> >> Subject: [Rails-devel] Fwd: 18xx Bug report
> >>
> >> A bug reported on 1856:
> >> Selling a 10% share which was immediately bought in that turn.
> >>
> >> However the player has the presidency, thus he should able to sell
> >> off the partial 10% from the presidency instead (if I understand
> >> Steve Thomas rule clarification correctly).
> >>
> >> If I remember we had this case previously discussed, however was not
> >> able to find it quickly.
> >>
> >> Previous Off-list conversion see below.
> >>
> >> Most likely Erik knows best how the current implementation should work.
> >>
> >> Stefan
> >>
> >>
> >> On 06/03/2012 05:28 PM, Ing. Antonio Baracca wrote:
> >>   >  No, Rails doesn't handle it in the right way.
> >>   >  Fontana had 4 GW
> >>   >  He bought the fifth share
> >>   >  And wish to sell 3 GW
> >>   >
> >>   >  All these moves are correct but rails just let him sell 2
> >> shares, in my
> >>
> >> opinion it does confusion with the president share.
> >>   >  Bye
> >>   >  Antonio
> >>   >
> >>   >
> >>   >  Il giorno 03/giu/2012, alle ore 16:50, Stefan Frey ha scritto:
> >>   >
> >>   >>  Antonio:
> >>   >>  just to be sure:
> >>   >>  Do we agree that Rails handled that case correctly?
> >>   >>
> >>   >>  In the example save file you have sent, Fontana just bought the
> >> 3rd
> >>>
> >> share of GW, so he is not able to sell 3 shares immediately.
> >>   >>  He has to wait for one turn and then he is able to do so (and
> >> Rails
> >>>
> >> allows it then).
> >>   >>
> >>   >>  Cheers,
> >>   >>  Stefan
> >>   >>
> >>   >>
> >>   >>  On 06/03/2012 04:06 PM, Ing. Antonio Baracca wrote:
> >>   >>>  Hello Stefan, thanks for your fast replay,>>>  it's true that
> >> in
> > 1856 you
> >> cannot sell a share you just bought, but if>>>  you hold some shares
> >> of a corporation and you buy another one, it's>>>  allowed to sell
> >> one or more shares of the ones you had before.
> >>   >>>
> >>   >>>  For example:
> >>   >>>  if you had 2 shares and you buy one more, in any case you can
> >> sell
> > only
> >>>>> the two shares you owned in the same move, you can sell the third
> >>>>> one when it's your turn again in the same stock round.
> >>   >>>  Greetings
> >>   >>>  Antonio
> >>   >>>
> >>   >>>
> >>   >>>
> >>   >>>  Il giorno 03/giu/2012, alle ore 10:54, Stefan Frey ha scritto:
> >>   >>>
> >>   >>>>  Hello Antonio,
> >>   >>>>  I am not the 1856 expert, however on first glance it looks
> >> like that
> > the
> >>>>>> rule that you cannot sell a share in the same StockRound turn
> >>>>>> that
> > you
> >>>>>> just bought?
> >>   >>>>
> >>   >>>>  But most likely I have overlooked something, because I only
> >> played
> >>>>>> 1856 only once.
> >>   >>>>
> >>   >>>>  Good to hear that the Italian community embraces Rails now as
> >> well
> >>>>>> Enjoy your PBEM competition!
> >>   >>>>  Kind regards,
> >>   >>>>  Stefan
> >>   >>>>
> >>   >>>>
> >>   >>>>>
> >>   >>>>>
> >>   >>>>>
> >>   >>>>>
> >>   >>>>>
> >>   >>>>>
> >>   >>>>>  Ing. Antonio Baracca
> >>   >>>>>  ant...@gm...<mailto:ant...@gm...>
> >>>>>
> >> <mailto:ant...@gm...>   >>>>>   >>>>>   >>>>>   >>>>   >>>
> >>>
> >>>>> Ing. Antonio Baracca>>>  ant...@gm...
> >> <mailto:ant...@gm...>   >>>
> <mailto:ant...@gm...>
> >
> >
> >
> > ----------------------------------------------------------------------
> > --------
> > Live Security Virtual Conference
> > Exclusive live event will cover all the ways today's security and
> > threat landscape has changed and how IT managers can respond.
> > Discussions will include endpoint security, mobile security and the
> > latest in malware threats.
> > http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> > _______________________________________________
> > Rails-devel mailing list
> > Rai...@li...
> > https://lists.sourceforge.net/lists/listinfo/rails-devel
> 
> 
>
----------------------------------------------------------------------------
--
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and threat
> landscape has changed and how IT managers can respond. Discussions will
> include endpoint security, mobile security and the latest in malware
threats.
> http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Rails-devel mailing list
> Rai...@li...
> https://lists.sourceforge.net/lists/listinfo/rails-devel

Re: [Rails-devel] 1856 revenue bug (1.7.5)

[Stefan F. <ste...@we...>]

On reload first everything going backwards everything looks ok, but then 
going forward again there seems to be an update issue after the Purchase 
of the Private (this includes displaying the bonus in the company table 
as well).

So this should be easy to resolve, however should best be done after 
checking that the previous calculation thread is stopped correctly if a 
new one is triggered.
Stefan



On 06/02/2012 12:21 AM, John David Galt wrote:
> In this saved game, LPS bought in the tunnel private just before declaring its
> dividend.  However, the calculated revenue did not increase to 120 because LPS
> now has tunnel rights.  I had to make that change manually.
>
>
>
> ------------------------------------------------------------------------------
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and
> threat landscape has changed and how IT managers can respond. Discussions
> will include endpoint security, mobile security and the latest in malware
> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
>
>
>
> _______________________________________________
> Rails-devel mailing list
> Rai...@li...
> https://lists.sourceforge.net/lists/listinfo/rails-devel

Re: [Rails-devel] Fwd: 18xx Bug report

[Stefan F. <ste...@we...>]

Erik:
sounds reasonable, however I am not an 1856 expert.
The good thing is that it enlarges action space only, so the other 
interpretation could be enforced by players.

If you want to check for more (and more qualified) opinions, you should 
forward the issue to the 18xx yahoo group.

Stefan

PS: Maybe we could collect resolved rules issues on the wiki and maybe 
even state what rules and clarifications we use as the basis of our 
implementation (I know we do not link to rules, but stating a 
bibliography and link to public available rules clarification should be 
possible - Maybe someone of non-developer contributors would like to 
volunteer... :-) ?

On 06/03/2012 09:13 PM, Erik Vos wrote:
> How Rails does work is as follows:
> - if a share has been bought in the same turn, the maximum number of shares
> that can be sold is unconditionally reduced by one.
>
> How Rails should work is open for discussion here, but given Steve Thomas'
> clarification I think the above should be reformulated as follows:
> - if a share has been bought in the same turn, at least one share should
> remain after selling.  So the number of sellable shares is only reduced by
> one if the number of remaining shares would otherwise become zero.
>
> If we agree that this interpretation is correct, I'll change the code
> accordingly.
>
> Erik.
>
>> -----Original Message-----
>> From: Stefan Frey [mailto:ste...@we...]
>> Sent: Sunday, June 03, 2012 5:47 PM
>> To: Development list for Rails: an 18xx game; Ing. Antonio Baracca
>> Subject: [Rails-devel] Fwd: 18xx Bug report
>>
>> A bug reported on 1856:
>> Selling a 10% share which was immediately bought in that turn.
>>
>> However the player has the presidency, thus he should able to sell off the
>> partial 10% from the presidency instead (if I understand Steve Thomas rule
>> clarification correctly).
>>
>> If I remember we had this case previously discussed, however was not able
>> to find it quickly.
>>
>> Previous Off-list conversion see below.
>>
>> Most likely Erik knows best how the current implementation should work.
>>
>> Stefan
>>
>>
>> On 06/03/2012 05:28 PM, Ing. Antonio Baracca wrote:
>>   >  No, Rails doesn't handle it in the right way.
>>   >  Fontana had 4 GW
>>   >  He bought the fifth share
>>   >  And wish to sell 3 GW
>>   >
>>   >  All these moves are correct but rails just let him sell 2 shares, in my
>>
>> opinion it does confusion with the president share.
>>   >  Bye
>>   >  Antonio
>>   >
>>   >
>>   >  Il giorno 03/giu/2012, alle ore 16:50, Stefan Frey ha scritto:
>>   >
>>   >>  Antonio:
>>   >>  just to be sure:
>>   >>  Do we agree that Rails handled that case correctly?
>>   >>
>>   >>  In the example save file you have sent, Fontana just bought the 3rd
>>>
>> share of GW, so he is not able to sell 3 shares immediately.
>>   >>  He has to wait for one turn and then he is able to do so (and Rails
>>>
>> allows it then).
>>   >>
>>   >>  Cheers,
>>   >>  Stefan
>>   >>
>>   >>
>>   >>  On 06/03/2012 04:06 PM, Ing. Antonio Baracca wrote:
>>   >>>  Hello Stefan, thanks for your fast replay,>>>  it's true that in
> 1856 you
>> cannot sell a share you just bought, but if>>>  you hold some shares of a
>> corporation and you buy another one, it's>>>  allowed to sell one or more
>> shares of the ones you had before.
>>   >>>
>>   >>>  For example:
>>   >>>  if you had 2 shares and you buy one more, in any case you can sell
> only
>>>>> the two shares you owned in the same move, you can sell the third one
>>>>> when it's your turn again in the same stock round.
>>   >>>  Greetings
>>   >>>  Antonio
>>   >>>
>>   >>>
>>   >>>
>>   >>>  Il giorno 03/giu/2012, alle ore 10:54, Stefan Frey ha scritto:
>>   >>>
>>   >>>>  Hello Antonio,
>>   >>>>  I am not the 1856 expert, however on first glance it looks like that
> the
>>>>>> rule that you cannot sell a share in the same StockRound turn that
> you
>>>>>> just bought?
>>   >>>>
>>   >>>>  But most likely I have overlooked something, because I only played
>>>>>> 1856 only once.
>>   >>>>
>>   >>>>  Good to hear that the Italian community embraces Rails now as well
>>>>>> Enjoy your PBEM competition!
>>   >>>>  Kind regards,
>>   >>>>  Stefan
>>   >>>>
>>   >>>>
>>   >>>>>
>>   >>>>>
>>   >>>>>
>>   >>>>>
>>   >>>>>
>>   >>>>>
>>   >>>>>  Ing. Antonio Baracca
>>   >>>>>  ant...@gm...<mailto:ant...@gm...>   >>>>>
>> <mailto:ant...@gm...>   >>>>>   >>>>>   >>>>>   >>>>   >>>   >>>
>>>>> Ing. Antonio Baracca>>>  ant...@gm...
>> <mailto:ant...@gm...>   >>>  <mailto:ant...@gm...>
>
>
>
> ------------------------------------------------------------------------------
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and
> threat landscape has changed and how IT managers can respond. Discussions
> will include endpoint security, mobile security and the latest in malware
> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Rails-devel mailing list
> Rai...@li...
> https://lists.sourceforge.net/lists/listinfo/rails-devel

Re: [Rails-devel] Fwd: 18xx Bug report

[Erik V. <eri...@xs...>]

How Rails does work is as follows:
- if a share has been bought in the same turn, the maximum number of shares
that can be sold is unconditionally reduced by one.

How Rails should work is open for discussion here, but given Steve Thomas'
clarification I think the above should be reformulated as follows:
- if a share has been bought in the same turn, at least one share should
remain after selling.  So the number of sellable shares is only reduced by
one if the number of remaining shares would otherwise become zero.

If we agree that this interpretation is correct, I'll change the code
accordingly.

Erik.

> -----Original Message-----
> From: Stefan Frey [mailto:ste...@we...]
> Sent: Sunday, June 03, 2012 5:47 PM
> To: Development list for Rails: an 18xx game; Ing. Antonio Baracca
> Subject: [Rails-devel] Fwd: 18xx Bug report
> 
> A bug reported on 1856:
> Selling a 10% share which was immediately bought in that turn.
> 
> However the player has the presidency, thus he should able to sell off the
> partial 10% from the presidency instead (if I understand Steve Thomas rule
> clarification correctly).
> 
> If I remember we had this case previously discussed, however was not able
> to find it quickly.
> 
> Previous Off-list conversion see below.
> 
> Most likely Erik knows best how the current implementation should work.
> 
> Stefan
> 
> 
> On 06/03/2012 05:28 PM, Ing. Antonio Baracca wrote:
>  > No, Rails doesn't handle it in the right way.
>  > Fontana had 4 GW
>  > He bought the fifth share
>  > And wish to sell 3 GW
>  >
>  > All these moves are correct but rails just let him sell 2 shares, in my
>
> opinion it does confusion with the president share.
>  > Bye
>  > Antonio
>  >
>  >
>  > Il giorno 03/giu/2012, alle ore 16:50, Stefan Frey ha scritto:
>  >
>  >> Antonio:
>  >> just to be sure:
>  >> Do we agree that Rails handled that case correctly?
>  >>
>  >> In the example save file you have sent, Fontana just bought the 3rd
>>
> share of GW, so he is not able to sell 3 shares immediately.
>  >> He has to wait for one turn and then he is able to do so (and Rails
>>
> allows it then).
>  >>
>  >> Cheers,
>  >> Stefan
>  >>
>  >>
>  >> On 06/03/2012 04:06 PM, Ing. Antonio Baracca wrote:
>  >>> Hello Stefan, thanks for your fast replay,  >>> it's true that in
1856 you
> cannot sell a share you just bought, but if  >>> you hold some shares of a
> corporation and you buy another one, it's  >>> allowed to sell one or more
> shares of the ones you had before.
>  >>>
>  >>> For example:
>  >>> if you had 2 shares and you buy one more, in any case you can sell
only
> >>> the two shares you owned in the same move, you can sell the third one
> >>> when it's your turn again in the same stock round.
>  >>> Greetings
>  >>> Antonio
>  >>>
>  >>>
>  >>>
>  >>> Il giorno 03/giu/2012, alle ore 10:54, Stefan Frey ha scritto:
>  >>>
>  >>>> Hello Antonio,
>  >>>> I am not the 1856 expert, however on first glance it looks like that
the
> >>>> rule that you cannot sell a share in the same StockRound turn that
you
> >>>> just bought?
>  >>>>
>  >>>> But most likely I have overlooked something, because I only played
> >>>> 1856 only once.
>  >>>>
>  >>>> Good to hear that the Italian community embraces Rails now as well
> >>>> Enjoy your PBEM competition!
>  >>>> Kind regards,
>  >>>> Stefan
>  >>>>
>  >>>>
>  >>>>>
>  >>>>>
>  >>>>>
>  >>>>>
>  >>>>>
>  >>>>>
>  >>>>> Ing. Antonio Baracca
>  >>>>> ant...@gm... <mailto:ant...@gm...>  >>>>>
> <mailto:ant...@gm...>  >>>>>  >>>>>  >>>>>  >>>>  >>>  >>>
> >>> Ing. Antonio Baracca  >>> ant...@gm...
> <mailto:ant...@gm...>  >>> <mailto:ant...@gm...>

[Rails-devel] Fwd: 18xx Bug report

[Stefan F. <ste...@we...>]

A bug reported on 1856:
Selling a 10% share which was immediately bought in that turn.

However the player has the presidency, thus he should able to sell off 
the partial 10% from the presidency instead (if I understand Steve 
Thomas rule clarification correctly).

If I remember we had this case previously discussed, however was not 
able to find it quickly.

Previous Off-list conversion see below.

Most likely Erik knows best how the current implementation should work.

Stefan


On 06/03/2012 05:28 PM, Ing. Antonio Baracca wrote:
 > No, Rails doesn't handle it in the right way.
 > Fontana had 4 GW
 > He bought the fifth share
 > And wish to sell 3 GW
 >
 > All these moves are correct but rails just let him sell 2 shares, in my
 > opinion it does confusion with the president share.
 > Bye
 > Antonio
 >
 >
 > Il giorno 03/giu/2012, alle ore 16:50, Stefan Frey ha scritto:
 >
 >> Antonio:
 >> just to be sure:
 >> Do we agree that Rails handled that case correctly?
 >>
 >> In the example save file you have sent, Fontana just bought the 3rd
 >> share of GW, so he is not able to sell 3 shares immediately.
 >> He has to wait for one turn and then he is able to do so (and Rails
 >> allows it then).
 >>
 >> Cheers,
 >> Stefan
 >>
 >>
 >> On 06/03/2012 04:06 PM, Ing. Antonio Baracca wrote:
 >>> Hello Stefan, thanks for your fast replay,
 >>> it's true that in 1856 you cannot sell a share you just bought, but if
 >>> you hold some shares of a corporation and you buy another one, it's
 >>> allowed to sell one or more shares of the ones you had before.
 >>>
 >>> For example:
 >>> if you had 2 shares and you buy one more, in any case you can sell only
 >>> the two shares you owned in the same move, you can sell the third one
 >>> when it's your turn again in the same stock round.
 >>> Greetings
 >>> Antonio
 >>>
 >>>
 >>>
 >>> Il giorno 03/giu/2012, alle ore 10:54, Stefan Frey ha scritto:
 >>>
 >>>> Hello Antonio,
 >>>> I am not the 1856 expert, however on first glance it looks like 
that the
 >>>> rule that you cannot sell a share in the same StockRound turn that you
 >>>> just bought?
 >>>>
 >>>> But most likely I have overlooked something, because I only played
 >>>> 1856 only once.
 >>>>
 >>>> Good to hear that the Italian community embraces Rails now as well
 >>>> Enjoy your PBEM competition!
 >>>> Kind regards,
 >>>> Stefan
 >>>>
 >>>>
 >>>>>
 >>>>>
 >>>>>
 >>>>>
 >>>>>
 >>>>>
 >>>>> Ing. Antonio Baracca
 >>>>> ant...@gm... <mailto:ant...@gm...>
 >>>>> <mailto:ant...@gm...>
 >>>>>
 >>>>>
 >>>>>
 >>>>
 >>>
 >>>
 >>> Ing. Antonio Baracca
 >>> ant...@gm... <mailto:ant...@gm...>
 >>> <mailto:ant...@gm...>