void Chapter9Test::Test9_10() { ofstream fout; OpenLogFile(fout, "test9_10.html", "Problem 9.10: implement a method to build the tallest stack"); vector<size_t> solution; double maxHeight(0.0); // 1. solution.clear(); maxHeight = sol.prob9_10({3.0,2.0,1.0}, {3.0,2.0,1.0}, {3.0,2.0,1.0}, solution); TestDouble(fout, "widths: {3,2,1}, heigths: {3,2,1}, depths: {3,2,1}", maxHeight, 6.0); TestDynamicArray(fout, "widths: {3,2,1}, heigths: {3,2,1}, depths: {3,2,1}", solution, {0,1,2}); // 2. solution.clear(); maxHeight = sol.prob9_10({1.0,3.0,4.0,1.0,7.0,8.0,3.0,3.0,2.0,1.0}, \ {5.0,2.0,3.0,1.0,8.0,12.0,2.0,3.0,2.0,1.0},\ {4.0,2.0,6.0,4.0,4.0,12.0,6.0,3.0,2.0,1.0}, solution); TestDouble(fout, "widths: {1.0,3.0,4.0,1.0,7.0,8.0,3.0,3.0,2.0,1.0}, heigths: {5.0,2.0,3.0,1.0,8.0,12.0,2.0,3.0,2.0,1.0}, depths: {4.0,2.0,6.0,4.0,4.0,12.0,6.0,3.0,2.0,1.0}", maxHeight, 26.0); TestDynamicArray(fout, "widths: {1.0,3.0,4.0,1.0,7.0,8.0,3.0,3.0,2.0,1.0}, heigths: {5.0,2.0,3.0,1.0,8.0,12.0,2.0,3.0,2.0,1.0}, depths: {4.0,2.0,6.0,4.0,4.0,12.0,6.0,3.0,2.0,1.0}", solution, {5,4,7,8,9}); // 3. solution.clear(); maxHeight = sol.prob9_10({1.0,3.0,4.0,1.0,7.0,8.0,3.0,3.0,2.0,1.0}, \ {5.0,2.0,3.0,1.0,8.0,7.0,2.0,3.0,2.0,1.0},\ {4.0,2.0,6.0,4.0,4.0,12.0,6.0,3.0,2.0,1.0}, solution); TestDouble(fout, "widths: {1.0,3.0,4.0,1.0,7.0,8.0,3.0,3.0,2.0,1.0}, heigths: {5.0,2.0,3.0,1.0,8.0,7.0,2.0,3.0,2.0,1.0}, depths: {4.0,2.0,6.0,4.0,4.0,12.0,6.0,3.0,2.0,1.0}", maxHeight, 14.0); TestDynamicArray(fout, "widths: {1.0,3.0,4.0,1.0,7.0,8.0,3.0,3.0,2.0,1.0}, heigths: {5.0,2.0,3.0,1.0,8.0,7.0,2.0,3.0,2.0,1.0}, depths: {4.0,2.0,6.0,4.0,4.0,12.0,6.0,3.0,2.0,1.0}", solution, {4,7,8,9}); CloseLogFile(fout); }
bool C_coretestBase::TestDouble(int callbackID, const Json::Value& parameters) { Json::Value testDouble_JSON; FetchObject(parameters, "testDouble", testDouble_JSON); double testDouble; FetchDouble(testDouble_JSON, testDouble); TestDouble(callbackID, testDouble); return true; }
void test_member_data_value_function() { p_member_data_value_class tcl; TestCharacter(tcl); TestInt(tcl); TestDouble(tcl); TestBool(tcl); TestPointer(tcl); TestEnum(tcl); TestPod(tcl); }
main() { /* Alpha/OSF (at least) requires us to request that SIGFPE be ignored */ signal(SIGFPE, SIG_IGN); /* First, some easy ones */ printf("\nEasy Ones\n"); TestDouble(1.0, 2.0); TestDouble(5.0, 2.0); TestHex(0x4010000000000000L, 0x400000000000001EL); TestHex(0x4030000000000000L, 0x400E200000000000L); /* How about negative inputs? */ printf("\nNegative Inputs\n"); TestDouble(3.0, -1.0); TestHex(0x430000000000000FL, 0xC00E000000000000L); TestHex(0xC00E00000000000FL, 0x430000000000000FL); TestDouble(-1.0, -2.0); TestHex(0xC30000000000000FL, 0x400E000000000000L); /* How about normalization? */ printf("\nNormalization\n"); TestDouble(1.0, 1.0); TestHex(0x400000000000000FL, 0xC000000000000000L); /* How about rounding? */ printf("\nRounding - 1 bit\n"); TestHex(0x4010000000000000L, 0x4000000000000000L); /* 1 bit shift */ TestHex(0x4010000000000000L, 0x4000000000000001L); TestHex(0x4010000000000001L, 0x4000000000000000L); TestHex(0x4010000000000001L, 0x4000000000000001L); printf("\nRounding - 2 bit\n"); TestHex(0x4020000000000000L, 0x4000000000000000L); /* 2 bit shift */ TestHex(0x4020000000000000L, 0x4000000000000001L); TestHex(0x4020000000000000L, 0x4000000000000002L); TestHex(0x4020000000000000L, 0x4000000000000003L); TestHex(0x4020000000000001L, 0x4000000000000000L); TestHex(0x4020000000000001L, 0x4000000000000001L); TestHex(0x4020000000000001L, 0x4000000000000002L); TestHex(0x4020000000000001L, 0x4000000000000003L); printf("\nRounding - 3 bit\n"); TestHex(0x4030000000000000L, 0x4000000000000000L); /* 3 bit shift */ TestHex(0x4030000000000000L, 0x4000000000000001L); TestHex(0x4030000000000000L, 0x4000000000000002L); TestHex(0x4030000000000000L, 0x4000000000000003L); TestHex(0x4030000000000000L, 0x4000000000000004L); TestHex(0x4030000000000000L, 0x4000000000000005L); TestHex(0x4030000000000000L, 0x4000000000000006L); TestHex(0x4030000000000000L, 0x4000000000000007L); TestHex(0x4030000000000001L, 0x4000000000000000L); TestHex(0x4030000000000001L, 0x4000000000000001L); TestHex(0x4030000000000001L, 0x4000000000000002L); TestHex(0x4030000000000001L, 0x4000000000000003L); TestHex(0x4030000000000001L, 0x4000000000000004L); TestHex(0x4030000000000001L, 0x4000000000000005L); TestHex(0x4030000000000001L, 0x4000000000000006L); TestHex(0x4030000000000001L, 0x4000000000000007L); printf("\nRounding - 4 bit\n"); TestHex(0x4040000000000000L, 0x4000000000000000L); /* 4 bit shift */ TestHex(0x4040000000000000L, 0x4000000000000001L); TestHex(0x4040000000000000L, 0x4000000000000002L); TestHex(0x4040000000000000L, 0x4000000000000003L); TestHex(0x4040000000000000L, 0x4000000000000004L); TestHex(0x4040000000000000L, 0x4000000000000005L); TestHex(0x4040000000000000L, 0x4000000000000006L); TestHex(0x4040000000000000L, 0x4000000000000007L); TestHex(0x4040000000000000L, 0x4000000000000008L); TestHex(0x4040000000000000L, 0x4000000000000009L); TestHex(0x4040000000000000L, 0x400000000000000AL); TestHex(0x4040000000000000L, 0x400000000000000BL); TestHex(0x4040000000000000L, 0x400000000000000CL); TestHex(0x4040000000000000L, 0x400000000000000DL); TestHex(0x4040000000000000L, 0x400000000000000EL); TestHex(0x4040000000000000L, 0x400000000000000FL); TestHex(0x4040000000000001L, 0x4000000000000000L); TestHex(0x4040000000000001L, 0x4000000000000001L); TestHex(0x4040000000000001L, 0x4000000000000002L); TestHex(0x4040000000000001L, 0x4000000000000003L); TestHex(0x4040000000000001L, 0x4000000000000004L); TestHex(0x4040000000000001L, 0x4000000000000005L); TestHex(0x4040000000000001L, 0x4000000000000006L); TestHex(0x4040000000000001L, 0x4000000000000007L); TestHex(0x4040000000000001L, 0x4000000000000008L); TestHex(0x4040000000000001L, 0x4000000000000009L); TestHex(0x4040000000000001L, 0x400000000000000AL); TestHex(0x4040000000000001L, 0x400000000000000BL); TestHex(0x4040000000000001L, 0x400000000000000CL); TestHex(0x4040000000000001L, 0x400000000000000DL); TestHex(0x4040000000000001L, 0x400000000000000EL); TestHex(0x4040000000000001L, 0x400000000000000FL); printf("\nRounding - sticky bit, etc\n"); TestHex(0x40A0000000000000L, 0x4000000000000201L); /* test sticky bit */ TestHex(0x4007FFFFFFFFFFFFL, 0x4340000000000000L); /* again */ TestHex(0x4040000000000001L, 0x4000000000000005L); /* subtract w/sticky */ TestHex(0x40AFF80000000000L, 0x400FFFFFFFFFFFFFL); /* rounding causes re-normalization */ TestHex(0x40AC000000000000L, 0x4004000000000005L); /* round or normalize result first? */ /* How about zero, NaN, infinity? */ printf("\nSpecial Cases - overflow\n"); TestHex(0x7FE0000000000000L, 0x7FE0000000000000L); /* overflow to +infinity */ TestHex(0xFFE0000000000000L, 0xFFE0000000000000L); /* overflow to -infinity */ printf("\nSpecial Cases - NaN in\n"); TestHex(0x7FF0000000000001L, 0x3FF0000000000000L); /* NaN plus 1 */ TestHex(0x3FF0000000000000L, 0x7FF1000000000000L); /* 1 plus NaN */ printf("\nSpecial Cases - NaN out\n"); TestHex(0x7FF0000000000000L, 0xFFF0000000000000L); /* +Infinity plus -Infinity */ printf("\nSpecial Cases - Infinity in\n"); TestHex(0x7FF0000000000000L, 0x3FF0000000000000L); /* +Infinity plus 1 */ TestHex(0x7FF0000000000000L, 0xBFF0000000000000L); /* +Infinity plus -1 */ TestHex(0xFFF0000000000000L, 0x3FF0000000000000L); /* -Infinity plus 1 */ TestHex(0xFFF0000000000000L, 0xBFF0000000000000L); /* -Infinity plus -1 */ printf("\nSpecial Cases - zero\n"); TestDouble(0.0, 1.0); TestDouble(1.0, -1.0); printf("\nDone.\n"); }