| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <sys/time.h> |
| #include <protocol/TBinaryProtocol.h> |
| #include <transport/TTransportUtils.h> |
| #include <transport/TSocket.h> |
| |
| #include <boost/shared_ptr.hpp> |
| #include "ThriftTest.h" |
| |
| #define __STDC_FORMAT_MACROS |
| #include <inttypes.h> |
| |
| using namespace boost; |
| using namespace std; |
| using namespace apache::thrift; |
| using namespace apache::thrift::protocol; |
| using namespace apache::thrift::transport; |
| using namespace thrift::test; |
| |
| //extern uint32_t g_socket_syscalls; |
| |
| // Current time, microseconds since the epoch |
| uint64_t now() |
| { |
| int64_t ret; |
| struct timeval tv; |
| |
| gettimeofday(&tv, NULL); |
| ret = tv.tv_sec; |
| ret = ret*1000*1000 + tv.tv_usec; |
| return ret; |
| } |
| |
| int main(int argc, char** argv) { |
| string host = "localhost"; |
| int port = 9090; |
| int numTests = 1; |
| bool framed = false; |
| |
| for (int i = 0; i < argc; ++i) { |
| if (strcmp(argv[i], "-h") == 0) { |
| char* pch = strtok(argv[++i], ":"); |
| if (pch != NULL) { |
| host = string(pch); |
| } |
| pch = strtok(NULL, ":"); |
| if (pch != NULL) { |
| port = atoi(pch); |
| } |
| } else if (strcmp(argv[i], "-n") == 0) { |
| numTests = atoi(argv[++i]); |
| } else if (strcmp(argv[i], "-f") == 0) { |
| framed = true; |
| } |
| } |
| |
| |
| shared_ptr<TBufferBase> transport; |
| |
| shared_ptr<TSocket> socket(new TSocket(host, port)); |
| |
| if (framed) { |
| shared_ptr<TFramedTransport> framedSocket(new TFramedTransport(socket)); |
| transport = framedSocket; |
| } else { |
| shared_ptr<TBufferedTransport> bufferedSocket(new TBufferedTransport(socket)); |
| transport = bufferedSocket; |
| } |
| |
| shared_ptr< TBinaryProtocolT<TBufferBase> > protocol( |
| new TBinaryProtocolT<TBufferBase>(transport)); |
| ThriftTestClientT< TBinaryProtocolT<TBufferBase> > testClient(protocol); |
| |
| uint64_t time_min = 0; |
| uint64_t time_max = 0; |
| uint64_t time_tot = 0; |
| |
| int test = 0; |
| for (test = 0; test < numTests; ++test) { |
| |
| try { |
| transport->open(); |
| } catch (TTransportException& ttx) { |
| printf("Connect failed: %s\n", ttx.what()); |
| continue; |
| } |
| |
| /** |
| * CONNECT TEST |
| */ |
| printf("Test #%d, connect %s:%d\n", test+1, host.c_str(), port); |
| |
| uint64_t start = now(); |
| |
| /** |
| * VOID TEST |
| */ |
| try { |
| printf("testVoid()"); |
| testClient.testVoid(); |
| printf(" = void\n"); |
| } catch (TApplicationException tax) { |
| printf("%s\n", tax.what()); |
| } |
| |
| /** |
| * STRING TEST |
| */ |
| printf("testString(\"Test\")"); |
| string s; |
| testClient.testString(s, "Test"); |
| printf(" = \"%s\"\n", s.c_str()); |
| |
| /** |
| * BYTE TEST |
| */ |
| printf("testByte(1)"); |
| uint8_t u8 = testClient.testByte(1); |
| printf(" = %d\n", (int)u8); |
| |
| /** |
| * I32 TEST |
| */ |
| printf("testI32(-1)"); |
| int32_t i32 = testClient.testI32(-1); |
| printf(" = %d\n", i32); |
| |
| /** |
| * I64 TEST |
| */ |
| printf("testI64(-34359738368)"); |
| int64_t i64 = testClient.testI64(-34359738368LL); |
| printf(" = %"PRId64"\n", i64); |
| |
| /** |
| * DOUBLE TEST |
| */ |
| printf("testDouble(-5.2098523)"); |
| double dub = testClient.testDouble(-5.2098523); |
| printf(" = %lf\n", dub); |
| |
| /** |
| * STRUCT TEST |
| */ |
| printf("testStruct({\"Zero\", 1, -3, -5})"); |
| Xtruct out; |
| out.string_thing = "Zero"; |
| out.byte_thing = 1; |
| out.i32_thing = -3; |
| out.i64_thing = -5; |
| Xtruct in; |
| testClient.testStruct(in, out); |
| printf(" = {\"%s\", %d, %d, %"PRId64"}\n", |
| in.string_thing.c_str(), |
| (int)in.byte_thing, |
| in.i32_thing, |
| in.i64_thing); |
| |
| /** |
| * NESTED STRUCT TEST |
| */ |
| printf("testNest({1, {\"Zero\", 1, -3, -5}), 5}"); |
| Xtruct2 out2; |
| out2.byte_thing = 1; |
| out2.struct_thing = out; |
| out2.i32_thing = 5; |
| Xtruct2 in2; |
| testClient.testNest(in2, out2); |
| in = in2.struct_thing; |
| printf(" = {%d, {\"%s\", %d, %d, %"PRId64"}, %d}\n", |
| in2.byte_thing, |
| in.string_thing.c_str(), |
| (int)in.byte_thing, |
| in.i32_thing, |
| in.i64_thing, |
| in2.i32_thing); |
| |
| /** |
| * MAP TEST |
| */ |
| map<int32_t,int32_t> mapout; |
| for (int32_t i = 0; i < 5; ++i) { |
| mapout.insert(make_pair(i, i-10)); |
| } |
| printf("testMap({"); |
| map<int32_t, int32_t>::const_iterator m_iter; |
| bool first = true; |
| for (m_iter = mapout.begin(); m_iter != mapout.end(); ++m_iter) { |
| if (first) { |
| first = false; |
| } else { |
| printf(", "); |
| } |
| printf("%d => %d", m_iter->first, m_iter->second); |
| } |
| printf("})"); |
| map<int32_t,int32_t> mapin; |
| testClient.testMap(mapin, mapout); |
| printf(" = {"); |
| first = true; |
| for (m_iter = mapin.begin(); m_iter != mapin.end(); ++m_iter) { |
| if (first) { |
| first = false; |
| } else { |
| printf(", "); |
| } |
| printf("%d => %d", m_iter->first, m_iter->second); |
| } |
| printf("}\n"); |
| |
| /** |
| * SET TEST |
| */ |
| set<int32_t> setout; |
| for (int32_t i = -2; i < 3; ++i) { |
| setout.insert(i); |
| } |
| printf("testSet({"); |
| set<int32_t>::const_iterator s_iter; |
| first = true; |
| for (s_iter = setout.begin(); s_iter != setout.end(); ++s_iter) { |
| if (first) { |
| first = false; |
| } else { |
| printf(", "); |
| } |
| printf("%d", *s_iter); |
| } |
| printf("})"); |
| set<int32_t> setin; |
| testClient.testSet(setin, setout); |
| printf(" = {"); |
| first = true; |
| for (s_iter = setin.begin(); s_iter != setin.end(); ++s_iter) { |
| if (first) { |
| first = false; |
| } else { |
| printf(", "); |
| } |
| printf("%d", *s_iter); |
| } |
| printf("}\n"); |
| |
| /** |
| * LIST TEST |
| */ |
| vector<int32_t> listout; |
| for (int32_t i = -2; i < 3; ++i) { |
| listout.push_back(i); |
| } |
| printf("testList({"); |
| vector<int32_t>::const_iterator l_iter; |
| first = true; |
| for (l_iter = listout.begin(); l_iter != listout.end(); ++l_iter) { |
| if (first) { |
| first = false; |
| } else { |
| printf(", "); |
| } |
| printf("%d", *l_iter); |
| } |
| printf("})"); |
| vector<int32_t> listin; |
| testClient.testList(listin, listout); |
| printf(" = {"); |
| first = true; |
| for (l_iter = listin.begin(); l_iter != listin.end(); ++l_iter) { |
| if (first) { |
| first = false; |
| } else { |
| printf(", "); |
| } |
| printf("%d", *l_iter); |
| } |
| printf("}\n"); |
| |
| /** |
| * ENUM TEST |
| */ |
| printf("testEnum(ONE)"); |
| Numberz::type ret = testClient.testEnum(Numberz::ONE); |
| printf(" = %d\n", ret); |
| |
| printf("testEnum(TWO)"); |
| ret = testClient.testEnum(Numberz::TWO); |
| printf(" = %d\n", ret); |
| |
| printf("testEnum(THREE)"); |
| ret = testClient.testEnum(Numberz::THREE); |
| printf(" = %d\n", ret); |
| |
| printf("testEnum(FIVE)"); |
| ret = testClient.testEnum(Numberz::FIVE); |
| printf(" = %d\n", ret); |
| |
| printf("testEnum(EIGHT)"); |
| ret = testClient.testEnum(Numberz::EIGHT); |
| printf(" = %d\n", ret); |
| |
| /** |
| * TYPEDEF TEST |
| */ |
| printf("testTypedef(309858235082523)"); |
| UserId uid = testClient.testTypedef(309858235082523LL); |
| printf(" = %"PRId64"\n", uid); |
| |
| /** |
| * NESTED MAP TEST |
| */ |
| printf("testMapMap(1)"); |
| map<int32_t, map<int32_t, int32_t> > mm; |
| testClient.testMapMap(mm, 1); |
| printf(" = {"); |
| map<int32_t, map<int32_t, int32_t> >::const_iterator mi; |
| for (mi = mm.begin(); mi != mm.end(); ++mi) { |
| printf("%d => {", mi->first); |
| map<int32_t, int32_t>::const_iterator mi2; |
| for (mi2 = mi->second.begin(); mi2 != mi->second.end(); ++mi2) { |
| printf("%d => %d, ", mi2->first, mi2->second); |
| } |
| printf("}, "); |
| } |
| printf("}\n"); |
| |
| /** |
| * INSANITY TEST |
| */ |
| Insanity insane; |
| insane.userMap.insert(make_pair(Numberz::FIVE, 5000)); |
| Xtruct truck; |
| truck.string_thing = "Truck"; |
| truck.byte_thing = 8; |
| truck.i32_thing = 8; |
| truck.i64_thing = 8; |
| insane.xtructs.push_back(truck); |
| printf("testInsanity()"); |
| map<UserId, map<Numberz::type,Insanity> > whoa; |
| testClient.testInsanity(whoa, insane); |
| printf(" = {"); |
| map<UserId, map<Numberz::type,Insanity> >::const_iterator i_iter; |
| for (i_iter = whoa.begin(); i_iter != whoa.end(); ++i_iter) { |
| printf("%"PRId64" => {", i_iter->first); |
| map<Numberz::type,Insanity>::const_iterator i2_iter; |
| for (i2_iter = i_iter->second.begin(); |
| i2_iter != i_iter->second.end(); |
| ++i2_iter) { |
| printf("%d => {", i2_iter->first); |
| map<Numberz::type, UserId> userMap = i2_iter->second.userMap; |
| map<Numberz::type, UserId>::const_iterator um; |
| printf("{"); |
| for (um = userMap.begin(); um != userMap.end(); ++um) { |
| printf("%d => %"PRId64", ", um->first, um->second); |
| } |
| printf("}, "); |
| |
| vector<Xtruct> xtructs = i2_iter->second.xtructs; |
| vector<Xtruct>::const_iterator x; |
| printf("{"); |
| for (x = xtructs.begin(); x != xtructs.end(); ++x) { |
| printf("{\"%s\", %d, %d, %"PRId64"}, ", |
| x->string_thing.c_str(), |
| (int)x->byte_thing, |
| x->i32_thing, |
| x->i64_thing); |
| } |
| printf("}"); |
| |
| printf("}, "); |
| } |
| printf("}, "); |
| } |
| printf("}\n"); |
| |
| /* test exception */ |
| |
| try { |
| printf("testClient.testException(\"Xception\") =>"); |
| testClient.testException("Xception"); |
| printf(" void\nFAILURE\n"); |
| |
| } catch(Xception& e) { |
| printf(" {%u, \"%s\"}\n", e.errorCode, e.message.c_str()); |
| } |
| |
| try { |
| printf("testClient.testException(\"success\") =>"); |
| testClient.testException("success"); |
| printf(" void\n"); |
| } catch(...) { |
| printf(" exception\nFAILURE\n"); |
| } |
| |
| /* test multi exception */ |
| |
| try { |
| printf("testClient.testMultiException(\"Xception\", \"test 1\") =>"); |
| Xtruct result; |
| testClient.testMultiException(result, "Xception", "test 1"); |
| printf(" result\nFAILURE\n"); |
| } catch(Xception& e) { |
| printf(" {%u, \"%s\"}\n", e.errorCode, e.message.c_str()); |
| } |
| |
| try { |
| printf("testClient.testMultiException(\"Xception2\", \"test 2\") =>"); |
| Xtruct result; |
| testClient.testMultiException(result, "Xception2", "test 2"); |
| printf(" result\nFAILURE\n"); |
| |
| } catch(Xception2& e) { |
| printf(" {%u, {\"%s\"}}\n", e.errorCode, e.struct_thing.string_thing.c_str()); |
| } |
| |
| try { |
| printf("testClient.testMultiException(\"success\", \"test 3\") =>"); |
| Xtruct result; |
| testClient.testMultiException(result, "success", "test 3"); |
| printf(" {{\"%s\"}}\n", result.string_thing.c_str()); |
| } catch(...) { |
| printf(" exception\nFAILURE\n"); |
| } |
| |
| /* test oneway void */ |
| { |
| printf("testClient.testOneway(3) =>"); |
| uint64_t startOneway = now(); |
| testClient.testOneway(3); |
| uint64_t elapsed = now() - startOneway; |
| if (elapsed > 200 * 1000) { // 0.2 seconds |
| printf(" FAILURE - took %.2f ms\n", (double)elapsed/1000.0); |
| } else { |
| printf(" success - took %.2f ms\n", (double)elapsed/1000.0); |
| } |
| } |
| |
| /** |
| * redo a simple test after the oneway to make sure we aren't "off by one" -- |
| * if the server treated oneway void like normal void, this next test will |
| * fail since it will get the void confirmation rather than the correct |
| * result. In this circumstance, the client will throw the exception: |
| * |
| * TApplicationException: Wrong method namea |
| */ |
| /** |
| * I32 TEST |
| */ |
| printf("re-test testI32(-1)"); |
| i32 = testClient.testI32(-1); |
| printf(" = %d\n", i32); |
| |
| |
| uint64_t stop = now(); |
| uint64_t tot = stop-start; |
| |
| printf("Total time: %"PRIu64" us\n", stop-start); |
| |
| time_tot += tot; |
| if (time_min == 0 || tot < time_min) { |
| time_min = tot; |
| } |
| if (tot > time_max) { |
| time_max = tot; |
| } |
| |
| transport->close(); |
| } |
| |
| // printf("\nSocket syscalls: %u", g_socket_syscalls); |
| printf("\nAll tests done.\n"); |
| |
| uint64_t time_avg = time_tot / numTests; |
| |
| printf("Min time: %"PRIu64" us\n", time_min); |
| printf("Max time: %"PRIu64" us\n", time_max); |
| printf("Avg time: %"PRIu64" us\n", time_avg); |
| |
| return 0; |
| } |