::CORBA::LongDouble
Foo_exec_i::my_default_longdouble (void)
{
CORBA::LongDouble ld;
ACE_CDR_LONG_DOUBLE_ASSIGNMENT (ld, 0.0);
return ld;
}
CORBA::LongDouble
LongDoubleTest::get_long_double ()
{
CORBA::LongDouble ld;
ACE_CDR_LONG_DOUBLE_ASSIGNMENT (ld, Global::get_long_double ());
return ld;
}
Data::Data (CORBA::ORB_var orb)
: m_bool1 (1), m_bool2 (0),
m_octet1 (8), m_octet2 (0),
m_char1 ('z'), m_char2 (0),
m_short1 (-5), m_short2 (0),
m_long1 (-123456), m_long2 (0),
m_ushort1 (5), m_ushort2 (0),
m_ulong1 (123456), m_ulong2 (0),
m_float1 (0.142857f), m_float2 (0.0f),
m_double1 (3.14159), m_double2 (0.0),
m_ulonglong1 (654321), m_ulonglong2 (0),
m_string1 (CORBA::string_dup ("upchuck")), m_string2 (0),
m_typecode1 (CORBA::TypeCode::_duplicate (CORBA::_tc_long)),
m_typecode2 (CORBA::TypeCode::_duplicate (CORBA::_tc_null)),
m_wchar1 (666), m_wchar2 (0),
orb_ (orb)
{
ACE_CDR_LONG_DOUBLE_ASSIGNMENT (m_longdouble1, 88888888888.8888);
ACE_CDR_LONG_DOUBLE_ASSIGNMENT (m_longdouble2, 99999999999.9999);
try
{
m_shortseq1.length (3UL);
m_shortseq1[0UL] = 0;
m_shortseq1[1UL] = 1;
m_shortseq1[2UL] = 2;
labels[0] = "type boolean";
labels[1] = "type octet";
labels[2] = "type char";
labels[3] = "type short";
labels[4] = "type long",
labels[5] = "type ushort";
labels[6] = "type ulong";
labels[7] = "type float";
labels[8] = "type double";
labels[9] = "type longlong";
labels[10] = "type ulonglong";
labels[11] = "type string";
labels[12] = "type typecode";
labels[13] = "type wchar";
labels[14] = "type any";
labels[15] = "type objref";
labels[16] = "type short sequence";
labels[17] = "type longdouble";
labels[18] = "type enum";
labels[19] = "typedef'd enum in struct";
// Getting the RootPOA so we can generate object references.
CORBA::Object_var obj =
this->orb_->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (obj.in ()))
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) Unable to get root poa reference.\n"));
}
// Get the POA_var object from Object_var.
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (obj.in ());
// Generate values for the member variables.
this->m_objref1 =
root_poa->create_reference ("foo");
this->m_objref2 =
root_poa->create_reference ("foo");
// Clean up after the POA
root_poa->destroy (1,
1);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception in ORB/POA init\n");
}
}
int run_main (int, ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT ("CDR_Fixed_Test"));
typedef ACE_CDR::Fixed Fixed;
typedef ACE_CDR::LongLong LongLong;
typedef ACE_CDR::ULongLong ULongLong;
typedef ACE_CDR::LongDouble LongDouble;
const Fixed f1 = Fixed::from_integer (LongLong (-1234567890l)),
f2 = Fixed::from_integer (ULongLong (987654321ul)),
f3 = Fixed::from_string ("612578912487901265.90125789");
TEST_EQUAL (LongLong (-1234567890l), LongLong (f1));
TEST_EQUAL (LongLong (987654321), LongLong (f2));
TEST_EQUAL (LongLong (612578912487901265ull), LongLong (f3));
TEST_EQUAL (0, f1.fixed_scale ());
TEST_EQUAL (10, f1.fixed_digits ());
TEST_EQUAL (0, f2.fixed_scale ());
TEST_EQUAL (9, f2.fixed_digits ());
TEST_EQUAL (8, f3.fixed_scale ());
TEST_EQUAL (26, f3.fixed_digits ());
ACE_OSTREAM_TYPE *const os = ace_file_stream::instance ()->output_file ();
EXPECT ("-1234567890", f1);
EXPECT ("987654321", f2);
EXPECT ("612578912487901265.90125789", f3);
Fixed f1_scaled = f1 / Fixed::from_integer (LongLong (100));
const Fixed f4 = Fixed::from_string ("-12345678.9");
TEST_EQUAL (f1_scaled, f4);
EXPECT ("-12345678.9", f4);
const Fixed f5 = Fixed::from_string ("0.00000000"),
f6 = Fixed::from_string ("0.000000000");
EXPECT ("0.00000000", f5);
EXPECT ("0.000000000", f6);
TEST_EQUAL (8, f5.fixed_scale ()); // these are not "normalized" since the
TEST_EQUAL (9, f6.fixed_scale ()); // caller explicitly requested this scale
Fixed f7 = Fixed::from_string ("0.1");
EXPECT ("0", f7.round (0));
EXPECT ("0", f7.truncate (0));
f7 = Fixed::from_string ("0.05");
EXPECT ("0.1", f7.round (1));
EXPECT ("0.0", f7.truncate (1));
f7 = Fixed::from_string ("-0.005");
EXPECT ("-0.01", f7.round (2));
EXPECT ("0.00", f7.truncate (2));
LongDouble ld1;
ACE_CDR_LONG_DOUBLE_ASSIGNMENT (ld1, 1234.45);
const Fixed f8 = Fixed::from_floating (ld1);
TEST_EQUAL (LongLong (1234), LongLong (f8));
LongDouble ld2;
ACE_CDR_LONG_DOUBLE_ASSIGNMENT (ld2, -0.3125);
const Fixed f9 = Fixed::from_floating (ld2);
EXPECT ("-0.3125", f9);
LongDouble ld3;
ACE_CDR_LONG_DOUBLE_ASSIGNMENT (ld3, 0.125);
const Fixed f10 = Fixed::from_floating (ld3);
EXPECT ("0.125", f10);
LongDouble ldzero = ACE_CDR_LONG_DOUBLE_INITIALIZER;
const Fixed fzero = Fixed::from_floating (ldzero);
EXPECT ("0", fzero);
ACE_CDR_LONG_DOUBLE_ASSIGNMENT(ldzero, 0);
const Fixed fzero2 = Fixed::from_floating(ldzero);
EXPECT("0", fzero2);
Fixed f11 = Fixed::from_integer (LongLong (-1l));
TEST_EQUAL (LongLong (-1), LongLong (f11));
TEST_EQUAL (false, !f11);
++f11;
TEST_EQUAL (true, !f11);
TEST_EQUAL (LongLong (0), LongLong (f11));
TEST_EQUAL (Fixed::from_integer (), f11);
f11 += Fixed::from_string ("0.124357891");
++f11;
TEST_EQUAL (Fixed::from_string ("1.124357891"), f11);
--f11;
--f11;
TEST_EQUAL (Fixed::from_string ("-0.875642109"), f11);
TEST_EQUAL (true, Fixed::from_integer (LongLong (-4)) < Fixed::from_integer (LongLong (2)));
TEST_EQUAL (true, Fixed::from_integer (LongLong (-4)) < Fixed::from_integer (LongLong (-2)));
TEST_EQUAL (false, Fixed::from_integer (LongLong (4)) < Fixed::from_integer (LongLong (-2)));
TEST_EQUAL (false, Fixed::from_integer (LongLong (4)) < Fixed::from_integer (LongLong (2)));
TEST_EQUAL (true, Fixed::from_string ("2.17") < Fixed::from_string ("3.142"));
TEST_EQUAL (true, Fixed::from_string ("10.1") < Fixed::from_string ("100"));
TEST_EQUAL (Fixed::from_string ("0000.000"), f5);
TEST_EQUAL (Fixed::from_string ("-0.00500"), f7);
TEST_EQUAL (f11, f11);
Fixed f12 = f11++;
TEST_EQUAL (++f12, f11);
Fixed f13 = f12--;
TEST_EQUAL (--f13, f12);
Fixed f14 = Fixed::from_integer (LongLong (9));
TEST_EQUAL (1, f14.fixed_digits ());
++f14;
TEST_EQUAL (Fixed::from_integer (LongLong (10)), f14);
TEST_EQUAL (Fixed::from_string ("778.33"),
Fixed::from_string ("12.9") + Fixed::from_string ("765.43"));
Fixed full = Fixed::from_string ("9876543210987654321098765432109"),
before = full;
full += Fixed::from_string ("0.99");
TEST_EQUAL (before, full); // no rounding
f14 += full;
const Fixed f15 = Fixed::from_string ("9876543210987654321098765432119");
TEST_EQUAL (f15, f14);
Fixed f16 = Fixed::from_string ("123.4567890123456789012345678901");
f16 += Fixed::from_integer (LongLong (9876));
const Fixed f17 = Fixed::from_string ("9999.456789012345678901234567890");
TEST_EQUAL (f17, f16);
Fixed f18 = Fixed::from_string ("197854191");
f18 -= Fixed::from_string ("123546789");
EXPECT ("74307402", f18);
TEST_EQUAL (8, f18.fixed_digits ());
Fixed f19 = Fixed::from_integer (LongLong (9));
f19 -= Fixed::from_integer (LongLong (10));
EXPECT ("-1", f19);
Fixed f20 = Fixed::from_integer (LongLong (99));
f20 += Fixed::from_integer (LongLong (99));
EXPECT ("198", f20); // carry extra digit
Fixed f21 = Fixed::from_string ("7.532");
f21 -= Fixed::from_string ("4.91");
EXPECT ("2.622", f21);
Fixed f22 = Fixed::from_integer (LongLong (-99)) * Fixed::from_integer (LongLong (-9));
EXPECT ("891", f22);
Fixed f23 = Fixed::from_integer (LongLong (9)) * Fixed::from_integer (LongLong (-99));
EXPECT ("-891", f23);
Fixed f24 = Fixed::from_string ("-3.4") * Fixed::from_string ("5.67");
EXPECT ("-19.278", f24);
Fixed f25 = Fixed::from_string ("9999999999.1234567890") // 10.10
* Fixed::from_string ("876543219087654321.9876543210");// 18.10
EXPECT ("8765432190108215212037174200.146", f25); // 28.3
// 1234567890123456789012345678901
Fixed f26 = Fixed::from_string ("0.0000000000000000000000000000001")
* Fixed::from_string ("0.1");
EXPECT ( "0.0000000000000000000000000000000", f26);
Fixed f27 = Fixed::from_string ("817459124");
f27 /= Fixed::from_string ("0.001");
EXPECT ("817459124000", f27);
f27 /= Fixed::from_integer (LongLong (1000));
EXPECT ("817459124", f27);
f27 /= Fixed::from_integer (LongLong (-2));
EXPECT ("-408729562", f27);
Fixed f28 = Fixed::from_string ("200000000");
f28 /= Fixed::from_string ("500");
EXPECT ("400000", f28);
TEST_EQUAL (6, f28.fixed_digits ());
Fixed f29 = Fixed::from_integer (LongLong (1)) / Fixed::from_integer (LongLong (-3));
EXPECT ("-0.333333333333333333333333333333", f29); //TODO: one more 3
ACE_END_TEST;
return failed;
}
