From da43d7f00f0cbc675468a1aa5e7c6bacad5a49ca Mon Sep 17 00:00:00 2001
From: Ichthyostega <prg@ichthyostega.de>
Date: Sun, 23 Aug 2015 02:00:33 +0200
Subject: [PATCH] follow-up to the bugfix: just plain int is yet more readable

basically the 32/64bit problem was caused by things like 23L, which creates a long.
Unfortunately on 64bit platforms, this is aliased to int64_t,
while on 32bit i386, it is a distinct data type, but just 32bit,
like int.

The code in question here is just test / demonstration code
and actually just needs "some integer number". So let's stick
to good old boring int then.
---
 tests/15library.tests          |  2 +-
 tests/library/variant-test.cpp | 34 +++++++++++++++++-----------------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/tests/15library.tests b/tests/15library.tests
index 5c8bc91e6..77b887245 100644
--- a/tests/15library.tests
+++ b/tests/15library.tests
@@ -598,7 +598,7 @@ END
 
 TEST "typesafe Variant record" Variant_test <<END
 out: Variant.«bool».0
-out: Variant.«(long|int64_t)».11
+out: Variant.«int».11
 out: Variant.«std::string».lololo
 out: Variant.«lib::time::Time».0:00:00.000
 return: 0
diff --git a/tests/library/variant-test.cpp b/tests/library/variant-test.cpp
index 3546c6297..f6d91d2a2 100644
--- a/tests/library/variant-test.cpp
+++ b/tests/library/variant-test.cpp
@@ -53,7 +53,7 @@ namespace test{
   
   
   // Test fixture...
-  typedef Variant<Types<bool,int64_t,string,Time>> TestVariant;
+  typedef Variant<Types<bool,int,string,Time>> TestVariant;
   
   
   
@@ -88,7 +88,7 @@ namespace test{
         {
           Time someTime;
           TestVariant v0;
-          TestVariant v1(int64_t(11));
+          TestVariant v1(11);
           TestVariant v2(string("lololo"));
           TestVariant v3(someTime);
           
@@ -105,7 +105,7 @@ namespace test{
           CHECK (contains (string(v0), "0"));
           
           CHECK (contains (string(v1), "Variant"));
-          CHECK (contains (string(v1), "int64_t") || contains (string(v1), "long") );
+          CHECK (contains (string(v1), "int"));
           CHECK (contains (string(v1), "11"));
           
           CHECK (contains (string(v2), "Variant"));
@@ -127,15 +127,15 @@ namespace test{
           
           TestVariant v3(someTime);
           TestVariant v2(someStr);
-          TestVariant v1 = int64_t(someVal);
+          TestVariant v1 = someVal;
           TestVariant v0; v0 = true;
           
           CHECK (true     == v0.get<bool>()   );
-          CHECK (someVal  == v1.get<int64_t>());
+          CHECK (someVal  == v1.get<int>());
           CHECK (someStr  == v2.get<string>() );
           CHECK (someTime == v3.get<Time>()   );
           
-          VERIFY_ERROR (WRONG_TYPE, v0.get<int64_t>());
+          VERIFY_ERROR (WRONG_TYPE, v0.get<int>()    );
           VERIFY_ERROR (WRONG_TYPE, v0.get<string>() );
           VERIFY_ERROR (WRONG_TYPE, v0.get<Time>()   );
           
@@ -144,11 +144,11 @@ namespace test{
           VERIFY_ERROR (WRONG_TYPE, v1.get<Time>()   );
           
           VERIFY_ERROR (WRONG_TYPE, v2.get<bool>()   );
-          VERIFY_ERROR (WRONG_TYPE, v2.get<int64_t>());
+          VERIFY_ERROR (WRONG_TYPE, v2.get<int>()    );
           VERIFY_ERROR (WRONG_TYPE, v2.get<Time>()   );
           
           VERIFY_ERROR (WRONG_TYPE, v3.get<bool>()   );
-          VERIFY_ERROR (WRONG_TYPE, v3.get<int64_t>());
+          VERIFY_ERROR (WRONG_TYPE, v3.get<int>()    );
           VERIFY_ERROR (WRONG_TYPE, v3.get<string>() );
           
           //// does not compile...
@@ -166,7 +166,7 @@ namespace test{
               void handle (bool& b) { b_ = b; }
               void handle (Time& t) { t_ = t; }
               
-              void handle (int64_t& i6)
+              void handle (int& i6)
                 {
                   i_ = i6;
                   ++i6;
@@ -199,9 +199,9 @@ namespace test{
           CHECK (acs.i_ == someVal);
           
           // side-effect!
-          CHECK (someVal+1 == v1.get<int64_t>());
+          CHECK (someVal+1 == v1.get<int>());
           v1.accept (acs);
-          CHECK (someVal+2 == v1.get<int64_t>());
+          CHECK (someVal+2 == v1.get<int>());
           CHECK (someVal+1 == acs.i_);
         }
       
@@ -210,18 +210,18 @@ namespace test{
       verifyAssignment()
         {
           TestVariant v1(string("boo"));
-          TestVariant v2(int64_t(23));
-          TestVariant v3(int64_t(42));
+          TestVariant v2(23);
+          TestVariant v3(42);
           
           v1 = string("booo");
           v2 = v3;
-          v3 = int64_t(24);
+          v3 = 24;
           CHECK ("booo" == v1.get<string>());
-          CHECK (42 == v2.get<int64_t>());
-          CHECK (24 == v3.get<int64_t>());
+          CHECK (42 == v2.get<int>());
+          CHECK (24 == v3.get<int>());
           
           VERIFY_ERROR (WRONG_TYPE, v1 = v2 );
-          VERIFY_ERROR (WRONG_TYPE, v1 = int64_t(22));
+          VERIFY_ERROR (WRONG_TYPE, v1 = 22);
           VERIFY_ERROR (WRONG_TYPE, v2 = string("2"));
           
           TestVariant v4  = Time();